@neuraloom/contracts 0.0.0-stage → 0.1.23

package/dist/schemas/cortex/bridge-events.schema.js

@@ -0,0 +1,828 @@
+"use strict";
+/**
+ * Cortex × NeuraLoom bridge event payloads + ingestion receipts (v1.0.0).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubReadResultSchema = exports.githubReadRequestSchema = exports.CodexRunnerCredentialRequestSchema = exports.CodexExecutorRuntimeResultPayloadSchema = exports.CodexExecutorRuntimeRequestPayloadSchema = exports.CodexExecutorWorkflowResultPayloadSchema = exports.CodexExecutorWorkflowRequestPayloadSchema = exports.CodexExecutorAuthorizationResultPayloadSchema = exports.CodexExecutorAuthorizationRequestPayloadSchema = exports.CodexExecutorRuntimeJobSchema = exports.CodexSignedSandboxWorkerPayloadSchema = exports.CodexSignedWorkerPayloadSchema = exports.CodexExecutorApprovedScopeSchema = exports.CodexExecutorRuntimeIdentitySchema = exports.CortexBridgeIngestionReceiptApiResponseSchema = exports.NeuraloomIngestionReceiptPayloadSchema = exports.CortexIngestionReceiptPayloadSchema = exports.ProductReleasePackageMvpBridgePayloadSchema = exports.DocDriftDetectedPayloadSchema = exports.DocDraftReadyPayloadSchema = exports.GuardianViolationEventPayloadSchema = exports.EngineeringCheckpointRecordedPayloadSchema = exports.EngineeringCheckpointVerificationSummarySchema = exports.EngineeringCheckpointRevisionSummarySchema = exports.ProofRunRecordedPayloadSchema = exports.PullRequestReadyPayloadSchema = exports.ImplementationPlanReadyPayloadSchema = exports.RepoFindingTaskPayloadSchema = exports.RepoIntelligenceResultPayloadSchema = exports.FindingReconciliationEvidenceSchema = exports.REPO_INTEL_ACTIVE_FINDING_IDS_MAX = exports.NeuraloomGraphGapsSchema = exports.NEURALOOM_GRAPH_GAPS_MAX_NODES = exports.NeuraloomGraphGapNodeSchema = exports.NeuraloomGraphGapStatusSchema = exports.NeuraloomGraphGapSeveritySchema = exports.NEURALOOM_GRAPH_GAPS_VERSION = exports.TaskGithubIssueRequestPayloadSchema = exports.EngineeringIssueResolutionPayloadSchema = exports.EngineeringIssueRecoveryReceiptSchema = exports.EngineeringIssueRecoveryProofSchema = exports.CortexTaskGithubIssuePointerSchema = exports.PortfolioRepoLinkPayloadSchema = exports.CreativeWorkflowResultPayloadSchema = exports.BrandContextLineageSchema = exports.CreativeWorkflowRequestPayloadSchema = exports.RepoIntelligenceRequestPayloadSchema = exports.BridgeIngestionReceiptStatusSchema = exports.BridgeProofKindSchema = exports.BridgeFindingSeveritySchema = void 0;
+exports.BRIDGE_EVENT_PAYLOAD_SCHEMAS = void 0;
+exports.githubIssueUrlMatches = githubIssueUrlMatches;
+const zod_1 = require("zod");
+const film_bridge_events_schema_1 = require("./film-bridge-events.schema");
+const product_release_package_schema_1 = require("./product-release-package.schema");
+const engineering_context_schema_1 = require("../workflow/engineering-context.schema");
+// ─── Shared primitives ────────────────────────────────────────────────────────
+exports.BridgeFindingSeveritySchema = zod_1.z.enum([
+    'critical',
+    'high',
+    'medium',
+    'low',
+    'info',
+]);
+exports.BridgeProofKindSchema = zod_1.z.enum(['browser', 'artifact', 'ci']);
+exports.BridgeIngestionReceiptStatusSchema = zod_1.z.enum([
+    'accepted',
+    'duplicate',
+    'rejected',
+]);
+// ─── Cortex → NeuraLoom ───────────────────────────────────────────────────────
+exports.RepoIntelligenceRequestPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    requestKind: zod_1.z.enum(['full_scan', 'incremental_scan', 'drift_only']),
+    repoFullName: zod_1.z.string().min(1),
+    defaultBranch: zod_1.z.string().min(1).optional(),
+    scanDepth: zod_1.z.enum(['standard', 'deep']).default('standard'),
+    includeEmbeddings: zod_1.z.boolean().default(false),
+    engineeringIssueResolution: zod_1.z.lazy(() => exports.EngineeringIssueResolutionPayloadSchema).optional(),
+    correlationId: zod_1.z.string().optional(),
+})
+    .strict();
+exports.CreativeWorkflowRequestPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    workflowKind: zod_1.z.enum([
+        'software_app',
+        'film_production',
+        'nonfiction_book',
+        'research_report',
+    ]),
+    neuraloomProjectId: zod_1.z.string().uuid(),
+    requestedStepId: zod_1.z.string().min(1),
+    operatorNotes: zod_1.z.string().optional(),
+    correlationId: zod_1.z.string().optional(),
+    brandContext: zod_1.z
+        .object({
+        schema_version: zod_1.z.literal('1.0.0'),
+        generated_at: zod_1.z.string().datetime(),
+        brand_id: zod_1.z.string().uuid(),
+        brand_slug: zod_1.z.string().min(1),
+        graph_version_id: zod_1.z.string().uuid(),
+        marketing_profile_version_id: zod_1.z.string().uuid(),
+        configuration: zod_1.z.record(zod_1.z.unknown()),
+        claims: zod_1.z.array(zod_1.z.object({
+            id: zod_1.z.string().uuid(),
+            claim_kind: zod_1.z.string().min(1),
+            claim_text: zod_1.z.string().min(1),
+            severity: zod_1.z.string().min(1),
+            rationale: zod_1.z.string().nullable().optional(),
+            metadata: zod_1.z.record(zod_1.z.unknown()).default({}),
+        }).strict()),
+        policy: zod_1.z.object({
+            authority: zod_1.z.literal('cortex'),
+            allow_generated_logos: zod_1.z.literal(false),
+            require_canonical_logo_for_branded_visuals: zod_1.z.literal(true),
+            external_publish_requires_human_approval: zod_1.z.literal(true),
+            allowed_asset_ids: zod_1.z.array(zod_1.z.string().uuid()),
+            required_lineage_fields: zod_1.z.array(zod_1.z.enum([
+                'context_hash',
+                'brand_id',
+                'brand_slug',
+                'graph_version_id',
+                'marketing_profile_version_id',
+                'used_assets',
+            ])),
+        }).strict(),
+        context_hash: zod_1.z.string().regex(/^[a-f0-9]{64}$/i),
+    })
+        .strict(),
+})
+    .strict();
+exports.BrandContextLineageSchema = zod_1.z.object({
+    schema_version: zod_1.z.literal('1.0.0'),
+    context_hash: zod_1.z.string().regex(/^[a-f0-9]{64}$/i),
+    brand_id: zod_1.z.string().uuid(),
+    brand_slug: zod_1.z.string().min(1),
+    graph_version_id: zod_1.z.string().uuid(),
+    marketing_profile_version_id: zod_1.z.string().uuid(),
+    output_kind: zod_1.z.enum(['copy', 'image', 'video', 'document', 'campaign']),
+    used_assets: zod_1.z.array(zod_1.z.object({
+        asset_id: zod_1.z.string().uuid(),
+        checksum_sha256: zod_1.z.string().regex(/^[a-f0-9]{64}$/i).nullable().optional(),
+    }).strict()),
+    generated_logo: zod_1.z.boolean().default(false),
+    lineage_complete: zod_1.z.boolean(),
+}).strict();
+exports.CreativeWorkflowResultPayloadSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    neuraloomProjectId: zod_1.z.string().uuid(),
+    workflowArtifactId: zod_1.z.string().uuid(),
+    workflowStepId: zod_1.z.string().min(1),
+    artifactType: zod_1.z.string().min(1),
+    status: zod_1.z.literal('accepted'),
+    lineage: exports.BrandContextLineageSchema,
+}).strict();
+exports.PortfolioRepoLinkPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    portfolioId: zod_1.z.string().uuid(),
+    repoFullName: zod_1.z.string().min(1),
+    defaultBranch: zod_1.z.string().min(1),
+    linkRole: zod_1.z.enum(['primary', 'mirror', 'reference']),
+    neuraloomProjectId: zod_1.z.string().uuid().optional(),
+    correlationId: zod_1.z.string().optional(),
+})
+    .strict();
+function githubIssueUrlMatches(url, repoFullName, number) {
+    const parts = /^https:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/issues\/([1-9][0-9]*)$/.exec(url);
+    return parts !== null && Number.isSafeInteger(number) && number > 0 &&
+        `${parts[1]}/${parts[2]}`.toLowerCase() === repoFullName.toLowerCase() &&
+        parts[3] === String(number);
+}
+/** Explicit GitHub lineage; repository and remote issue existence are checked by the projector. */
+exports.CortexTaskGithubIssuePointerSchema = zod_1.z.object({
+    number: zod_1.z.number().int().positive(),
+    url: zod_1.z.string().url(),
+    epic: zod_1.z.object({
+        repoFullName: zod_1.z.string().min(1),
+        number: zod_1.z.number().int().positive(),
+        url: zod_1.z.string().url(),
+    }).strict(),
+}).strict().superRefine((pointer, context) => {
+    if (!githubIssueUrlMatches(pointer.epic.url, pointer.epic.repoFullName, pointer.epic.number)) {
+        context.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['epic', 'url'], message: 'Epic URL must match its repository and issue number' });
+    }
+});
+/** Exact original wire bytes bind caller evidence to the immutable authenticated delivery. */
+exports.EngineeringIssueRecoveryProofSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    originalEventId: zod_1.z.string().uuid(),
+    originalIdempotencyKey: zod_1.z.string().min(1),
+    originalPayloadHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+    scanRunId: zod_1.z.string().uuid(),
+    snapshotArtifactId: zod_1.z.string().uuid(),
+    commitSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+    originalEnvelopeBody: zod_1.z.string().min(1).max(32_768).refine(value => new TextEncoder().encode(value).byteLength <= 32_768, 'Original envelope exceeds UTF8 byte bound'),
+}).strict();
+exports.EngineeringIssueRecoveryReceiptSchema = exports.EngineeringIssueRecoveryProofSchema.extend({
+    githubIssue: exports.CortexTaskGithubIssuePointerSchema,
+    neuraloomTaskId: zod_1.z.string().uuid(),
+    cortexTaskId: zod_1.z.string().uuid(),
+    findingId: zod_1.z.string().min(1),
+    canonicalFindingId: zod_1.z.string().min(1),
+    repoFullName: zod_1.z.string().min(1),
+    neuraloomProjectId: zod_1.z.string().uuid(),
+    brandSlug: zod_1.z.string().min(1),
+    productSlug: zod_1.z.string().min(1).optional(),
+}).strict().superRefine((receipt, context) => {
+    if (!githubIssueUrlMatches(receipt.githubIssue.url, receipt.repoFullName, receipt.githubIssue.number)) {
+        context.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['githubIssue'], message: 'Recovery issue must match repository' });
+    }
+});
+exports.EngineeringIssueResolutionPayloadSchema = zod_1.z.object({
+    cortexTaskId: zod_1.z.string().uuid(),
+    findingId: zod_1.z.string().min(1),
+    title: zod_1.z.string().min(1).max(256),
+    body: zod_1.z.string().min(1),
+    labels: zod_1.z.array(zod_1.z.string().min(1)),
+    priority: zod_1.z.enum(['low', 'medium', 'high', 'urgent']),
+    epic: zod_1.z.object({ repoFullName: zod_1.z.string().min(1), number: zod_1.z.number().int().positive(), url: zod_1.z.string().url() }).strict(),
+    githubIssue: exports.CortexTaskGithubIssuePointerSchema.optional(),
+    recovery: exports.EngineeringIssueRecoveryProofSchema.optional(),
+}).strict().superRefine((resolution, context) => {
+    if (!githubIssueUrlMatches(resolution.epic.url, resolution.epic.repoFullName, resolution.epic.number)) {
+        context.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['epic', 'url'], message: 'Epic URL must match its repository and issue number' });
+    }
+    if (resolution.githubIssue !== undefined && (resolution.githubIssue.epic.repoFullName.toLowerCase() !== resolution.epic.repoFullName.toLowerCase() ||
+        resolution.githubIssue.epic.number !== resolution.epic.number ||
+        resolution.githubIssue.epic.url.toLowerCase() !== resolution.epic.url.toLowerCase())) {
+        context.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['githubIssue', 'epic'], message: 'Existing issue must belong to the selected epic' });
+    }
+});
+exports.TaskGithubIssueRequestPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    /** Cortex `graph.tasks.id` — carried through as the fingerprint/dedupe key and the receipt task linkage. */
+    cortexTaskId: zod_1.z.string().uuid(),
+    githubIssue: exports.CortexTaskGithubIssuePointerSchema.optional(),
+    repoFullName: zod_1.z.string().min(1),
+    title: zod_1.z.string().min(1).max(256),
+    body: zod_1.z.string().min(1),
+    labels: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    priority: zod_1.z.enum(['low', 'medium', 'high', 'urgent']).default('medium'),
+    sourceUrl: zod_1.z.string().url().optional(),
+    correlationId: zod_1.z.string().optional(),
+})
+    .strict()
+    .superRefine((payload, context) => {
+    if (payload.githubIssue !== undefined && !githubIssueUrlMatches(payload.githubIssue.url, payload.repoFullName, payload.githubIssue.number)) {
+        context.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['githubIssue', 'url'], message: 'Issue URL must match the task repository and issue number' });
+    }
+});
+// ─── NeuraLoom → Cortex ───────────────────────────────────────────────────────
+/**
+ * Graph gap nodes (Cortex epic 1019 slice 3) — an OPTIONAL, versioned block on
+ * `RepoIntelligenceResult`. Byte-compatible mirror of Cortex
+ * `neuraloomGraphGapsSchema` (`packages/contracts/src/schemas/codebase-health.ts`
+ * in NeuroNetIQ/cortex): same keys, same bounds, same regexes, `.strict()`.
+ *
+ * Cortex mints one `graph.tasks` row per `open` (nodeId, gapCode) and completes
+ * that task when a later payload reports the same (nodeId, gapCode) `resolved`.
+ * A node absent from a later payload is never read as resolved, so `nodeId`
+ * and `gapCode` must be stable across scans. Omitting the block keeps the
+ * payload valid for Cortex builds that predate slice 3 (nothing minted/closed).
+ */
+exports.NEURALOOM_GRAPH_GAPS_VERSION = '1.0.0';
+/** Cortex `FINDING_SEVERITY` (P0 urgent … P3 low) — distinct from `BridgeFindingSeveritySchema`. */
+exports.NeuraloomGraphGapSeveritySchema = zod_1.z.enum(['P0', 'P1', 'P2', 'P3']);
+exports.NeuraloomGraphGapStatusSchema = zod_1.z.enum(['open', 'resolved']);
+exports.NeuraloomGraphGapNodeSchema = zod_1.z
+    .object({
+    /** Stable NeuraLoom graph node id (identical across rescans). */
+    nodeId: zod_1.z
+        .string()
+        .trim()
+        .min(1)
+        .max(200)
+        .regex(/^[^\s|]+$/, 'must not contain whitespace or "|"'),
+    /** Stable gap code within the node, e.g. `not_wired`, `missing_test`. */
+    gapCode: zod_1.z
+        .string()
+        .trim()
+        .min(1)
+        .max(120)
+        .regex(/^[a-z0-9][a-z0-9._-]*$/i, 'must be a slug/code (letters, digits, . _ -)'),
+    status: exports.NeuraloomGraphGapStatusSchema,
+    title: zod_1.z.string().trim().min(1).max(200),
+    nextAction: zod_1.z.string().trim().min(1).max(500),
+    severity: exports.NeuraloomGraphGapSeveritySchema.default('P2'),
+    /** Absolute NeuraLoom URL of the node (evidence deep link). */
+    evidenceUrl: zod_1.z.string().url(),
+})
+    .strict();
+/** Cortex caps a block at 200 nodes; the sender must never exceed it. */
+exports.NEURALOOM_GRAPH_GAPS_MAX_NODES = 200;
+exports.NeuraloomGraphGapsSchema = zod_1.z
+    .object({
+    graphGapsVersion: zod_1.z.literal(exports.NEURALOOM_GRAPH_GAPS_VERSION),
+    /** NeuraLoom `execution_runs.id` whose state produced this block (null when none). */
+    executionRunId: zod_1.z.string().uuid().nullable(),
+    /** Absolute NeuraLoom project URL for the task deep link. */
+    projectUrl: zod_1.z.string().url().optional(),
+    nodes: zod_1.z.array(exports.NeuraloomGraphGapNodeSchema).max(exports.NEURALOOM_GRAPH_GAPS_MAX_NODES),
+})
+    .strict();
+/** Upper bound on `RepoIntelligenceResult.activeFindingIds` (byte-compatible with the Cortex mirror). */
+exports.REPO_INTEL_ACTIVE_FINDING_IDS_MAX = 2000;
+exports.FindingReconciliationEvidenceSchema = zod_1.z.object({
+    /** Categories whose complete detector family actually ran for this repository and scope. */
+    coveredCategories: zod_1.z.array(zod_1.z.string().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/i)).max(128)
+        .refine(categories => new Set(categories).size === categories.length, 'Covered categories must be unique').optional(),
+    version: zod_1.z.literal(1), scanId: zod_1.z.string().min(1), projectId: zod_1.z.string().min(1), repositoryId: zod_1.z.string().min(1),
+    branch: zod_1.z.string().min(1), commitSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/i),
+    startedAt: zod_1.z.string().datetime(), completedAt: zod_1.z.string().datetime(),
+    activeSet: zod_1.z.object({ complete: zod_1.z.literal(true), total: zod_1.z.number().int().nonnegative(), idsHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict(),
+    coverage: zod_1.z.object({ policyHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/), detectorSetHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/), scopeHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict(),
+}).strict().refine((value) => Date.parse(value.startedAt) <= Date.parse(value.completedAt), 'Scan completion precedes start');
+exports.RepoIntelligenceResultPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    scanStatus: zod_1.z.enum(['passed', 'warning', 'failed']),
+    repoFullName: zod_1.z.string().min(1),
+    commitSha: zod_1.z.string().min(7),
+    branch: zod_1.z.string().min(1),
+    scanMode: zod_1.z.enum(['standard', 'deep']),
+    counts: zod_1.z
+        .object({
+        filesIndexed: zod_1.z.number().int().min(0),
+        routesDetected: zod_1.z.number().int().min(0),
+        apiHandlersDetected: zod_1.z.number().int().min(0),
+        contractsDetected: zod_1.z.number().int().min(0),
+        migrationsDetected: zod_1.z.number().int().min(0),
+        driftFindings: zod_1.z.number().int().min(0),
+        orphanFindings: zod_1.z.number().int().min(0),
+    })
+        .strict(),
+    repoIntelSnapshotArtifactId: zod_1.z.string().uuid().optional(),
+    codeRealityGraphSnapshotArtifactId: zod_1.z.string().uuid().optional(),
+    knowledgeGraphSubgraphId: zod_1.z.string().optional(),
+    manifestPath: zod_1.z.string().optional(),
+    contentHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/i).optional(),
+    /** Optional, versioned graph gap nodes (epic 1019 slice 3); see `NeuraloomGraphGapsSchema`. */
+    graphGaps: exports.NeuraloomGraphGapsSchema.optional(),
+    /**
+     * Ids of ALL observed findings, including low severity, present in the
+     * completed scan that produced this result — independent of the per-scan
+     * `RepoFindingTask` emit cap, so it is the complete "still open" set even when
+     * only a page of `RepoFindingTask` events was emitted (NeuraLoom-Mono issue 1825).
+     * Cortex closes its `source='neuraloom'` finding tasks whose finding id is absent
+     * from this list. Sent only for a completed scan; omitted when findings are
+     * unavailable. Sorted severity → runtime scope → id; omitted when the complete
+     * set exceeds `REPO_INTEL_ACTIVE_FINDING_IDS_MAX`. Absence alone is not proof
+     * of a fix: reconciliation also requires authoritative comparable coverage.
+     */
+    activeFindingIds: zod_1.z.array(zod_1.z.string().min(1)).max(exports.REPO_INTEL_ACTIVE_FINDING_IDS_MAX).optional(),
+    reconciliationEvidence: exports.FindingReconciliationEvidenceSchema.optional(),
+})
+    .strict();
+exports.RepoFindingTaskPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    findingId: zod_1.z.string().min(1),
+    /** Explicit scoped aliases for migrating legacy display-derived identities. */
+    legacyFindingIds: zod_1.z.array(zod_1.z.string().min(1).max(2048)).max(4)
+        .refine(ids => new Set(ids).size === ids.length, 'Legacy finding IDs must be unique')
+        .optional(),
+    severity: exports.BridgeFindingSeveritySchema,
+    category: zod_1.z.string().min(1),
+    title: zod_1.z.string().min(1),
+    evidence: zod_1.z.string().min(1),
+    recommendedFix: zod_1.z.string().min(1),
+    route: zod_1.z.string().optional(),
+    apiPath: zod_1.z.string().optional(),
+    component: zod_1.z.string().optional(),
+    testPath: zod_1.z.string().optional(),
+    filePath: zod_1.z.string().optional(),
+    firstSeenScanId: zod_1.z.string().min(1),
+    lastSeenScanId: zod_1.z.string().min(1),
+})
+    .strict();
+exports.ImplementationPlanReadyPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    planArtifactId: zod_1.z.string().uuid(),
+    neuraloomProjectId: zod_1.z.string().uuid(),
+    executionRunId: zod_1.z.string().uuid().optional(),
+    taskIds: zod_1.z.array(zod_1.z.string().uuid()),
+    findingIds: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    /**
+     * Stable Cortex task-ledger finding id, `impl-plan:<neuraloomProjectId>:<planArtifactId>`,
+     * keyed on the accepted plan artifact rather than the run id (issue #1793). A
+     * re-emission for the same accepted plan carries the same `findingId` so Cortex
+     * updates one task instead of minting a fresh one per emission. Optional so older
+     * Cortex readers that only key off `executionRunId` (kept above, unchanged) still work.
+     */
+    findingId: zod_1.z.string().min(1).optional(),
+})
+    .strict();
+exports.PullRequestReadyPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    patchSetId: zod_1.z.string().uuid(),
+    pullRequestNumber: zod_1.z.number().int().positive(),
+    pullRequestUrl: zod_1.z.string().url(),
+    branchName: zod_1.z.string().min(1),
+    neuraloomProjectId: zod_1.z.string().uuid(),
+    taskIds: zod_1.z.array(zod_1.z.string().uuid()),
+    planArtifactId: zod_1.z.string().uuid().optional(),
+    commitSha: zod_1.z.string().min(7).optional(),
+    executionRunId: zod_1.z.string().uuid().optional(),
+})
+    .strict();
+exports.ProofRunRecordedPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    proofKind: exports.BridgeProofKindSchema,
+    proofRunId: zod_1.z.string().uuid(),
+    neuraloomProjectId: zod_1.z.string().uuid(),
+    workflowStepId: zod_1.z.string().min(1).optional(),
+    evidencePath: zod_1.z.string().min(1),
+    summary: zod_1.z.string().min(1),
+    passed: zod_1.z.boolean(),
+    recordedAt: zod_1.z.string().datetime(),
+    browserSessionId: zod_1.z.string().optional(),
+    ciRunUrl: zod_1.z.string().url().optional(),
+    artifactId: zod_1.z.string().uuid().optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.proofKind === 'browser' && value.browserSessionId === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'browser proof requires browserSessionId',
+            path: ['browserSessionId'],
+        });
+    }
+    if (value.proofKind === 'ci' && value.ciRunUrl === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'ci proof requires ciRunUrl',
+            path: ['ciRunUrl'],
+        });
+    }
+    if (value.proofKind === 'artifact' && value.artifactId === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'artifact proof requires artifactId',
+            path: ['artifactId'],
+        });
+    }
+});
+/**
+ * Summary of one participating repository at the checkpoint revision. A pointer
+ * summary only — uncommitted file lists and installed versions stay in NeuraLoom.
+ */
+exports.EngineeringCheckpointRevisionSummarySchema = engineering_context_schema_1.RevisionMapEntrySchema.pick({
+    repo: true,
+    commit: true,
+    branch: true,
+    dirty: true,
+}).strict();
+/** Verification result counts by `VerificationStatusSchema` value. */
+exports.EngineeringCheckpointVerificationSummarySchema = zod_1.z
+    .object({
+    passed: zod_1.z.number().int().min(0),
+    failed: zod_1.z.number().int().min(0),
+    blocked: zod_1.z.number().int().min(0),
+    not_run: zod_1.z.number().int().min(0),
+})
+    .strict();
+/**
+ * EngineeringCheckpointRecorded — NeuraLoom owns the checkpoint, evidence,
+ * patches and verification; Cortex owns the task. This payload lets Cortex
+ * store a POINTER on its `graph.tasks` row (execution run + latest checkpoint
+ * by id, revision consistency, next action) without mirroring execution state
+ * into a second writable system. No evidence content is carried.
+ */
+exports.EngineeringCheckpointRecordedPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    /** Cortex `graph.tasks.id` the engineering task was requested for. */
+    cortexTaskId: zod_1.z.string().min(1),
+    neuraloomProjectId: zod_1.z.string().uuid(),
+    /** NeuraLoom engineering task id (`TaskCheckpointPayload.taskId`). */
+    taskId: zod_1.z.string().min(1),
+    executionRunId: zod_1.z.string().uuid().nullable(),
+    /** execution_tasks.id the checkpoint is persisted on (single persistence path). */
+    executionTaskId: zod_1.z.string().uuid(),
+    sequence: zod_1.z.number().int().min(0),
+    milestone: zod_1.z.string().min(1),
+    nextAction: zod_1.z.string().min(1),
+    revisionMap: zod_1.z.array(exports.EngineeringCheckpointRevisionSummarySchema).min(1),
+    /** Primary repo commit the task asked for (from the checkpoint revision map). */
+    requestedRevision: zod_1.z.string().min(1).nullable(),
+    /** Commit of the code-reality graph the evidence was drawn from. */
+    indexedRevision: zod_1.z.string().min(1).nullable(),
+    evidenceCount: zod_1.z.number().int().min(0),
+    invalidatedEvidenceCount: zod_1.z.number().int().min(0),
+    verificationSummary: exports.EngineeringCheckpointVerificationSummarySchema,
+    recordedAt: zod_1.z.string().datetime(),
+})
+    .strict();
+exports.GuardianViolationEventPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    ruleId: zod_1.z.string().min(1),
+    severity: exports.BridgeFindingSeveritySchema,
+    score: zod_1.z.number().min(0).max(100),
+    threshold: zod_1.z.number().min(0).max(100),
+    message: zod_1.z.string().min(1),
+    artifactType: zod_1.z.string().optional(),
+    artifactId: zod_1.z.string().uuid().optional(),
+    neuraloomProjectId: zod_1.z.string().uuid().optional(),
+    evidenceRefs: zod_1.z.array(zod_1.z.string()).default([]),
+})
+    .strict();
+exports.DocDraftReadyPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    docKind: zod_1.z.enum([
+        'tutorial',
+        'runbook',
+        'api_reference',
+        'operator_guide',
+        'operatorManual',
+        'onboardingGuide',
+        'faqDraft',
+        'releaseNotesDraft',
+        'troubleshootingGuide',
+        'salesEnablementDraft',
+        'supportArticleDraft',
+        'trainingScriptDraft',
+    ]),
+    docSlug: zod_1.z.string().min(1),
+    title: zod_1.z.string().min(1),
+    draftPath: zod_1.z.string().min(1),
+    groundedSources: zod_1.z.array(zod_1.z.string()).min(1),
+    neuraloomProjectId: zod_1.z.string().uuid().optional(),
+})
+    .strict();
+exports.DocDriftDetectedPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    docSlug: zod_1.z.string().min(1),
+    driftKind: zod_1.z.enum(['missing_source', 'stale_content', 'claim_mismatch']),
+    detectedAt: zod_1.z.string().datetime(),
+    summary: zod_1.z.string().min(1),
+    revokedClaimIds: zod_1.z.array(zod_1.z.string()).default([]),
+})
+    .strict();
+exports.ProductReleasePackageMvpBridgePayloadSchema = product_release_package_schema_1.ProductReleasePackageMvpSchema;
+// ─── Receipts (both directions) ───────────────────────────────────────────────
+exports.CortexIngestionReceiptPayloadSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal('1.0.0'),
+    receiptId: zod_1.z.string().uuid(),
+    eventId: zod_1.z.string().uuid(),
+    idempotencyKey: zod_1.z.string().min(1),
+    status: exports.BridgeIngestionReceiptStatusSchema,
+    reason: zod_1.z.string().optional(),
+    receivedAt: zod_1.z.string().datetime(),
+    normalizedCandidateId: zod_1.z.string().optional(),
+    githubIssue: exports.CortexTaskGithubIssuePointerSchema.optional(),
+    neuraloomTaskId: zod_1.z.string().uuid().optional(),
+    engineeringRecovery: exports.EngineeringIssueRecoveryReceiptSchema.optional(),
+})
+    .strict().superRefine((receipt, context) => {
+    const recovery = receipt.engineeringRecovery;
+    if (recovery && (JSON.stringify(receipt.githubIssue) !== JSON.stringify(recovery.githubIssue) ||
+        receipt.neuraloomTaskId !== recovery.neuraloomTaskId || receipt.normalizedCandidateId !== recovery.scanRunId)) {
+        context.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['engineeringRecovery'], message: 'Recovery must agree with outer receipt pointers and scan' });
+    }
+});
+exports.NeuraloomIngestionReceiptPayloadSchema = exports.CortexIngestionReceiptPayloadSchema;
+exports.CortexBridgeIngestionReceiptApiResponseSchema = zod_1.z
+    .object({
+    receipt: exports.NeuraloomIngestionReceiptPayloadSchema,
+})
+    .strict();
+exports.CodexExecutorRuntimeIdentitySchema = zod_1.z.object({
+    kind: zod_1.z.literal('vercel_sandbox'),
+    workerRepoFullName: zod_1.z.string().regex(/^NeuroNetIQ\/[A-Za-z0-9_.-]+$/i),
+    workerSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+    workerPath: zod_1.z.literal('scripts/agent-executors/codex-worker.mjs'),
+    runtimeConfigHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+    nodeVersion: zod_1.z.literal('24.18.0'),
+    codexSdkVersion: zod_1.z.literal('0.160.0'),
+    sandboxSdkVersion: zod_1.z.literal('3.5.1'),
+}).strict();
+/** Canonical worker scope mirror used solely to verify Cortex's current approval. */
+exports.CodexExecutorApprovedScopeSchema = zod_1.z.object({
+    version: zod_1.z.literal(1), executor: zod_1.z.literal('codex'), runtime: exports.CodexExecutorRuntimeIdentitySchema.optional(),
+    planRunId: zod_1.z.string().uuid(), taskId: zod_1.z.string().uuid(), planHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+    repoFullName: zod_1.z.string().regex(/^NeuroNetIQ\/[A-Za-z0-9_.-]+$/i), baseRef: zod_1.z.literal('main'),
+    baseSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/), githubIssue: exports.CortexTaskGithubIssuePointerSchema,
+    allowedPaths: zod_1.z.array(zod_1.z.string().min(1).max(500)).min(1).max(30),
+    excludedPaths: zod_1.z.array(zod_1.z.string().min(1).max(500)).max(100),
+    maxFiles: zod_1.z.number().int().min(1).max(30), maxLines: zod_1.z.number().int().min(1).max(2500),
+    expiresAt: zod_1.z.string().datetime(), maxTokens: zod_1.z.number().int().min(1).max(500_000),
+    maxCostUsd: zod_1.z.number().positive().max(20), maxOutputTokens: zod_1.z.number().int().min(1).max(8192),
+}).strict();
+exports.CodexSignedWorkerPayloadSchema = zod_1.z.object({
+    version: zod_1.z.literal(1), agentRunId: zod_1.z.string().uuid(), idempotencyKey: zod_1.z.string().min(1).max(500),
+    title: zod_1.z.string().min(1).max(2048), prompt: zod_1.z.string().min(1).max(8000),
+    repoUrl: zod_1.z.string().url(), startingRef: zod_1.z.literal('main'),
+    forbiddenActions: zod_1.z.array(zod_1.z.string().min(1).max(100)).max(50),
+    authorization: exports.CodexExecutorApprovedScopeSchema.omit({ version: true, executor: true, baseRef: true, runtime: true }),
+    model: zod_1.z.string().min(1).max(100), workflowSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+}).strict();
+/** V2 mirrors Cortex signCodexDispatchRequest; historical Actions workers remain V1 only. */
+exports.CodexSignedSandboxWorkerPayloadSchema = exports.CodexSignedWorkerPayloadSchema
+    .omit({ version: true, workflowSha: true, authorization: true })
+    .extend({ version: zod_1.z.literal(2), runtime: exports.CodexExecutorRuntimeIdentitySchema,
+    authorization: exports.CodexExecutorApprovedScopeSchema.extend({ runtime: exports.CodexExecutorRuntimeIdentitySchema }).strict(),
+}).strict();
+const CodexAuthorizationFreshness = {
+    issuedAt: zod_1.z.string().datetime(), expiresAt: zod_1.z.string().datetime(),
+};
+const authorizationRequestIdentity = {
+    version: zod_1.z.literal(1), ...CodexAuthorizationFreshness,
+    agentRunId: zod_1.z.string().uuid(),
+    commandId: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+};
+const positiveWorkflowRunId = zod_1.z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const signedWorkerFields = {
+    workerPayload: zod_1.z.string().min(1).max(32_768),
+    workerSignature: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+};
+/** Provider-generated job identity; names alone never establish execution authority. */
+exports.CodexExecutorRuntimeJobSchema = zod_1.z.object({
+    sandboxName: zod_1.z.string().min(1).max(100), sessionId: zod_1.z.string().min(1).max(200),
+    runtimeCommandId: zod_1.z.string().min(1).max(200).optional(),
+}).strict();
+const sandboxAuthorizationFields = { runtime: exports.CodexExecutorRuntimeIdentitySchema };
+exports.CodexExecutorAuthorizationRequestPayloadSchema = zod_1.z.discriminatedUnion('purpose', [
+    zod_1.z.object({ ...authorizationRequestIdentity, purpose: zod_1.z.literal('runner'), workflowRunId: positiveWorkflowRunId, ...signedWorkerFields }).strict(),
+    zod_1.z.object({ ...authorizationRequestIdentity, purpose: zod_1.z.literal('dispatch'), ...signedWorkerFields }).strict(),
+    zod_1.z.object({ ...authorizationRequestIdentity, purpose: zod_1.z.literal('observation'), workflowRunId: positiveWorkflowRunId.optional() }).strict(),
+    zod_1.z.object({ ...authorizationRequestIdentity, purpose: zod_1.z.literal('sandbox_dispatch'), ...sandboxAuthorizationFields, ...signedWorkerFields }).strict(),
+    zod_1.z.object({ ...authorizationRequestIdentity, purpose: zod_1.z.literal('sandbox_runner'), ...sandboxAuthorizationFields, ...signedWorkerFields,
+        job: exports.CodexExecutorRuntimeJobSchema, claimNonce: zod_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict(),
+    zod_1.z.object({ ...authorizationRequestIdentity, purpose: zod_1.z.literal('sandbox_publish'), ...sandboxAuthorizationFields, ...signedWorkerFields,
+        job: exports.CodexExecutorRuntimeJobSchema.extend({ runtimeCommandId: zod_1.z.string().min(1).max(200) }).strict(), claimNonce: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+        completionReceipt: zod_1.z.object({ payload: zod_1.z.string().min(1).max(32_768).refine(value => new TextEncoder().encode(value).byteLength <= 32_768, 'Completion receipt exceeds UTF8 byte bound'), signature: zod_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict() }).strict(),
+    zod_1.z.object({ ...authorizationRequestIdentity, purpose: zod_1.z.literal('sandbox_observation'), ...sandboxAuthorizationFields, job: exports.CodexExecutorRuntimeJobSchema.optional() }).strict(),
+]).refine(value => {
+    const lifetime = Date.parse(value.expiresAt) - Date.parse(value.issuedAt);
+    return lifetime > 0 && lifetime <= 30_000;
+}, 'Authorization requests must expire within thirty seconds');
+exports.CodexExecutorAuthorizationResultPayloadSchema = zod_1.z.object({
+    version: zod_1.z.literal(1), eventType: zod_1.z.literal('CodexExecutorAuthorizationResult'),
+    requestId: zod_1.z.string().uuid(), ...CodexAuthorizationFreshness,
+    purpose: zod_1.z.enum(['runner', 'dispatch', 'observation', 'sandbox_dispatch', 'sandbox_runner', 'sandbox_observation', 'sandbox_publish']),
+    authorized: zod_1.z.boolean(), agentRunId: zod_1.z.string().uuid(),
+    reason: zod_1.z.enum(['pending_run_linkage', 'invalid_request', 'approval_unavailable', 'approval_expired', 'scope_changed', 'execution_inactive']).optional(),
+    workflowRunId: positiveWorkflowRunId.optional(),
+    commandId: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+    scope: exports.CodexExecutorApprovedScopeSchema.optional(),
+    runtime: exports.CodexExecutorRuntimeIdentitySchema.optional(), job: exports.CodexExecutorRuntimeJobSchema.optional(),
+    publication: zod_1.z.object({ patchSha256: zod_1.z.string().regex(/^[a-f0-9]{64}$/), completionReceiptHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict().optional(),
+    workflow: zod_1.z.object({
+        repoFullName: zod_1.z.string().regex(/^NeuroNetIQ\/[A-Za-z0-9_.-]+$/i),
+        workflowPath: zod_1.z.literal('.github/workflows/codex-agent-executor.yml'),
+        ref: zod_1.z.string().min(1).max(500), sha: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+    }).strict().optional(),
+}).strict().refine(value => {
+    const lifetime = Date.parse(value.expiresAt) - Date.parse(value.issuedAt);
+    const sandbox = value.purpose.startsWith('sandbox_');
+    if (!(lifetime > 0 && lifetime <= 30_000))
+        return false;
+    if (sandbox ? value.workflow !== undefined || value.workflowRunId !== undefined : value.runtime !== undefined || value.job !== undefined)
+        return false;
+    if (value.purpose === 'runner' && value.workflowRunId === undefined || value.purpose === 'dispatch' && value.workflowRunId !== undefined)
+        return false;
+    if (value.purpose !== 'sandbox_publish' && value.publication !== undefined)
+        return false;
+    if (!value.authorized)
+        return value.publication === undefined && value.scope === undefined && value.workflow === undefined && value.runtime === undefined && value.job === undefined;
+    if (!value.scope || value.reason !== undefined)
+        return false;
+    if (value.purpose === 'sandbox_publish' && (!value.publication || !value.job?.runtimeCommandId))
+        return false;
+    if (!sandbox)
+        return value.workflow !== undefined && value.scope.runtime === undefined;
+    return value.runtime !== undefined && JSON.stringify(value.scope.runtime) === JSON.stringify(value.runtime) &&
+        (['sandbox_runner', 'sandbox_publish'].includes(value.purpose) ? value.job !== undefined : value.purpose !== 'sandbox_dispatch' || value.job === undefined);
+}, 'Authorization result requires fresh exact scope only when authorized');
+const workflowCommandIdentity = {
+    version: zod_1.z.literal(1), agentRunId: zod_1.z.string().uuid(), commandId: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+};
+/** Dispatch is immutable across outbox retries; only observation challenges expire. */
+exports.CodexExecutorWorkflowRequestPayloadSchema = zod_1.z.discriminatedUnion('operation', [
+    zod_1.z.object({ ...workflowCommandIdentity, operation: zod_1.z.literal('dispatch'), ...signedWorkerFields }).strict(),
+    zod_1.z.object({ ...workflowCommandIdentity, operation: zod_1.z.literal('reconcile'), ...CodexAuthorizationFreshness, workflowRunId: positiveWorkflowRunId.optional() }).strict(),
+]).refine(value => value.operation === 'dispatch' ||
+    (Date.parse(value.expiresAt) > Date.parse(value.issuedAt) && Date.parse(value.expiresAt) - Date.parse(value.issuedAt) <= 30_000), 'Observation challenges expire within thirty seconds');
+exports.CodexExecutorWorkflowResultPayloadSchema = zod_1.z.object({
+    credentialCleanup: zod_1.z.enum(['revoked', 'unconfirmed']).optional(),
+    ...workflowCommandIdentity, eventType: zod_1.z.literal('CodexExecutorWorkflowResult'), requestId: zod_1.z.string().uuid(),
+    ...CodexAuthorizationFreshness, operation: zod_1.z.enum(['dispatch', 'reconcile']),
+    outcome: zod_1.z.enum(['dispatched', 'observed', 'not_found', 'delivery_unknown', 'denied']),
+    workflow: zod_1.z.object({ repoFullName: zod_1.z.string().regex(/^NeuroNetIQ\/[A-Za-z0-9_.-]+$/i),
+        workflowPath: zod_1.z.literal('.github/workflows/codex-agent-executor.yml'), ref: zod_1.z.string().min(1).max(500), sha: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+    }).strict(),
+    run: zod_1.z.object({ id: positiveWorkflowRunId, displayTitle: zod_1.z.string().min(1).max(200),
+        htmlUrl: zod_1.z.string().url().max(1000), status: zod_1.z.string().min(1).max(100), conclusion: zod_1.z.string().max(100).nullable(), headSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+    }).strict().optional(),
+    pr: zod_1.z.object({ url: zod_1.z.string().url().max(1000), body: zod_1.z.string().max(100_000), headSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+        baseSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/), baseRef: zod_1.z.literal('main'), draft: zod_1.z.boolean(), state: zod_1.z.enum(['open', 'closed']),
+    }).strict().nullable().optional(),
+    reason: zod_1.z.enum(['approval_denied', 'identity_conflict', 'ambiguous_run', 'delivery_uncertain', 'observation_unavailable']).optional(),
+}).strict().refine(value => {
+    const lifetime = Date.parse(value.expiresAt) - Date.parse(value.issuedAt);
+    return lifetime > 0 && lifetime <= 30_000 &&
+        (['dispatched', 'observed'].includes(value.outcome) ? value.run !== undefined : value.run === undefined && value.pr == null);
+}, 'Workflow results require a fresh correlated run only when observed');
+/** Every operation uses a fresh challenge; stable command and signed worker identity are immutable across retries. */
+const runtimeCommandIdentity = { ...workflowCommandIdentity, ...CodexAuthorizationFreshness, runtime: exports.CodexExecutorRuntimeIdentitySchema };
+exports.CodexExecutorRuntimeRequestPayloadSchema = zod_1.z.discriminatedUnion('operation', [
+    zod_1.z.object({ ...runtimeCommandIdentity, operation: zod_1.z.literal('dispatch'), ...signedWorkerFields }).strict(),
+    zod_1.z.object({ ...runtimeCommandIdentity, operation: zod_1.z.literal('reconcile'), job: exports.CodexExecutorRuntimeJobSchema.optional() }).strict(),
+    zod_1.z.object({ ...runtimeCommandIdentity, operation: zod_1.z.literal('cancel'), job: exports.CodexExecutorRuntimeJobSchema }).strict(),
+]).refine(value => {
+    const lifetime = Date.parse(value.expiresAt) - Date.parse(value.issuedAt);
+    return lifetime > 0 && lifetime <= 30_000;
+}, 'Runtime challenges expire within thirty seconds');
+exports.CodexExecutorRuntimeResultPayloadSchema = zod_1.z.object({
+    ...runtimeCommandIdentity, eventType: zod_1.z.literal('CodexExecutorRuntimeResult'), requestId: zod_1.z.string().uuid(),
+    payloadHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/), operation: zod_1.z.enum(['dispatch', 'reconcile', 'cancel']),
+    outcome: zod_1.z.enum(['dispatched', 'observed', 'not_found', 'delivery_unknown', 'denied']),
+    job: exports.CodexExecutorRuntimeJobSchema.extend({
+        state: zod_1.z.enum(['queued', 'running', 'completed', 'failed', 'cancelled', 'unknown']),
+        exitCode: zod_1.z.number().int().min(0).max(255).nullable(),
+    }).strict().optional(),
+    claimNonceHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    cleanup: zod_1.z.enum(['not_created', 'running', 'stopped', 'unknown']),
+    credentialCleanup: zod_1.z.enum(['revoked', 'unconfirmed']).optional(),
+    workerReceipt: zod_1.z.object({ payload: zod_1.z.string().min(1).max(32_768), signature: zod_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict().optional(),
+    pr: exports.CodexExecutorWorkflowResultPayloadSchema.innerType().shape.pr,
+    reason: zod_1.z.enum(['approval_denied', 'identity_conflict', 'delivery_uncertain', 'observation_unavailable']).optional(),
+}).strict().refine(value => {
+    const lifetime = Date.parse(value.expiresAt) - Date.parse(value.issuedAt);
+    if (!(lifetime > 0 && lifetime <= 30_000))
+        return false;
+    if (['dispatched', 'observed'].includes(value.outcome) && !value.job)
+        return false;
+    if (value.outcome === 'denied' && (value.job || value.workerReceipt || value.pr))
+        return false;
+    if (value.outcome === 'not_found' && (value.job || value.workerReceipt || value.pr || value.cleanup !== 'not_created'))
+        return false;
+    if (value.job && (!value.claimNonceHash || value.cleanup === 'not_created'))
+        return false;
+    if (!value.job && value.claimNonceHash !== undefined)
+        return false;
+    if (value.job && ['queued', 'running'].includes(value.job.state) && value.cleanup === 'stopped')
+        return false;
+    if (value.job && ['queued', 'running', 'unknown'].includes(value.job.state) && value.job.exitCode !== null)
+        return false;
+    if (value.job && ['completed', 'failed'].includes(value.job.state) && (!value.job.runtimeCommandId || value.job.exitCode === null))
+        return false;
+    if (value.job?.state === 'completed' && value.job.exitCode !== 0)
+        return false;
+    if (value.job?.state === 'failed' && value.job.exitCode === 0)
+        return false;
+    if (value.pr && (value.outcome !== 'observed' || value.job?.state !== 'completed' || !value.workerReceipt || value.credentialCleanup !== 'revoked' || value.cleanup !== 'stopped'))
+        return false;
+    return true;
+}, 'Runtime observations require genuine correlated job and publication evidence');
+exports.CodexRunnerCredentialRequestSchema = zod_1.z.object({
+    payload: zod_1.z.string().min(1).max(32_768), signature: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+    command_id: zod_1.z.string().regex(/^[a-f0-9]{64}$/),
+    workflowRunId: zod_1.z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    purpose: zod_1.z.enum(['checkout', 'publication']),
+}).strict();
+/** Fresh repository-scoped App facts; no credentials or execution authority cross this boundary. */
+const githubReadIdentity = {
+    version: zod_1.z.literal(1), repoFullName: zod_1.z.string().regex(/^NeuroNetIQ\/[A-Za-z0-9_.-]+$/i),
+    ...CodexAuthorizationFreshness,
+};
+const githubReadChecksInput = { operation: zod_1.z.literal('checks_observe'), prNumber: positiveWorkflowRunId,
+    headSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/), baseSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/), baseRef: zod_1.z.literal('main') };
+const githubReadPrInput = { operation: zod_1.z.literal('pr_get'), prNumber: positiveWorkflowRunId };
+const githubReadIssueInput = { operation: zod_1.z.literal('issue_get'), issueNumber: positiveWorkflowRunId };
+const githubReadBranchInput = { operation: zod_1.z.literal('branch_get'), branch: zod_1.z.literal('main') };
+const githubReadCompareInput = { operation: zod_1.z.literal('compare'), baseSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/), headSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/) };
+const githubReadFresh = (value) => {
+    if (typeof value.issuedAt !== 'string' || typeof value.expiresAt !== 'string')
+        return false;
+    const lifetime = Date.parse(value.expiresAt) - Date.parse(value.issuedAt);
+    return lifetime > 0 && lifetime <= 30_000;
+};
+exports.githubReadRequestSchema = zod_1.z.discriminatedUnion('operation', [
+    zod_1.z.object({ ...githubReadIdentity, ...githubReadIssueInput }).strict(),
+    zod_1.z.object({ ...githubReadIdentity, ...githubReadPrInput }).strict(),
+    zod_1.z.object({ ...githubReadIdentity, ...githubReadChecksInput }).strict(),
+    zod_1.z.object({ ...githubReadIdentity, ...githubReadCompareInput }).strict(),
+    zod_1.z.object({ ...githubReadIdentity, ...githubReadBranchInput }).strict(),
+]).refine(githubReadFresh, 'GitHub read challenges expire within thirty seconds');
+const githubReadResultIdentity = { ...githubReadIdentity, eventType: zod_1.z.literal('GitHubReadResult'),
+    requestId: zod_1.z.string().uuid(), requestPayloadHash: zod_1.z.string().regex(/^[a-f0-9]{64}$/) };
+const githubReadObserved = { outcome: zod_1.z.literal('observed'), repositoryId: positiveWorkflowRunId, credentialCleanup: zod_1.z.literal('revoked') };
+const githubReadUnavailable = { outcome: zod_1.z.enum(['not_found', 'denied', 'unavailable']), repositoryId: positiveWorkflowRunId.optional(),
+    credentialCleanup: zod_1.z.enum(['revoked', 'unconfirmed']).optional() };
+exports.githubReadResultSchema = zod_1.z.union([
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadChecksInput, ...githubReadObserved,
+        observation: zod_1.z.object({ state: zod_1.z.enum(['open', 'closed']), merged: zod_1.z.boolean(),
+            conflict: zod_1.z.enum(['conflicting', 'clean', 'unknown']), requiredChecks: zod_1.z.enum(['known', 'unknown']),
+            checks: zod_1.z.array(zod_1.z.object({ name: zod_1.z.string().min(1).max(200), state: zod_1.z.enum(['passed', 'failed', 'pending']),
+                url: zod_1.z.string().url().max(500).refine(value => new URL(value).protocol === 'https:', 'Check URLs require HTTPS').nullable(),
+                required: zod_1.z.boolean(),
+            }).strict()).max(100),
+        }).strict(),
+    }).strict().refine(value => (value.observation.requiredChecks !== 'unknown' || value.observation.checks.every(check => !check.required)) &&
+        (!value.observation.merged || (value.observation.state === 'closed' && value.observation.conflict !== 'conflicting')), 'Check observations cannot assert unknown required checks or contradictory merge facts'),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadChecksInput, ...githubReadUnavailable }).strict(),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadPrInput, ...githubReadObserved,
+        pullRequest: zod_1.z.object({ number: positiveWorkflowRunId, url: zod_1.z.string().url().max(500), state: zod_1.z.enum(['open', 'closed']),
+            merged: zod_1.z.boolean(), mergedAt: zod_1.z.string().datetime().nullable(), mergeCommitSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/).nullable(),
+            baseRef: zod_1.z.string().min(1).max(500), baseSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/), headSha: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
+            mergeable: zod_1.z.boolean().nullable(), mergeableState: zod_1.z.string().min(1).max(100).nullable(),
+        }).strict(),
+    }).strict().refine(value => value.pullRequest.number === value.prNumber &&
+        value.pullRequest.url.toLowerCase() === `https://github.com/${value.repoFullName}/pull/${value.prNumber}`.toLowerCase() &&
+        (!value.pullRequest.merged || (value.pullRequest.state === 'closed' && value.pullRequest.mergeCommitSha !== null && value.pullRequest.mergedAt !== null)), 'GitHub PR facts require exact request identity and complete merge evidence'),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadPrInput, ...githubReadUnavailable }).strict(),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadIssueInput, ...githubReadObserved,
+        issue: zod_1.z.object({ number: positiveWorkflowRunId, url: zod_1.z.string().url().max(500), isPullRequest: zod_1.z.boolean(), isEpic: zod_1.z.boolean() }).strict(),
+    }).strict().refine(value => value.issue.number === value.issueNumber &&
+        value.issue.url.toLowerCase() === `https://github.com/${value.repoFullName}/issues/${value.issueNumber}`.toLowerCase(), 'GitHub issue facts must match the exact request'),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadCompareInput, ...githubReadObserved,
+        compare: zod_1.z.object({ status: zod_1.z.enum(['identical', 'behind', 'ahead', 'diverged']),
+            aheadBy: zod_1.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER), behindBy: zod_1.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER) }).strict(),
+    }).strict(),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadBranchInput, ...githubReadObserved,
+        branchFacts: zod_1.z.object({ name: zod_1.z.literal('main'), sha: zod_1.z.string().regex(/^[a-f0-9]{40}$/) }).strict(),
+    }).strict(),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadBranchInput, ...githubReadUnavailable }).strict(),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadIssueInput, ...githubReadUnavailable }).strict(),
+    zod_1.z.object({ ...githubReadResultIdentity, ...githubReadCompareInput, ...githubReadUnavailable }).strict(),
+]).refine(githubReadFresh, 'GitHub read facts expire within thirty seconds');
+exports.BRIDGE_EVENT_PAYLOAD_SCHEMAS = {
+    GitHubReadRequest: exports.githubReadRequestSchema,
+    GitHubReadResult: exports.githubReadResultSchema,
+    CodexExecutorRuntimeRequest: exports.CodexExecutorRuntimeRequestPayloadSchema,
+    CodexExecutorRuntimeResult: exports.CodexExecutorRuntimeResultPayloadSchema,
+    CodexExecutorWorkflowRequest: exports.CodexExecutorWorkflowRequestPayloadSchema,
+    CodexExecutorWorkflowResult: exports.CodexExecutorWorkflowResultPayloadSchema,
+    CodexExecutorAuthorizationRequest: exports.CodexExecutorAuthorizationRequestPayloadSchema,
+    CodexExecutorAuthorizationResult: exports.CodexExecutorAuthorizationResultPayloadSchema,
+    RepoIntelligenceRequest: exports.RepoIntelligenceRequestPayloadSchema,
+    RepoIntelligenceResult: exports.RepoIntelligenceResultPayloadSchema,
+    RepoFindingTask: exports.RepoFindingTaskPayloadSchema,
+    ImplementationPlanReady: exports.ImplementationPlanReadyPayloadSchema,
+    PullRequestReady: exports.PullRequestReadyPayloadSchema,
+    ProofRunRecorded: exports.ProofRunRecordedPayloadSchema,
+    EngineeringCheckpointRecorded: exports.EngineeringCheckpointRecordedPayloadSchema,
+    RenderProofRecorded: film_bridge_events_schema_1.RenderProofRecordedPayloadSchema,
+    GuardianViolationEvent: exports.GuardianViolationEventPayloadSchema,
+    CreativeWorkflowRequest: exports.CreativeWorkflowRequestPayloadSchema,
+    CreativeWorkflowResult: exports.CreativeWorkflowResultPayloadSchema,
+    DocDraftReady: exports.DocDraftReadyPayloadSchema,
+    DocDriftDetected: exports.DocDriftDetectedPayloadSchema,
+    PortfolioRepoLink: exports.PortfolioRepoLinkPayloadSchema,
+    TaskGithubIssueRequest: exports.TaskGithubIssueRequestPayloadSchema,
+    ProductReleasePackageMvp: exports.ProductReleasePackageMvpBridgePayloadSchema,
+    FilmProductionPlanReady: film_bridge_events_schema_1.FilmProductionPlanReadyPayloadSchema,
+    FilmCutReady: film_bridge_events_schema_1.FilmCutReadyPayloadSchema,
+    CortexIngestionReceipt: exports.CortexIngestionReceiptPayloadSchema,
+    NeuraloomIngestionReceipt: exports.NeuraloomIngestionReceiptPayloadSchema,
+};