@moltzap/protocol 2026.503.3 → 2026.504.0

package/dist/testing/conformance/delivery.js

@@ -9,23 +9,30 @@
  * Principle 3: every property body is `Effect<void, PropertyFailure>`.
  */
 import * as fc from "fast-check";
-import { Effect, Ref } from "effect";
+import { Effect, Either, Ref } from "effect";
 import { ErrorCodes } from "../../schema/errors.js";
-import { EventNames } from "../../schema/events.js";
+import { AppSessionClosedNotificationDefinition, ConversationArchivedNotificationDefinition, ConversationCreatedNotificationDefinition, ConversationUnarchivedNotificationDefinition, ConversationUpdatedNotificationDefinition, MessageReceivedNotificationDefinition, } from "../../schema/notifications.js";
 import { AppsCloseSession, AppsCreate, AppsRegister, } from "../../schema/methods/apps.js";
 import { ConversationsArchive, ConversationsCreate, ConversationsUnarchive, ConversationsUpdate, } from "../../schema/methods/conversations.js";
 import { MessagesSend } from "../../schema/methods/messages.js";
+import { AgentId, ConversationId, conversationId as makeConversationId, } from "../../schema/primitives.js";
+import { RpcResponseError } from "../errors.js";
+import { isNotificationFrame } from "../codec.js";
 import { makeTestClient } from "../test-client.js";
 import { registerTestAgent } from "../agent-registration.js";
 import { PropertyDeferred, PropertyInvariantViolation, PropertyUnavailable, assertProperty, registerProperty, } from "./registry.js";
-import { sendUntypedRpc } from "./_helpers.js";
+import { leftOrNull, requireRight, sendUntypedRpc } from "./_helpers.js";
 const CATEGORY = "delivery";
 const DEFAULT_TIMEOUT_MS = 5000;
 const DEFAULT_CAPTURE_CAPACITY = 256;
+const DEFAULT_PROPERTY_NUM_RUNS = 3;
+const DATE_ID_RADIX = 36;
 const MAX_N = 4;
 const CONVERSATION_LIFECYCLE_PROPERTY = "conversation-lifecycle";
 const APP_SESSION_CLOSE_LIFECYCLE_PROPERTY = "app-session-close-lifecycle";
 const ARCHIVE_LIFECYCLE_PROPERTY = "archive-lifecycle";
+const STORE_AND_REPLAY_PROPERTY = "store-and-replay";
+const TASK_BOUNDARY_ISOLATION_PROPERTY = "task-boundary-isolation";
 function violation(name, reason) {
     return new PropertyInvariantViolation({ category: CATEGORY, name, reason });
 }
@@ -39,104 +46,110 @@ function firstParticipant(fixture, propertyName) {
         : Effect.succeed(participant);
 }
 function sendText(actor, conversationId, text) {
-    return actor.client.sendRpc(MessagesSend.name, {
+    return actor.client.sendRpc(MessagesSend, {
         conversationId,
         parts: [{ type: "text", text }],
     });
 }
 function archiveConversation(actor, conversationId) {
-    return actor.client.sendRpc(ConversationsArchive.name, { conversationId });
+    return actor.client.sendRpc(ConversationsArchive, { conversationId });
 }
 function updateConversationName(actor, conversationId, name) {
-    return actor.client.sendRpc(ConversationsUpdate.name, {
+    return actor.client.sendRpc(ConversationsUpdate, {
         conversationId,
         name,
     });
 }
 function unarchiveConversation(actor, conversationId) {
-    return actor.client.sendRpc(ConversationsUnarchive.name, { conversationId });
+    return actor.client.sendRpc(ConversationsUnarchive, { conversationId });
 }
-function waitForConversationCreatedEvent(observer, conversationId, propertyName) {
+function waitForConversationCreatedNotification(observer, conversationId, propertyName) {
     return Effect.gen(function* () {
         const event = yield* observer.client
-            .waitForEvent(EventNames.ConversationCreated, DEFAULT_TIMEOUT_MS)
+            .waitForNotification(ConversationCreatedNotificationDefinition, DEFAULT_TIMEOUT_MS)
             .pipe(Effect.mapError((e) => violation(propertyName, `created event missing: ${e.message}`)));
-        const data = event.data;
+        const data = event.params;
         if (data?.conversation?.id !== conversationId) {
-            return yield* Effect.fail(violation(propertyName, `bad created event payload: ${JSON.stringify(event.data)}`));
+            return yield* Effect.fail(violation(propertyName, `bad created event payload: ${JSON.stringify(event.params)}`));
         }
     });
 }
-function waitForConversationUpdatedEvent(observer, conversationId, name, propertyName) {
+function waitForConversationUpdatedNotification(observer, conversationId, name, propertyName) {
     return Effect.gen(function* () {
         const event = yield* observer.client
-            .waitForEvent(EventNames.ConversationUpdated, DEFAULT_TIMEOUT_MS)
+            .waitForNotification(ConversationUpdatedNotificationDefinition, DEFAULT_TIMEOUT_MS)
             .pipe(Effect.mapError((e) => violation(propertyName, `updated event missing: ${e.message}`)));
-        const data = event.data;
+        const data = event.params;
         if (data?.conversation?.id !== conversationId ||
             data.conversation.name !== name) {
-            return yield* Effect.fail(violation(propertyName, `bad updated event payload: ${JSON.stringify(event.data)}`));
+            return yield* Effect.fail(violation(propertyName, `bad updated event payload: ${JSON.stringify(event.params)}`));
         }
     });
 }
-function waitForMessageReceivedEvent(observer, conversationId, propertyName) {
+function waitForMessageReceivedNotification(observer, conversationId, propertyName) {
     return Effect.gen(function* () {
         const event = yield* observer.client
-            .waitForEvent(EventNames.MessageReceived, DEFAULT_TIMEOUT_MS)
+            .waitForNotification(MessageReceivedNotificationDefinition, DEFAULT_TIMEOUT_MS)
             .pipe(Effect.mapError((e) => violation(propertyName, `message event missing: ${e.message}`)));
-        const data = event.data;
+        const data = event.params;
         if (data?.message?.conversationId !== conversationId) {
-            return yield* Effect.fail(violation(propertyName, `bad message event payload: ${JSON.stringify(event.data)}`));
+            return yield* Effect.fail(violation(propertyName, `bad message event payload: ${JSON.stringify(event.params)}`));
         }
     });
 }
-function waitForAppSessionClosedEvent(observer, sessionId, closedBy, propertyName) {
+function waitForAppSessionClosedNotification(observer, sessionId, closedBy, propertyName) {
     return Effect.gen(function* () {
         const event = yield* observer.client
-            .waitForEvent(EventNames.AppSessionClosed, DEFAULT_TIMEOUT_MS)
+            .waitForNotification(AppSessionClosedNotificationDefinition, DEFAULT_TIMEOUT_MS)
             .pipe(Effect.mapError((e) => violation(propertyName, `session closed event missing: ${e.message}`)));
-        const data = event.data;
+        const data = event.params;
         if (data?.sessionId !== sessionId || data.closedBy !== closedBy) {
-            return yield* Effect.fail(violation(propertyName, `bad session closed event payload: ${JSON.stringify(event.data)}`));
+            return yield* Effect.fail(violation(propertyName, `bad session closed event payload: ${JSON.stringify(event.params)}`));
         }
     });
 }
 function waitForArchivedEvent(observer, conversationId, byAgentId, propertyName) {
     return Effect.gen(function* () {
         const event = yield* observer.client
-            .waitForEvent(EventNames.ConversationArchived, DEFAULT_TIMEOUT_MS)
+            .waitForNotification(ConversationArchivedNotificationDefinition, DEFAULT_TIMEOUT_MS)
             .pipe(Effect.mapError((e) => violation(propertyName, `archive event missing: ${e.message}`)));
-        const data = event.data;
+        const data = event.params;
         if (data?.conversationId !== conversationId ||
             typeof data.archivedAt !== "string" ||
             data.by !== byAgentId) {
-            return yield* Effect.fail(violation(propertyName, `bad archive event payload: ${JSON.stringify(event.data)}`));
+            return yield* Effect.fail(violation(propertyName, `bad archive event payload: ${JSON.stringify(event.params)}`));
         }
     });
 }
 function waitForUnarchivedEvent(observer, conversationId, byAgentId, propertyName) {
     return Effect.gen(function* () {
         const event = yield* observer.client
-            .waitForEvent(EventNames.ConversationUnarchived, DEFAULT_TIMEOUT_MS)
+            .waitForNotification(ConversationUnarchivedNotificationDefinition, DEFAULT_TIMEOUT_MS)
             .pipe(Effect.mapError((e) => violation(propertyName, `unarchive event missing: ${e.message}`)));
-        const data = event.data;
+        const data = event.params;
         if (data?.conversationId !== conversationId || data.by !== byAgentId) {
-            return yield* Effect.fail(violation(propertyName, `bad unarchive event payload: ${JSON.stringify(event.data)}`));
+            return yield* Effect.fail(violation(propertyName, `bad unarchive event payload: ${JSON.stringify(event.params)}`));
         }
     });
 }
 function assertConversationRejectsMessages(actor, conversationId, propertyName) {
     return Effect.gen(function* () {
         const outcome = yield* sendText(actor, conversationId, "must-fail-while-archived").pipe(Effect.either);
-        if (outcome._tag === "Right") {
-            return yield* Effect.fail(violation(propertyName, "messages/send succeeded while archived"));
-        }
-        if (outcome.left._tag !== "TestingRpcResponseError" ||
-            outcome.left.code !== ErrorCodes.ConversationArchived) {
-            const errorLabel = outcome.left._tag === "TestingRpcResponseError"
-                ? `${outcome.left._tag}/${outcome.left.code}`
-                : outcome.left._tag;
-            return yield* Effect.fail(violation(propertyName, `messages/send returned ${errorLabel}, expected ConversationArchived`));
+        const outcomeViolation = Either.match(outcome, {
+            onRight: () => violation(propertyName, "messages/send succeeded while archived"),
+            onLeft: (error) => {
+                if (error instanceof RpcResponseError &&
+                    error.code === ErrorCodes.ConversationArchived) {
+                    return null;
+                }
+                const errorLabel = error instanceof RpcResponseError
+                    ? `${error._tag}/${error.code}`
+                    : error._tag;
+                return violation(propertyName, `messages/send returned ${errorLabel}, expected ConversationArchived`);
+            },
+        });
+        if (outcomeViolation !== null) {
+            return yield* Effect.fail(outcomeViolation);
         }
     });
 }
@@ -162,7 +175,7 @@ function acquireConversation(ctx, n, namePrefix) {
         const owner = yield* acquireClient(ctx, `${namePrefix}-owner`);
         const participants = yield* Effect.forEach(Array.from({ length: clamped }, (_, i) => i), (i) => acquireClient(ctx, `${namePrefix}-p${i}`), { concurrency: clamped });
         const createResult = yield* owner.client
-            .sendRpc(ConversationsCreate.name, {
+            .sendRpc(ConversationsCreate, {
             type: "group",
             name: `${namePrefix}-conv`,
             participants: participants.map((p) => ({
@@ -171,15 +184,16 @@ function acquireConversation(ctx, n, namePrefix) {
             })),
         })
             .pipe(Effect.either);
-        if (createResult._tag === "Left") {
-            return yield* Effect.fail(`conversations/create failed: ${createResult.left._tag}`);
-        }
-        const created = createResult.right;
+        const created = (yield* requireRight(createResult, (error) => `conversations/create failed: ${error._tag}`));
         const conversationId = created.conversation?.id;
         if (typeof conversationId !== "string" || conversationId.length === 0) {
             return yield* Effect.fail(`conversations/create returned no conversation.id`);
         }
-        return { owner, participants, conversationId };
+        return {
+            owner,
+            participants,
+            conversationId: makeConversationId(conversationId),
+        };
     });
 }
 /**
@@ -192,22 +206,22 @@ function acquireConversation(ctx, n, namePrefix) {
  */
 export function registerFanOutCardinality(ctx) {
     registerProperty(ctx, CATEGORY, "fan-out-cardinality", "messages/send ⇒ exactly N inbound message events (one per connection)", assertProperty(CATEGORY, "fan-out-cardinality", () => fc.assert(fc.asyncProperty(fc.integer({ min: 2, max: 3 }), (n) => Effect.runPromise(Effect.scoped(Effect.gen(function* () {
-        const fixture = yield* acquireConversation(ctx, n, "fan").pipe(Effect.mapError((e) => new Error(e)));
+        const fixture = yield* acquireConversation(ctx, n, "fan").pipe(Effect.mapError((e) => violation("fan-out-cardinality", `fixture: ${e}`)));
         const send = yield* fixture.owner.client
-            .sendRpc(MessagesSend.name, {
+            .sendRpc(MessagesSend, {
             conversationId: fixture.conversationId,
             parts: [{ type: "text", text: "fan-out-ping" }],
         })
             .pipe(Effect.either);
-        if (send._tag === "Left") {
+        if (leftOrNull(send) !== null) {
             return { kind: "send-failed" };
         }
         yield* Effect.sleep("250 millis");
         const observed = yield* Effect.forEach(fixture.participants, (p) => p.client.snapshot);
         const counts = observed.map((snap) => snap.filter((s) => s.kind === "inbound" &&
-            s.frame?.type === "event" &&
-            typeof s.frame.event === "string" &&
-            s.frame.event.includes("message")).length);
+            s.frame !== null &&
+            isNotificationFrame(s.frame) &&
+            s.frame.method.includes("message")).length);
         return { kind: "ok", counts };
     })).pipe(Effect.map((result) => {
         if (result.kind !== "ok")
@@ -215,7 +229,10 @@ export function registerFanOutCardinality(ctx) {
         // Exact-cardinality predicate. Duplicates and drops both fail.
         return (result.counts.length === fixture_n(n) &&
             result.counts.every((c) => c === 1));
-    })))), { seed: ctx.seed, numRuns: ctx.opts.numRuns ?? 3 })));
+    })))), {
+        seed: ctx.seed,
+        numRuns: ctx.opts.numRuns ?? DEFAULT_PROPERTY_NUM_RUNS,
+    })));
 }
 function fixture_n(requested) {
     return Math.min(Math.max(1, requested), MAX_N);
@@ -245,24 +262,24 @@ function fixture_n(requested) {
  * from the git history and remove the #186 pointer.
  */
 export function registerStoreAndReplay(ctx) {
-    registerProperty(ctx, CATEGORY, "store-and-replay", "every messages/send lands in a live participant's capture buffer (basic-delivery-landing; #186 tracks C2 offline-replay)", Effect.scoped(Effect.gen(function* () {
+    registerProperty(ctx, CATEGORY, STORE_AND_REPLAY_PROPERTY, "every messages/send lands in a live participant's capture buffer (basic-delivery-landing; #186 tracks C2 offline-replay)", Effect.scoped(Effect.gen(function* () {
         const fixture = yield* acquireConversation(ctx, 1, "sr").pipe(Effect.mapError((e) => new PropertyInvariantViolation({
             category: CATEGORY,
-            name: "store-and-replay",
+            name: STORE_AND_REPLAY_PROPERTY,
             reason: `fixture: ${e}`,
         })));
         const participant = fixture.participants[0];
         if (participant === undefined) {
             return yield* Effect.fail(new PropertyInvariantViolation({
                 category: CATEGORY,
-                name: "store-and-replay",
+                name: STORE_AND_REPLAY_PROPERTY,
                 reason: "fixture missing participant",
             }));
         }
         const sent = 3;
         for (let i = 0; i < sent; i++) {
             yield* fixture.owner.client
-                .sendRpc(MessagesSend.name, {
+                .sendRpc(MessagesSend, {
                 conversationId: fixture.conversationId,
                 parts: [{ type: "text", text: `sr-${i}` }],
             })
@@ -271,13 +288,13 @@ export function registerStoreAndReplay(ctx) {
         yield* Effect.sleep("350 millis");
         const snap = yield* participant.client.snapshot;
         const delivered = snap.filter((s) => s.kind === "inbound" &&
-            s.frame?.type === "event" &&
-            typeof s.frame.event === "string" &&
-            s.frame.event.includes("message")).length;
+            s.frame !== null &&
+            isNotificationFrame(s.frame) &&
+            s.frame.method.includes("message")).length;
         if (delivered < sent) {
             return yield* Effect.fail(new PropertyInvariantViolation({
                 category: CATEGORY,
-                name: "store-and-replay",
+                name: STORE_AND_REPLAY_PROPERTY,
                 reason: `sent ${sent}, live participant observed ${delivered}`,
             }));
         }
@@ -290,22 +307,24 @@ export function registerPayloadOpacity(ctx) {
     fc
         .string({ minLength: 4, maxLength: 24 })
         .filter((s) => !/[\\" \n\r\t]/.test(s)), (text) => Effect.runPromise(Effect.scoped(Effect.gen(function* () {
-        const fixture = yield* acquireConversation(ctx, 1, "po").pipe(Effect.mapError((e) => new Error(e)));
+        const fixture = yield* acquireConversation(ctx, 1, "po").pipe(Effect.mapError((e) => violation("payload-opacity", `fixture: ${e}`)));
         const participant = fixture.participants[0];
         if (participant === undefined)
             return false;
-        yield* fixture.owner.client
-            .sendRpc(MessagesSend.name, {
+        yield* fixture.owner.client.sendRpc(MessagesSend, {
             conversationId: fixture.conversationId,
             parts: [{ type: "text", text }],
-        })
-            .pipe(Effect.either);
+        });
         yield* Effect.sleep("250 millis");
         const snap = yield* participant.client.snapshot;
         return snap.some((s) => s.kind === "inbound" &&
-            s.frame?.type === "event" &&
+            s.frame !== null &&
+            isNotificationFrame(s.frame) &&
             s.raw.includes(text));
-    })).pipe(Effect.catchAll(() => Effect.succeed(false))))), { seed: ctx.seed, numRuns: ctx.opts.numRuns ?? 3 })));
+    })).pipe(Effect.catchAll(() => Effect.succeed(false))))), {
+        seed: ctx.seed,
+        numRuns: ctx.opts.numRuns ?? DEFAULT_PROPERTY_NUM_RUNS,
+    })));
 }
 /**
  * Hook-gated delivery — admission verbs are awaitable, the verdict
@@ -332,13 +351,11 @@ export function registerPayloadOpacity(ctx) {
 export function registerHookGatedDelivery(ctx) {
     registerProperty(ctx, CATEGORY, "hook-gated-delivery", "deny drops; patch mutates recipient view; attached conv enters hooks", Effect.scoped(Effect.gen(function* () {
         const fixture = yield* acquireAppSessionFixture(ctx, "hgd", "hook-gated-delivery").pipe(Effect.either);
-        if (fixture._tag === "Left") {
-            return yield* Effect.fail(fixture.left);
-        }
+        yield* requireRight(fixture, (error) => error);
         // Codex review (#327, finding 4): the protocol fixture cannot
         // drive the deny/patch/attach scenarios end-to-end (no DB seam
         // to inspect the recipient view; `apps/attachConversation` is a
-        // c2s RPC but the assertion needs a server-internal observation
+        // client-originated RPC but the assertion needs a server-internal observation
         // the conformance contract does not expose). When a future
         // fixture extension makes apps/create reachable, surface a
         // typed Deferred so the suite reports honest coverage instead
@@ -363,9 +380,7 @@ export function registerHookGatedDelivery(ctx) {
 export function registerMultiAppFifoShortCircuit(ctx) {
     registerProperty(ctx, CATEGORY, "multi-app-fifo-short-circuit", "two apps; first denies; second hook is NOT invoked", Effect.scoped(Effect.gen(function* () {
         const fixture = yield* acquireAppSessionFixture(ctx, "mfs", "multi-app-fifo-short-circuit").pipe(Effect.either);
-        if (fixture._tag === "Left") {
-            return yield* Effect.fail(fixture.left);
-        }
+        yield* requireRight(fixture, (error) => error);
         // Codex review (#327, finding 5): once apps/create succeeds, the
         // FIFO short-circuit assertion requires registering a SECOND
         // app on the same hook and observing the second handler is NOT
@@ -393,12 +408,11 @@ function acquireAppSessionFixture(ctx, namePrefix, propertyName) {
             defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
             captureCapacity: DEFAULT_CAPTURE_CAPACITY,
         }).pipe(Effect.mapError((e) => unavailable(`app client acquire: ${String(e)}`)));
-        const appId = `${namePrefix}-${Date.now().toString(36)}`;
-        const registerOutcome = yield* sendUntypedRpc(appClient, AppsRegister.name, {
+        const appId = `${namePrefix}-${Date.now().toString(DATE_ID_RADIX)}`;
+        const registerOutcome = yield* sendUntypedRpc(appClient, AppsRegister, {
             manifest: {
                 appId,
                 name: `Hook-gated app ${appId}`,
-                permissions: { required: [], optional: [] },
                 conversations: [
                     { key: "main", name: "Main", participantFilter: "all" },
                 ],
@@ -408,9 +422,7 @@ function acquireAppSessionFixture(ctx, namePrefix, propertyName) {
                 },
             },
         }).pipe(Effect.either);
-        if (registerOutcome._tag === "Left") {
-            return yield* Effect.fail(unavailable(`apps/register failed: ${registerOutcome.left._tag}`));
-        }
+        yield* requireRight(registerOutcome, (error) => unavailable(`apps/register failed: ${error._tag}`));
         const senderAgent = yield* registerTestAgent({
             baseUrl: ctx.realServer.baseUrl,
             name: `${namePrefix}-sender`,
@@ -423,16 +435,14 @@ function acquireAppSessionFixture(ctx, namePrefix, propertyName) {
             captureCapacity: DEFAULT_CAPTURE_CAPACITY,
         }).pipe(Effect.mapError((e) => unavailable(`sender client acquire: ${String(e)}`)));
         const createOutcome = yield* senderClient
-            .sendRpc(AppsCreate.name, { appId, invitedAgentIds: [] })
+            .sendRpc(AppsCreate, { appId, invitedAgentIds: [] })
             .pipe(Effect.either);
-        if (createOutcome._tag === "Left") {
-            // Most common cause: owner_user_id is null on the sender (see
-            // app-host.ts:629). The default `startCoreTestServer` does not
-            // configure `devModeUserId`; B.9 fills the gap via DB seeding.
-            return yield* Effect.fail(unavailable(`apps/create failed (likely sender owner_user_id null; B.9 covers via DB seeding): ${createOutcome.left._tag}`));
-        }
-        const session = createOutcome.right
-            .session;
+        const createResult = yield* requireRight(createOutcome, (error) => unavailable(
+        // Most common cause: owner_user_id is null on the sender (see
+        // app-host.ts:629). The default `startCoreTestServer` does not
+        // configure `devModeUserId`; B.9 fills the gap via DB seeding.
+        `apps/create failed (likely sender owner_user_id null; B.9 covers via DB seeding): ${error._tag}`));
+        const session = createResult.session;
         const sessionId = session?.id;
         if (typeof sessionId !== "string" || sessionId.length === 0) {
             return yield* Effect.fail(unavailable(`apps/create returned no session.id`));
@@ -462,20 +472,17 @@ function acquireAppSessionCloseFixture(ctx) {
             defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
             captureCapacity: DEFAULT_CAPTURE_CAPACITY,
         }).pipe(Effect.mapError((e) => unavailable(`app client acquire: ${String(e)}`)));
-        const appId = `close-life-${Date.now().toString(36)}`;
-        const registerOutcome = yield* sendUntypedRpc(appClient, AppsRegister.name, {
+        const appId = `close-life-${Date.now().toString(DATE_ID_RADIX)}`;
+        const registerOutcome = yield* sendUntypedRpc(appClient, AppsRegister, {
             manifest: {
                 appId,
                 name: `Close lifecycle app ${appId}`,
-                permissions: { required: [], optional: [] },
                 conversations: [
                     { key: "main", name: "Main", participantFilter: "all" },
                 ],
             },
         }).pipe(Effect.either);
-        if (registerOutcome._tag === "Left") {
-            return yield* Effect.fail(unavailable(`apps/register failed: ${registerOutcome.left._tag}`));
-        }
+        yield* requireRight(registerOutcome, (error) => unavailable(`apps/register failed: ${error._tag}`));
         const initiatorAgent = yield* registerTestAgent({
             baseUrl: ctx.realServer.baseUrl,
             name: "clinit",
@@ -501,44 +508,42 @@ function acquireAppSessionCloseFixture(ctx) {
             captureCapacity: DEFAULT_CAPTURE_CAPACITY,
         }).pipe(Effect.mapError((e) => unavailable(`invitee client acquire: ${String(e)}`)));
         const createOutcome = yield* initiatorClient
-            .sendRpc(AppsCreate.name, {
+            .sendRpc(AppsCreate, {
             appId,
             invitedAgentIds: [inviteeAgent.agentId],
         })
             .pipe(Effect.either);
-        if (createOutcome._tag === "Left") {
-            return yield* Effect.fail(unavailable(`apps/create failed (likely agents lack owner_user_id): ${createOutcome.left._tag}`));
-        }
-        const session = createOutcome.right.session;
+        const createResult = yield* requireRight(createOutcome, (error) => unavailable(`apps/create failed (likely agents lack owner_user_id): ${error._tag}`));
+        const session = createResult.session;
         const sessionId = session?.id;
         const mainConversationId = session?.conversations?.["main"];
         if (typeof sessionId !== "string" ||
             typeof mainConversationId !== "string") {
-            return yield* Effect.fail(violation(propertyName, `apps/create response missing session id or main conversation: ${JSON.stringify(createOutcome.right)}`));
+            return yield* Effect.fail(violation(propertyName, `apps/create response missing session id or main conversation: ${JSON.stringify(createResult)}`));
         }
         return {
             initiator: { agent: initiatorAgent, client: initiatorClient },
             invitee: { agent: inviteeAgent, client: inviteeClient },
             sessionId,
-            conversationId: mainConversationId,
+            conversationId: makeConversationId(mainConversationId),
         };
     });
 }
 /** Task-boundary isolation — conversation A's events don't leak into B. */
 export function registerTaskBoundaryIsolation(ctx) {
-    registerProperty(ctx, CATEGORY, "task-boundary-isolation", "participants in conversation B observe zero leaks from conversation A", Effect.scoped(Effect.gen(function* () {
+    registerProperty(ctx, CATEGORY, TASK_BOUNDARY_ISOLATION_PROPERTY, "participants in conversation B observe zero leaks from conversation A", Effect.scoped(Effect.gen(function* () {
         const fxA = yield* acquireConversation(ctx, 1, "iso-a").pipe(Effect.mapError((e) => new PropertyInvariantViolation({
             category: CATEGORY,
-            name: "task-boundary-isolation",
+            name: TASK_BOUNDARY_ISOLATION_PROPERTY,
             reason: `fixture A: ${e}`,
         })));
         const fxB = yield* acquireConversation(ctx, 1, "iso-b").pipe(Effect.mapError((e) => new PropertyInvariantViolation({
             category: CATEGORY,
-            name: "task-boundary-isolation",
+            name: TASK_BOUNDARY_ISOLATION_PROPERTY,
             reason: `fixture B: ${e}`,
         })));
         yield* fxA.owner.client
-            .sendRpc(MessagesSend.name, {
+            .sendRpc(MessagesSend, {
             conversationId: fxA.conversationId,
             parts: [{ type: "text", text: "iso-leak-canary" }],
         })
@@ -552,7 +557,7 @@ export function registerTaskBoundaryIsolation(ctx) {
         if (leaked) {
             return yield* Effect.fail(new PropertyInvariantViolation({
                 category: CATEGORY,
-                name: "task-boundary-isolation",
+                name: TASK_BOUNDARY_ISOLATION_PROPERTY,
                 reason: `conversation ${fxA.conversationId} leaked into outsider ${outsider.agent.agentId}`,
             }));
         }
@@ -572,33 +577,23 @@ export function registerConversationLifecycle(ctx) {
     registerProperty(ctx, CATEGORY, CONVERSATION_LIFECYCLE_PROPERTY, "create/send/update/archive/unarchive lifecycle is observable and enforced", Effect.scoped(Effect.gen(function* () {
         const fixture = yield* acquirePropertyConversation(ctx, CONVERSATION_LIFECYCLE_PROPERTY, "life");
         const participant = yield* firstParticipant(fixture, CONVERSATION_LIFECYCLE_PROPERTY);
-        yield* waitForConversationCreatedEvent(participant, fixture.conversationId, CONVERSATION_LIFECYCLE_PROPERTY);
+        yield* waitForConversationCreatedNotification(participant, fixture.conversationId, CONVERSATION_LIFECYCLE_PROPERTY);
         const firstSend = yield* sendText(fixture.owner, fixture.conversationId, "lifecycle-before-update").pipe(Effect.either);
-        if (firstSend._tag === "Left") {
-            return yield* Effect.fail(violation(CONVERSATION_LIFECYCLE_PROPERTY, `messages/send failed before archive: ${firstSend.left._tag}`));
-        }
-        yield* waitForMessageReceivedEvent(participant, fixture.conversationId, CONVERSATION_LIFECYCLE_PROPERTY);
+        yield* requireRight(firstSend, (error) => violation(CONVERSATION_LIFECYCLE_PROPERTY, `messages/send failed before archive: ${error._tag}`));
+        yield* waitForMessageReceivedNotification(participant, fixture.conversationId, CONVERSATION_LIFECYCLE_PROPERTY);
         const updatedName = `Lifecycle ${ctx.seed}`;
         const update = yield* updateConversationName(fixture.owner, fixture.conversationId, updatedName).pipe(Effect.either);
-        if (update._tag === "Left") {
-            return yield* Effect.fail(violation(CONVERSATION_LIFECYCLE_PROPERTY, `conversations/update failed: ${update.left._tag}`));
-        }
-        yield* waitForConversationUpdatedEvent(participant, fixture.conversationId, updatedName, CONVERSATION_LIFECYCLE_PROPERTY);
+        yield* requireRight(update, (error) => violation(CONVERSATION_LIFECYCLE_PROPERTY, `conversations/update failed: ${error._tag}`));
+        yield* waitForConversationUpdatedNotification(participant, fixture.conversationId, updatedName, CONVERSATION_LIFECYCLE_PROPERTY);
         const archive = yield* archiveConversation(fixture.owner, fixture.conversationId).pipe(Effect.either);
-        if (archive._tag === "Left") {
-            return yield* Effect.fail(violation(CONVERSATION_LIFECYCLE_PROPERTY, `archive failed: ${archive.left._tag}`));
-        }
+        yield* requireRight(archive, (error) => violation(CONVERSATION_LIFECYCLE_PROPERTY, `archive failed: ${error._tag}`));
         yield* waitForArchivedEvent(participant, fixture.conversationId, fixture.owner.agent.agentId, CONVERSATION_LIFECYCLE_PROPERTY);
         yield* assertConversationRejectsMessages(participant, fixture.conversationId, CONVERSATION_LIFECYCLE_PROPERTY);
         const unarchive = yield* unarchiveConversation(fixture.owner, fixture.conversationId).pipe(Effect.either);
-        if (unarchive._tag === "Left") {
-            return yield* Effect.fail(violation(CONVERSATION_LIFECYCLE_PROPERTY, `unarchive failed: ${unarchive.left._tag}`));
-        }
+        yield* requireRight(unarchive, (error) => violation(CONVERSATION_LIFECYCLE_PROPERTY, `unarchive failed: ${error._tag}`));
         yield* waitForUnarchivedEvent(participant, fixture.conversationId, fixture.owner.agent.agentId, CONVERSATION_LIFECYCLE_PROPERTY);
         const resumedSend = yield* sendText(participant, fixture.conversationId, "lifecycle-after-unarchive").pipe(Effect.either);
-        if (resumedSend._tag === "Left") {
-            return yield* Effect.fail(violation(CONVERSATION_LIFECYCLE_PROPERTY, `messages/send failed after unarchive: ${resumedSend.left._tag}`));
-        }
+        yield* requireRight(resumedSend, (error) => violation(CONVERSATION_LIFECYCLE_PROPERTY, `messages/send failed after unarchive: ${error._tag}`));
     })));
 }
 /**
@@ -610,16 +605,14 @@ export function registerAppSessionCloseLifecycle(ctx) {
     registerProperty(ctx, CATEGORY, APP_SESSION_CLOSE_LIFECYCLE_PROPERTY, "apps/closeSession archives app conversations and broadcasts session close", Effect.scoped(Effect.gen(function* () {
         const fixture = yield* acquireAppSessionCloseFixture(ctx);
         const close = yield* fixture.initiator.client
-            .sendRpc(AppsCloseSession.name, { sessionId: fixture.sessionId })
+            .sendRpc(AppsCloseSession, { sessionId: fixture.sessionId })
             .pipe(Effect.either);
-        if (close._tag === "Left") {
-            return yield* Effect.fail(violation(APP_SESSION_CLOSE_LIFECYCLE_PROPERTY, `apps/closeSession failed: ${close.left._tag}`));
-        }
-        if (close.right.closed !== true) {
-            return yield* Effect.fail(violation(APP_SESSION_CLOSE_LIFECYCLE_PROPERTY, `apps/closeSession returned unexpected result: ${JSON.stringify(close.right)}`));
+        const closeResult = yield* requireRight(close, (error) => violation(APP_SESSION_CLOSE_LIFECYCLE_PROPERTY, `apps/closeSession failed: ${error._tag}`));
+        if (closeResult.closed !== true) {
+            return yield* Effect.fail(violation(APP_SESSION_CLOSE_LIFECYCLE_PROPERTY, `apps/closeSession returned unexpected result: ${JSON.stringify(closeResult)}`));
         }
         yield* waitForArchivedEvent(fixture.invitee, fixture.conversationId, fixture.initiator.agent.agentId, APP_SESSION_CLOSE_LIFECYCLE_PROPERTY);
-        yield* waitForAppSessionClosedEvent(fixture.invitee, fixture.sessionId, fixture.initiator.agent.agentId, APP_SESSION_CLOSE_LIFECYCLE_PROPERTY);
+        yield* waitForAppSessionClosedNotification(fixture.invitee, fixture.sessionId, fixture.initiator.agent.agentId, APP_SESSION_CLOSE_LIFECYCLE_PROPERTY);
         yield* assertConversationRejectsMessages(fixture.initiator, fixture.conversationId, APP_SESSION_CLOSE_LIFECYCLE_PROPERTY);
     })));
 }
@@ -636,20 +629,14 @@ export function registerArchiveLifecycle(ctx) {
         const fixture = yield* acquirePropertyConversation(ctx, ARCHIVE_LIFECYCLE_PROPERTY, "arch");
         const participant = yield* firstParticipant(fixture, ARCHIVE_LIFECYCLE_PROPERTY);
         const archive = yield* archiveConversation(fixture.owner, fixture.conversationId).pipe(Effect.either);
-        if (archive._tag === "Left") {
-            return yield* Effect.fail(violation(ARCHIVE_LIFECYCLE_PROPERTY, `archive failed: ${archive.left._tag}`));
-        }
+        yield* requireRight(archive, (error) => violation(ARCHIVE_LIFECYCLE_PROPERTY, `archive failed: ${error._tag}`));
         yield* waitForArchivedEvent(participant, fixture.conversationId, fixture.owner.agent.agentId, ARCHIVE_LIFECYCLE_PROPERTY);
         yield* assertConversationRejectsMessages(participant, fixture.conversationId, ARCHIVE_LIFECYCLE_PROPERTY);
         const unarchive = yield* unarchiveConversation(fixture.owner, fixture.conversationId).pipe(Effect.either);
-        if (unarchive._tag === "Left") {
-            return yield* Effect.fail(violation(ARCHIVE_LIFECYCLE_PROPERTY, `unarchive failed: ${unarchive.left._tag}`));
-        }
+        yield* requireRight(unarchive, (error) => violation(ARCHIVE_LIFECYCLE_PROPERTY, `unarchive failed: ${error._tag}`));
         yield* waitForUnarchivedEvent(participant, fixture.conversationId, fixture.owner.agent.agentId, ARCHIVE_LIFECYCLE_PROPERTY);
         const resumedSend = yield* sendText(participant, fixture.conversationId, "must-succeed-after-unarchive").pipe(Effect.either);
-        if (resumedSend._tag === "Left") {
-            return yield* Effect.fail(violation(ARCHIVE_LIFECYCLE_PROPERTY, `messages/send failed after unarchive: ${resumedSend.left._tag}`));
-        }
+        yield* requireRight(resumedSend, (error) => violation(ARCHIVE_LIFECYCLE_PROPERTY, `messages/send failed after unarchive: ${error._tag}`));
     })));
 }
 //# sourceMappingURL=delivery.js.map