import assert from "node:assert/strict"; import { mkdtemp, rm } from "node:fs/promises"; import { tmpdir } from "node:os"; import { createRequire } from "node:module"; import { join, resolve } from "node:path"; import { buildEpiphanyOperatorRequest, epiphanyOperatorRequestPayloadSha256, processEpiphanyOperatorDelivery, consumeEpiphanyOperatorDeliveries, registerEpiphanyOperatorInteraction, submitEpiphanyOperatorRequest, validateDelivery, type EpiphanyOperatorDeliveryDocument, type EpiphanyOperatorDeliveryCheckpoint } from "../packages/core/src/index"; async function main(): Promise { const request = buildEpiphanyOperatorRequest( { interactionId: "interaction-1", actorDiscordId: "owner-1", guildId: "guild-1", channelId: "channel-1", command: { kind: "sleep", reason: "bank the fire" }, issuedAt: "2026-07-19T12:00:00.000Z", }, "voidbot-yggdrasil", ); const digest = epiphanyOperatorRequestPayloadSha256(request); assert.match(digest, /^sha256-[0-9a-f]{64}$/); assert.notEqual( digest, epiphanyOperatorRequestPayloadSha256({ ...request, discordGuildId: "other", }), ); assert.notEqual( digest, epiphanyOperatorRequestPayloadSha256({ ...request, command: { kind: "wake" }, }), ); const completed: EpiphanyOperatorDeliveryDocument = { schemaVersion: "bifrost.discord.epiphany_operator_delivery.v1", deliveryId: request.requestId, requestId: request.requestId, requestPayloadSha256: digest, commandId: request.commandId, discordGuildId: request.discordGuildId, discordChannelId: request.discordChannelId, discordInteractionId: request.sourceEventId, targetRuntimeId: "epiphany-yggdrasil", status: "completed", disposition: "observed", failureCode: "", detail: "sleep accepted", operatorStatus: "sleeping", stateStatus: "banked", coordinatorAction: "none", brakeStatus: "engaged", sealedResultPayloadSha256: `sha256-${"a".repeat(64)}`, executorSignatureSha256: `sha256-${"b".repeat(64)}`, resultProviderIdentityId: "bifrost-yggdrasil", reviews: [], reviewCandidateId: "", reviewDecision: "", statusV2: null, recordedAt: "2026-07-19T12:00:01.000Z", privateStateExposed: false, }; assert.equal(validateDelivery(completed).status, "completed"); const refused: EpiphanyOperatorDeliveryDocument = { ...completed, status: "refused", disposition: "", failureCode: "brakes_engaged", detail: "refused", operatorStatus: "", stateStatus: "", coordinatorAction: "", brakeStatus: "", sealedResultPayloadSha256: "", executorSignatureSha256: "", resultProviderIdentityId: "", reviews: [], reviewCandidateId: "", reviewDecision: "", }; assert.equal(validateDelivery(refused).status, "refused"); function rejects(change: Record, pattern: RegExp): void { assert.throws(() => validateDelivery({ ...completed, ...change }), pattern); } rejects({ privateStateExposed: true }, /private state/); rejects({ status: "pending" }, /terminal/); rejects({ detail: "x".repeat(513) }, /detail/); rejects({ operatorStatus: "x".repeat(513) }, /operatorStatus/); rejects({ requestPayloadSha256: "raw-payload" }, /digest/); rejects({ targetRuntimeId: "epiphany-nightwing" }, /runtime/); rejects({ deliveryId: "collision" }, /identity/); rejects({ executorSignatureSha256: "signature-bytes" }, /sealed bindings/); rejects({ resultProviderIdentityId: "" }, /resultProviderIdentityId|sealed bindings/); rejects({ surprisePrivatePayload: "secret" }, /field set/); rejects( { reviews: [ { mindRequestId: "m", candidateId: "c", candidateSha256: "1".repeat(64), modelRevision: 1, modelHash: "2".repeat(64), frontierItemId: "f", requestedAt: "2026-07-19T12:00:00Z", proposalText: "private", }, ], }, /inexact field set/, ); rejects( { reviews: Array.from({ length: 11 }, () => ({ mindRequestId: "m", candidateId: "c", candidateSha256: "1".repeat(64), modelRevision: 1, modelHash: "2".repeat(64), frontierItemId: "f", requestedAt: "2026-07-19T12:00:00Z", })), }, /at most ten/, ); assert.throws(() => validateDelivery({ ...refused, brakeStatus: "not empty" }), /completed-result bindings/); assert.throws(() => validateDelivery({ ...refused, failureCode: "" }), /failureCode|failure code/); const baseCheckpoint: EpiphanyOperatorDeliveryCheckpoint = { schemaVersion: "voidbot.private.epiphany_operator_delivery_checkpoint.v0", requestId: request.requestId, applicationId: "app-1", interactionToken: "private-token", discordGuildId: request.discordGuildId, discordChannelId: request.discordChannelId, discordInteractionId: request.sourceEventId, targetRuntimeId: "epiphany-yggdrasil", state: "pending", observedDeliverySha256: "", respondedDeliverySha256: "", attemptCount: 0, lastError: "", registeredAt: "2026-07-19T12:00:00.000Z", updatedAt: "2026-07-19T12:00:00.000Z", }; const statusRequest = buildEpiphanyOperatorRequest( { interactionId: "interaction-status", actorDiscordId: "owner-1", guildId: "guild-1", channelId: "channel-1", command: { kind: "status" }, issuedAt: "2026-07-19T12:00:00.000Z", }, "voidbot-yggdrasil", ); const unavailable = (daemonId: string, healthContract: string) => ({ daemonId, healthContract, availability: "unavailable" as const, unavailableReason: "required-provider-record-missing", state: null, reasonCode: null, providerObservedAtUnixMillis: null, evaluatedAtUnixMillis: null, expiresAtUnixMillis: null, releaseId: null, releaseWitnessSha256: null, sourceCommit: null, deploymentId: null, projectionSha256: null, }); const statusDelivery: EpiphanyOperatorDeliveryDocument = { ...completed, deliveryId: statusRequest.requestId, requestId: statusRequest.requestId, commandId: statusRequest.commandId, discordInteractionId: statusRequest.sourceEventId, requestPayloadSha256: epiphanyOperatorRequestPayloadSha256(statusRequest), statusV2: { schemaVersion: "epiphany.operator.status.v2", releaseId: "release-7", releaseWitnessSha256: `sha256-${"7".repeat(64)}`, sourceCommit: "8".repeat(40), deploymentId: "deployment-9", coordinatorSnapshot: "sleeping", coordinatorState: "ready", coordinatorAction: "none", brakeStatus: "engaged", residentStatus: "idle", pressureCount: 3, pendingReviewCount: 2, providerSetStatus: "incomplete", providers: [unavailable("yggdrasil-epiphany", "epiphany.cultnet-rudp-runtime-health"), unavailable("yggdrasil-bifrost-persona-feedback", "bifrost.cultnet-rudp-persona-feedback-health")], privateStateExposed: false, }, }; assert.equal(validateDelivery(statusDelivery).statusV2?.providerSetStatus, "incomplete"); for (const hostile of [ { ...statusDelivery, statusV2: { ...statusDelivery.statusV2!, privateKey: "secret" }, }, { ...statusDelivery, statusV2: { ...statusDelivery.statusV2!, privateStateExposed: true }, }, { ...statusDelivery, statusV2: { ...statusDelivery.statusV2!, residentStatus: "x".repeat(257), }, }, { ...statusDelivery, statusV2: { ...statusDelivery.statusV2!, providerSetStatus: "complete-authenticated", }, }, { ...statusDelivery, statusV2: { ...statusDelivery.statusV2!, providers: [...statusDelivery.statusV2!.providers].reverse(), }, }, ]) assert.throws(() => validateDelivery(hostile)); let statusText = "", statusCheckpoint = { ...baseCheckpoint, requestId: statusRequest.requestId, discordInteractionId: statusRequest.sourceEventId, }; assert.equal( await processEpiphanyOperatorDelivery( statusDelivery, statusRequest, statusCheckpoint, async (_a, _t, text) => { statusText = text; }, async (next) => { statusCheckpoint = next; }, ), "responded", ); assert.match(statusText, /Deployment: release-7 \| commit [8]{40} \| deployment-9/); assert.match(statusText, /Resident: idle \| Brake: engaged/); assert.match(statusText, /Pressure: 3 \| Reviews: 2/); assert.match(statusText, /Provider set: incomplete/); assert.match(statusText, /Epiphany: unavailable \(required-provider-record-missing\)/); assert.match(statusText, /Bifrost: unavailable \(required-provider-record-missing\)/); assert.doesNotMatch(statusText, /signature|sha256|private|path|key/i); assert.ok(statusText.length < 2000); const currentProvider = (base: ReturnType, state: string, withLineage: boolean) => ({ ...base, availability: "authenticated-current" as const, unavailableReason: "", state, reasonCode: "healthy", providerObservedAtUnixMillis: 1, evaluatedAtUnixMillis: 2, expiresAtUnixMillis: 3, releaseId: withLineage ? "release-7" : null, releaseWitnessSha256: withLineage ? `sha256-${"7".repeat(64)}` : null, sourceCommit: withLineage ? "8".repeat(40) : null, deploymentId: withLineage ? "deployment-9" : null, projectionSha256: `sha256-${"9".repeat(64)}`, }); const completeDelivery: EpiphanyOperatorDeliveryDocument = { ...statusDelivery, statusV2: { ...statusDelivery.statusV2!, providerSetStatus: "complete-authenticated", providers: [currentProvider(unavailable("yggdrasil-epiphany", "epiphany.cultnet-rudp-runtime-health"), "serving", true), currentProvider(unavailable("yggdrasil-bifrost-persona-feedback", "bifrost.cultnet-rudp-persona-feedback-health"), "ready", false)], }, }; let completeText = "", completeCheckpoint = { ...baseCheckpoint, requestId: statusRequest.requestId, discordInteractionId: statusRequest.sourceEventId, }; assert.equal( await processEpiphanyOperatorDelivery( completeDelivery, statusRequest, completeCheckpoint, async (_a, _t, text) => { completeText = text; }, async (next) => { completeCheckpoint = next; }, ), "responded", ); assert.match(completeText, /Provider set: complete-authenticated/); assert.match(completeText, /Epiphany: authenticated-current \| serving \| healthy/); assert.match(completeText, /Bifrost: authenticated-current \| ready \| healthy/); assert.doesNotMatch(completeText, /sha256|signature|private|path|key/i); assert.equal( await processEpiphanyOperatorDelivery( { ...statusDelivery, statusV2: null }, statusRequest, { ...baseCheckpoint, requestId: statusRequest.requestId, discordInteractionId: statusRequest.sourceEventId, }, async () => { throw new Error("must not lower missing status"); }, async () => {}, ), "failed", ); let current = baseCheckpoint; let editCount = 0; let failEdit = true; const edit = async (_app: string, token: string, content: string): Promise => { assert.equal(token, "private-token"); assert.doesNotMatch(content, /signature|private-token|sha256-/i); editCount += 1; if (failEdit) throw new Error("temporary Discord failure"); }; const save = async (next: EpiphanyOperatorDeliveryCheckpoint): Promise => { current = next; }; assert.equal(await processEpiphanyOperatorDelivery(completed, request, current, edit, save), "failed"); assert.equal(current.state, "pending"); assert.match(current.lastError, /temporary Discord failure/); assert.ok(current.observedDeliverySha256); failEdit = false; assert.equal(await processEpiphanyOperatorDelivery(completed, request, current, edit, save), "responded"); assert.equal(current.state, "responded"); assert.equal(await processEpiphanyOperatorDelivery(completed, request, current, edit, save), "replayed"); assert.equal(editCount, 2, "a restart replay must not create another response"); for (const [field, value] of [ ["commandId", "wrong"], ["discordGuildId", "wrong"], ["discordChannelId", "wrong"], ["discordInteractionId", "wrong"], ["targetRuntimeId", "epiphany-nightwing"], ["requestPayloadSha256", `sha256-${"c".repeat(64)}`], ] as const) { let rejectedCheckpoint = { ...baseCheckpoint }; assert.equal( await processEpiphanyOperatorDelivery( { ...completed, [field]: value }, request, rejectedCheckpoint, async () => { throw new Error("must not edit"); }, async (next) => { rejectedCheckpoint = next; }, ), "failed", ); assert.match(rejectedCheckpoint.lastError, /request|runtime|digest/); } let collisionCheckpoint = { ...baseCheckpoint, observedDeliverySha256: `sha256-${"d".repeat(64)}`, }; assert.equal( await processEpiphanyOperatorDelivery( completed, request, collisionCheckpoint, async () => { throw new Error("must not edit"); }, async (next) => { collisionCheckpoint = next; }, ), "failed", ); assert.match(collisionCheckpoint.lastError, /collision/); const reviewRequest = buildEpiphanyOperatorRequest( { interactionId: "interaction-review", actorDiscordId: "owner-1", guildId: "guild-1", channelId: "channel-1", command: { kind: "reviews" }, issuedAt: "2026-07-19T12:00:00.000Z", }, "voidbot-yggdrasil", ); const reviewDelivery: EpiphanyOperatorDeliveryDocument = { ...completed, deliveryId: reviewRequest.requestId, requestId: reviewRequest.requestId, commandId: reviewRequest.commandId, discordInteractionId: reviewRequest.sourceEventId, requestPayloadSha256: epiphanyOperatorRequestPayloadSha256(reviewRequest), reviews: [ { mindRequestId: "mind-1", candidateId: "candidate-1", candidateSha256: "1".repeat(64), modelRevision: 7, modelHash: "2".repeat(64), frontierItemId: "frontier-1", requestedAt: "2026-07-19T11:59:00Z", }, ], }; let renderedReview = ""; let reviewCheckpoint = { ...baseCheckpoint, requestId: reviewRequest.requestId, discordInteractionId: reviewRequest.sourceEventId, }; assert.equal( await processEpiphanyOperatorDelivery( reviewDelivery, reviewRequest, reviewCheckpoint, async (_app, _token, content) => { renderedReview = content; }, async (next) => { reviewCheckpoint = next; }, ), "responded", ); assert.match(renderedReview, /candidate-1.*request mind-1.*revision 7.*frontier frontier-1/); assert.doesNotMatch(renderedReview, /proposal|private|sha256/i); let substitutedCheckpoint = { ...baseCheckpoint }; assert.equal( await processEpiphanyOperatorDelivery( { ...completed, reviews: reviewDelivery.reviews }, request, substitutedCheckpoint, async () => { throw new Error("must not render substituted review state"); }, async (next) => { substitutedCheckpoint = next; }, ), "failed", ); assert.match(substitutedCheckpoint.lastError, /non-review/); const decisionRequest = buildEpiphanyOperatorRequest( { interactionId: "interaction-decision", actorDiscordId: "owner-1", guildId: "guild-1", channelId: "channel-1", command: { kind: "review", mindRequestId: "mind-1", candidateId: "candidate-1", candidateSha256: "1".repeat(64), expectedModelRevision: 7, expectedModelHash: "2".repeat(64), decision: "hold", }, issuedAt: "2026-07-19T12:00:00.000Z", }, "voidbot-yggdrasil", ); const decisionDelivery: EpiphanyOperatorDeliveryDocument = { ...completed, deliveryId: decisionRequest.requestId, requestId: decisionRequest.requestId, commandId: decisionRequest.commandId, discordInteractionId: decisionRequest.sourceEventId, requestPayloadSha256: epiphanyOperatorRequestPayloadSha256(decisionRequest), reviewCandidateId: "candidate-1", reviewDecision: "hold", }; let decisionCheckpoint = { ...baseCheckpoint, requestId: decisionRequest.requestId, discordInteractionId: decisionRequest.sourceEventId, }; assert.equal( await processEpiphanyOperatorDelivery( { ...decisionDelivery, reviewCandidateId: "candidate-2" }, decisionRequest, decisionCheckpoint, async () => { throw new Error("must not render substituted decision"); }, async (next) => { decisionCheckpoint = next; }, ), "failed", ); assert.match(decisionCheckpoint.lastError, /exact candidate and decision/); const temp = await mkdtemp(join(tmpdir(), "voidbot-epiphany-delivery-")); try { const bifrostRoot = resolve("../Bifrost"); const cultlibRoot = resolve("../CultLib"); const stores = { requestStorePath: join(temp, "requests.cc"), deliveryStorePath: join(temp, "deliveries.cc"), checkpointStorePath: join(temp, "checkpoints.cc"), bifrostRoot, cultlibRoot, }; await registerEpiphanyOperatorInteraction( { requestId: request.requestId, applicationId: "app-1", interactionToken: "private-token", guildId: request.discordGuildId, channelId: request.discordChannelId, registeredAt: request.issuedAt, }, stores, ); await submitEpiphanyOperatorRequest( { interactionId: request.requestId, actorDiscordId: request.sourceActorDiscordId, guildId: request.discordGuildId, channelId: request.discordChannelId, command: request.command, issuedAt: request.issuedAt, }, { storePath: stores.requestStorePath, bifrostRoot, cultlibRoot, producerRuntimeId: request.producerRuntimeId, }, ); const cachePackage = resolve(cultlibRoot, "packages/cultcache-ts/package.json"); const meshPackage = resolve(cultlibRoot, "packages/cultmesh-ts/package.json"); const define = createRequire(cachePackage)("cultcache-ts").defineDocumentType; const CultMesh = createRequire(meshPackage)("cultmesh-ts").CultMesh; const deliveryDef = define({ type: "bifrost.discord.epiphany_operator_delivery", schemaName: "bifrost.discord.epiphany_operator_delivery", schemaId: completed.schemaVersion, schemaVersion: completed.schemaVersion, contentHash: completed.schemaVersion, global: false, name: "deliveryId", schema: { parse: (value: unknown) => value }, }); const deliveryNode = await CultMesh.createNode(stores.deliveryStorePath, { documents: [deliveryDef], }); await deliveryNode.put(deliveryDef, completed.deliveryId, completed); let integrationEdits = 0; assert.deepEqual( await consumeEpiphanyOperatorDeliveries(stores, async () => { integrationEdits += 1; }), { observed: 1, responded: 1, failed: 0 }, ); assert.deepEqual( await consumeEpiphanyOperatorDeliveries(stores, async () => { integrationEdits += 1; }), { observed: 1, responded: 0, failed: 0 }, ); assert.equal(integrationEdits, 1); } finally { await rm(temp, { recursive: true, force: true }); } console.log("Epiphany operator delivery smoke passed."); } void main().catch((error) => { console.error(error); process.exitCode = 1; });