@ccmsg/protocol 1.19.0 → 1.21.0

package/src/control/peers.ts

@@ -1,5 +1,4 @@
 import { type Static, Type } from "@sinclair/typebox";
-import { InstanceInfo } from "../common/hello.ts";
 import { topicFrame } from "../envelope.ts";
 import { InstanceId, Sid, Timestamp } from "../identifiers.ts";
 import { SessionMetaFields } from "../session-meta.ts";
@@ -31,8 +30,9 @@ export const SessionState = Type.Union(
 );
 export type SessionState = Static<typeof SessionState>;
 
-/** How long a session stays in `last_live` after it was last seen. The same
- * window the inbox keeps undelivered messages for: what a person comes back to
+/** How long a lost session's row is kept after it was last seen, before the
+ * instance forgets it and the row leaves as a removal. The same window the inbox
+ * keeps undelivered messages for: what a person comes back to
  * is one thing — the session and what was said to it — so the two cannot expire
  * at different times. */
 export const LAST_LIVE_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
@@ -57,11 +57,20 @@ export const StaleClientInfo = Type.Object(
 );
 export type StaleClientInfo = Static<typeof StaleClientInfo>;
 
-/** One session an instance can call live (connected or not).
+/** One session an instance knows of, connected or lost.
  *
  * The paths are the host's, so the entry names the instance holding them:
  * `peers` carries every instance's sessions in one list, and two hosts' paths
- * would otherwise be indistinguishable. */
+ * would otherwise be indistinguishable. The pair `instance` and `sid` is also
+ * what a later row is matched against, since one session lives on one
+ * instance.
+ *
+ * Connected and lost sessions are one kind of row rather than two lists: a
+ * session registering or going quiet moves it between the two, and a row that
+ * changed lists while keeping its identity is an update of that row. Which it
+ * is now is the `state` below, and the fields that only a lost session has
+ * (`last_seen_at`, `stopped_at`, and what it must resume as) are stated
+ * alongside the connection fields it kept. */
 export const PeerInfo = Type.Object(
   {
     sid: Sid,
@@ -81,10 +90,10 @@ export const PeerInfo = Type.Object(
      * notification's `sid_label` — so the material for those is on the row that
      * every client already holds. */
     title: Type.Optional(SessionMetaFields.title),
-    /** How this session stands. One of `waiting`, `live` or `live_unmanaged`:
-     * a session in this list is connected, so it is by definition not gone.
-     * Absent from an instance that states no classification, and a client then
-     * shows the session without grouping it rather than guessing one. */
+    /** How this session stands, which is also what separates a connected row
+     * from one its instance has lost. Absent from an instance that states no
+     * classification, and a client then shows the session without grouping it
+     * rather than guessing one. */
     state: Type.Optional(SessionState),
     /** Set while a person has pinned this session. Absent means not pinned. */
     pinned: Type.Optional(Type.Boolean()),
@@ -129,77 +138,52 @@ export const PeerInfo = Type.Object(
     protocol_version: Type.Optional(Type.Integer({ minimum: 1 })),
     /** Set while some client of this session is being refused. */
     stale_client: Type.Optional(StaleClientInfo),
+    /** The newest instant this session is known to have been alive. Stated on a
+     * row its instance has lost, where it is what the retention window above is
+     * measured from; a connected row is alive now and states none. */
+    last_seen_at: Type.Optional(Timestamp),
+    /** When the session said it was stopping. Its presence is what makes a lost
+     * session a pause rather than a disappearance: one that goes without a word
+     * leaves nothing to stamp here. */
+    stopped_at: Type.Optional(Timestamp),
+    /** What its last turn ran as, in the transcript's own spelling, read back
+     * from the transcript rather than copied from the connection: what a lost
+     * session must resume as is a property of where it actually stopped. A
+     * resume must not quietly switch the session to something else. */
+    model: Type.Optional(SessionMetaFields.model),
+    effort: Type.Optional(SessionMetaFields.effort),
   },
   { $id: "PeerInfo" },
 );
 export type PeerInfo = Static<typeof PeerInfo>;
 
-/** One session that was connected when its instance last saw it, and has not
- * come back.
+/** A row that is gone: the session has been forgotten by the instance that
+ * held it, whether its retention window ran out or a person dropped it.
  *
- * The connection fields are a frozen copy of what that session looked like at
- * the last snapshot, not a live reading — by definition it is not connected
- * while it appears here. The model and effort are the exception: they are read
- * back from the transcript's last turn, because what the session must resume as
- * is a property of where it actually stopped, not of when the snapshot was
- * written. An entry leaves this list the moment its session registers again, so
- * a fully recovered host shows none. */
-export const LastLiveSession = Type.Object(
+ * A removal has to be a marked element rather than an absence, since a frame
+ * carries only what changed and an absence in it says nothing. It names the
+ * same pair every row is matched by and nothing else — there is no row left to
+ * describe. */
+export const PeerRemoved = Type.Object(
   {
     sid: Sid,
     instance: InstanceId,
-    repo: SessionMetaFields.repo,
-    ws: SessionMetaFields.ws,
-    cwd: SessionMetaFields.cwd,
-    /** Also where the model and effort below were read from. */
-    transcript_path: Type.Optional(SessionMetaFields.transcript_path),
-    repo_root: Type.Optional(SessionMetaFields.repo_root),
-    branch: Type.Optional(SessionMetaFields.branch),
-    title: Type.Optional(SessionMetaFields.title),
-    /** How this session stands: `paused` or `disappeared`, which the
-     * `stopped_at` below is what separates. Absent from an instance that states
-     * no classification. */
-    state: Type.Optional(SessionState),
-    /** Set while a person has pinned this session. Absent means not pinned. */
-    pinned: Type.Optional(Type.Boolean()),
-    connected_at: Type.Optional(Timestamp),
-    /** The newest instant this session is known to have been alive. */
-    last_seen_at: Timestamp,
-    /** When the session said it was stopping. Its presence is what makes this a
-     * pause rather than a disappearance: a session that goes without a word
-     * leaves nothing to stamp here. */
-    stopped_at: Type.Optional(Timestamp),
-    /** What its last turn ran as, in the transcript's own spelling. A resume
-     * must not quietly switch the session to something else. */
-    model: Type.Optional(SessionMetaFields.model),
-    effort: Type.Optional(SessionMetaFields.effort),
+    removed: Type.Literal(true),
   },
-  { $id: "LastLiveSession" },
+  { $id: "PeerRemoved" },
 );
-export type LastLiveSession = Static<typeof LastLiveSession>;
+export type PeerRemoved = Static<typeof PeerRemoved>;
+
+export const PeerElement = Type.Union([PeerInfo, PeerRemoved], { $id: "PeerElement" });
+export type PeerElement = Static<typeof PeerElement>;
 
 /** The `peers` topic.
  *
- * Whole-value per instance: a frame replaces everything previously known from
- * the instance that sent it and leaves other instances' entries alone, which is
- * what lets several instances each state their whole list without colliding.
+ * Elements: each frame carries the rows that changed, matched by their
+ * `instance` and `sid`, and rows it does not name are left as they were. A row
+ * changes on its own — one session becoming busy, another going quiet — and
+ * restating every row an instance knows would send a list to report one field.
  *
- * Both lists travel together because a session registering is exactly what
- * moves it from one to the other. */
-export const PeersFrame = topicFrame(
-  "peers",
-  Type.Object({
-    peers: Type.Array(PeerInfo),
-    last_live: Type.Array(LastLiveSession),
-    /** The instances the sending one can see, itself included, as `hello`
-     * answers it. Carried here so that a link going down is something a
-     * subscriber learns from the topic it is already on, rather than by
-     * greeting again to find out. It is the sender's own view like the two
-     * lists above — `reachable` says whether that instance can reach the one it
-     * names, which two instances may legitimately disagree about.
-     *
-     * Absent from an instance that states no view; a client then keeps what it
-     * last knew rather than reading the omission as nothing being reachable. */
-    instances: Type.Optional(Type.Array(InstanceInfo)),
-  }),
-);
+ * The opening `snapshot: true` frame carries every row the instance holds,
+ * connected and lost alike. */
+export const PeersFrame = topicFrame("peers", Type.Object({ peers: Type.Array(PeerElement) }));

package/src/control/sandbox.ts

@@ -37,8 +37,8 @@ export const SandboxGrantResult = Type.Object({
 });
 export type SandboxGrantResult = Static<typeof SandboxGrantResult>;
 
-export const SandboxGrantRequest = request("sandbox_grant", SandboxGrantArgs);
-export const SandboxGrantResponse = response("sandbox_grant", SandboxGrantResult);
+export const SandboxGrantRequest = request("sandbox.grant", SandboxGrantArgs);
+export const SandboxGrantResponse = response("sandbox.grant", SandboxGrantResult);
 
 /** Ends a grant early, as when a preview is closed.
  *
@@ -54,5 +54,5 @@ export type SandboxRevokeArgs = Static<typeof SandboxRevokeArgs>;
 export const SandboxRevokeResult = Type.Object({});
 export type SandboxRevokeResult = Static<typeof SandboxRevokeResult>;
 
-export const SandboxRevokeRequest = request("sandbox_revoke", SandboxRevokeArgs);
-export const SandboxRevokeResponse = response("sandbox_revoke", SandboxRevokeResult);
+export const SandboxRevokeRequest = request("sandbox.revoke", SandboxRevokeArgs);
+export const SandboxRevokeResponse = response("sandbox.revoke", SandboxRevokeResult);

package/src/control/session-errors.ts

@@ -10,10 +10,10 @@ export const SessionErrorEntry = Type.Intersect(
 );
 export type SessionErrorEntry = Static<typeof SessionErrorEntry>;
 
-/** The `session_errors` topic: every connected session currently stopped on a
+/** The `session.errors` topic: every connected session currently stopped on a
  * harness error.
  *
- * Not per session, unlike `session_status`. A client showing a list of sessions
+ * Not per session, unlike `session.status`. A client showing a list of sessions
  * has to mark the stopped ones, and subscribing to a whole status fold for each
  * visible session is the cost this exists to avoid: the instance folds the one
  * error pattern over every connected session instead.
@@ -22,6 +22,6 @@ export type SessionErrorEntry = Static<typeof SessionErrorEntry>;
  * rather than appearing with an empty error, so a client that missed a frame
  * still converges on the next one. */
 export const SessionErrorsFrame = topicFrame(
-  "session_errors",
+  "session.errors",
   Type.Object({ errors: Type.Array(SessionErrorEntry) }),
 );

package/src/control/session-status.ts

@@ -303,9 +303,9 @@ export const SessionStatusSnapshot = Type.Object(
 );
 export type SessionStatusSnapshot = Static<typeof SessionStatusSnapshot>;
 
-/** The `session_status:<sid>` topic. Whole-value: the fold is recomputed and
+/** The `session.status:<sid>` topic. Whole-value: the fold is recomputed and
  * sent entire whenever something in the transcript changes it. */
 export const SessionStatusFrame = topicFrame(
-  "session_status",
+  "session.status",
   Type.Intersect([Type.Object({ sid: Sid }), SessionStatusSnapshot]),
 );

package/src/control/session.ts

@@ -25,8 +25,8 @@ export const SessionKillResult = Type.Object({
 });
 export type SessionKillResult = Static<typeof SessionKillResult>;
 
-export const SessionKillRequest = request("session_kill", SessionKillArgs);
-export const SessionKillResponse = response("session_kill", SessionKillResult);
+export const SessionKillRequest = request("session.kill", SessionKillArgs);
+export const SessionKillResponse = response("session.kill", SessionKillResult);
 
 /** How long a title may be. A title is typed into a terminal and shown as a
  * session's first line, where anything longer is unreadable whatever the
@@ -63,8 +63,8 @@ export const SessionRenameResult = Type.Object({
 });
 export type SessionRenameResult = Static<typeof SessionRenameResult>;
 
-export const SessionRenameRequest = request("session_rename", SessionRenameArgs);
-export const SessionRenameResponse = response("session_rename", SessionRenameResult);
+export const SessionRenameRequest = request("session.rename", SessionRenameArgs);
+export const SessionRenameResponse = response("session.rename", SessionRenameResult);
 
 /** Reads the environment of a session's own process.
  *
@@ -84,8 +84,8 @@ export const SessionEnvReadResult = Type.Object({
 });
 export type SessionEnvReadResult = Static<typeof SessionEnvReadResult>;
 
-export const SessionEnvReadRequest = request("session_env_read", SessionEnvReadArgs);
-export const SessionEnvReadResponse = response("session_env_read", SessionEnvReadResult);
+export const SessionEnvReadRequest = request("session.env.read", SessionEnvReadArgs);
+export const SessionEnvReadResponse = response("session.env.read", SessionEnvReadResult);
 
 /** Searches the transcripts of sessions that have run on this instance,
  * including ones long finished. */
@@ -162,8 +162,8 @@ export const SessionSearchResult = Type.Object({
 });
 export type SessionSearchResult = Static<typeof SessionSearchResult>;
 
-export const SessionSearchRequest = request("session_search", SessionSearchArgs);
-export const SessionSearchResponse = response("session_search", SessionSearchResult);
+export const SessionSearchRequest = request("session.search", SessionSearchArgs);
+export const SessionSearchResponse = response("session.search", SessionSearchResult);
 
 /** Writes a session's dump to a file on the instance's host and answers with
  * its path.
@@ -201,7 +201,7 @@ export const SessionDumpWriteArgs = Type.Object({
    * thing in the vocabulary the rest of the selection is written in. */
   no_thinking: Type.Optional(Type.Boolean()),
   /** Leave out the machinery of in-process agents, which
-   * `["-message:sub", "-tool:Agent"]` also says. */
+   * `["-message.sub", "-tool.Agent"]` also says. */
   no_agent: Type.Optional(Type.Boolean()),
 });
 export type SessionDumpWriteArgs = Static<typeof SessionDumpWriteArgs>;
@@ -221,16 +221,16 @@ export const SessionDumpWriteResult = Type.Object({
 });
 export type SessionDumpWriteResult = Static<typeof SessionDumpWriteResult>;
 
-export const SessionDumpWriteRequest = request("session_dump_write", SessionDumpWriteArgs);
-export const SessionDumpWriteResponse = response("session_dump_write", SessionDumpWriteResult);
+export const SessionDumpWriteRequest = request("session.dump.write", SessionDumpWriteArgs);
+export const SessionDumpWriteResponse = response("session.dump.write", SessionDumpWriteResult);
 
 /** Asks where a forked session stopped being a copy of its ancestor.
  *
  * Forking duplicates the ancestor's records keeping each record id, so nothing
  * inside the file marks the seam; finding it means comparing against the
  * sibling transcripts the instance can already enumerate. */
-export const SessionForkOriginArgs = Type.Object({ sid: Sid });
-export type SessionForkOriginArgs = Static<typeof SessionForkOriginArgs>;
+export const SessionForkOriginReadArgs = Type.Object({ sid: Sid });
+export type SessionForkOriginReadArgs = Static<typeof SessionForkOriginReadArgs>;
 
 export const ForkOrigin = Type.Object(
   {
@@ -245,38 +245,39 @@ export const ForkOrigin = Type.Object(
 );
 export type ForkOrigin = Static<typeof ForkOrigin>;
 
-export const SessionForkOriginResult = Type.Object({
+export const SessionForkOriginReadResult = Type.Object({
   /** Absent both when the session is no fork and when it is one whose ancestor
    * file is gone. Nothing left on disk tells those two apart, and neither has a
    * seam to place. */
   origin: Type.Optional(ForkOrigin),
 });
-export type SessionForkOriginResult = Static<typeof SessionForkOriginResult>;
+export type SessionForkOriginReadResult = Static<typeof SessionForkOriginReadResult>;
 
-export const SessionForkOriginRequest = request("session_fork_origin", SessionForkOriginArgs);
-export const SessionForkOriginResponse = response("session_fork_origin", SessionForkOriginResult);
+export const SessionForkOriginReadRequest = request(
+  "session.fork.origin.read",
+  SessionForkOriginReadArgs,
+);
+export const SessionForkOriginReadResponse = response(
+  "session.fork.origin.read",
+  SessionForkOriginReadResult,
+);
 
-/** Drops one entry from the list of sessions that were running when the
- * instance last saw them.
+/** A person dropping one session an instance still holds a row for, which is
+ * the other way a row reaches `peers` as a `PeerRemoved` — the one that does
+ * not wait for the retention window.
  *
- * The removal touches that list alone: the session stays resumable by every
- * other route, and an instance that later sees it connected records it again.
- * An unknown session is not an error — two clients pressing the same button is
- * the ordinary case, and the caller's goal holds either way. */
-export const SessionLastLiveRemoveArgs = Type.Object({ sid: Sid });
-export type SessionLastLiveRemoveArgs = Static<typeof SessionLastLiveRemoveArgs>;
+ * Forgetting touches the row alone: the session stays resumable by every other
+ * route, and an instance that later sees it connected records it again. An
+ * unknown session is not an error — two clients pressing the same button is the
+ * ordinary case, and the caller's goal holds either way. */
+export const SessionForgetArgs = Type.Object({ sid: Sid });
+export type SessionForgetArgs = Static<typeof SessionForgetArgs>;
 
-export const SessionLastLiveRemoveResult = Type.Object({
+export const SessionForgetResult = Type.Object({
   /** Whether the entry was there to remove. */
   removed: Type.Boolean(),
 });
-export type SessionLastLiveRemoveResult = Static<typeof SessionLastLiveRemoveResult>;
+export type SessionForgetResult = Static<typeof SessionForgetResult>;
 
-export const SessionLastLiveRemoveRequest = request(
-  "session_last_live_remove",
-  SessionLastLiveRemoveArgs,
-);
-export const SessionLastLiveRemoveResponse = response(
-  "session_last_live_remove",
-  SessionLastLiveRemoveResult,
-);
+export const SessionForgetRequest = request("session.forget", SessionForgetArgs);
+export const SessionForgetResponse = response("session.forget", SessionForgetResult);

package/src/control/transcript.ts

@@ -48,8 +48,8 @@ export const TranscriptReadResult = Type.Object({
 });
 export type TranscriptReadResult = Static<typeof TranscriptReadResult>;
 
-export const TranscriptReadRequest = request("transcript_read", TranscriptReadArgs);
-export const TranscriptReadResponse = response("transcript_read", TranscriptReadResult);
+export const TranscriptReadRequest = request("transcript.read", TranscriptReadArgs);
+export const TranscriptReadResponse = response("transcript.read", TranscriptReadResult);
 
 /** Reads a slice of a transcript as the items it was read into.
  *
@@ -115,13 +115,13 @@ export const TranscriptItemsReadResult = Type.Object({
 });
 export type TranscriptItemsReadResult = Static<typeof TranscriptItemsReadResult>;
 
-export const TranscriptItemsReadRequest = request("transcript_items_read", TranscriptItemsReadArgs);
+export const TranscriptItemsReadRequest = request("transcript.items.read", TranscriptItemsReadArgs);
 export const TranscriptItemsReadResponse = response(
-  "transcript_items_read",
+  "transcript.items.read",
   TranscriptItemsReadResult,
 );
 
-/** The `transcript_items:<sid>` topic.
+/** The `transcript.items:<sid>` topic.
  *
  * What `transcript:<sid>` carries as appended bytes, carried as the items those
  * bytes were read as. A subscriber holds a list it only ever appends to, so the
@@ -133,7 +133,7 @@ export const TranscriptItemsReadResponse = response(
  * A record still being written is not classified until its line ends, which is
  * the same rule the raw topic sends whole lines under. */
 export const TranscriptItemsFrame = topicFrame(
-  "transcript_items",
+  "transcript.items",
   Type.Object({
     sid: Sid,
     items: Type.Array(TranscriptItem),

package/src/control/translate.ts

@@ -29,5 +29,5 @@ export const TranslateRunResult = Type.Object({
 });
 export type TranslateRunResult = Static<typeof TranslateRunResult>;
 
-export const TranslateRunRequest = request("translate_run", TranslateRunArgs);
-export const TranslateRunResponse = response("translate_run", TranslateRunResult);
+export const TranslateRunRequest = request("translate.run", TranslateRunArgs);
+export const TranslateRunResponse = response("translate.run", TranslateRunResult);

package/src/envelope.ts

@@ -24,7 +24,7 @@ export const MAX_FRAME_BYTES = 1_048_576;
 export const CallerIdentity = Type.Object(
   {
     role: Role,
-    /** Present exactly when the role is `session`, as in `hello`. */
+    /** Present exactly when the role is `session`, as in `hello.session`. */
     sid: Type.Optional(Sid),
   },
   { $id: "CallerIdentity" },
@@ -102,7 +102,7 @@ export type ErrorResponse = Static<typeof ErrorResponse>;
 
 /** A frame pushed on a topic the connection subscribed to.
  *
- * Snapshot and delta share one shape: the first frame after `topic_subscribe`
+ * Snapshot and delta share one shape: the first frame after `topic.subscribe`
  * carries `snapshot: true` and the whole current value, and later frames carry
  * the same payload type as a change. `instance` names where the frame came
  * from, which is what keeps whole-value topics from several instances out of

package/src/errors.ts

@@ -5,7 +5,7 @@ import { type Static, Type } from "@sinclair/typebox";
 export const ERROR_CODES = [
   // --- connection level (no single op owns these) ---
   /** The request could not be dispatched at all: unparseable JSON, no `op`, no
-   * `request_id`, or a `hello` announcing another protocol generation. */
+   * `request_id`, or a greeting announcing another protocol generation. */
   "bad_request",
   /** The op name is not in the op attribute table. */
   "unknown_op",

package/src/fixtures/common.ts

@@ -4,10 +4,10 @@ import type {
   AuthAssertResponse,
   AuthChallengeRequest,
   AuthChallengeResponse,
-  AuthRefreshRequest,
-  AuthRefreshResponse,
-  AuthRefreshTokenRequest,
-  AuthRefreshTokenResponse,
+  AuthExtendRequest,
+  AuthExtendResponse,
+  AuthTokenRefreshRequest,
+  AuthTokenRefreshResponse,
   AuthRegisterRequest,
   AuthRegisterResponse,
   AuthResolveRequest,
@@ -15,7 +15,12 @@ import type {
   AuthRotateRequest,
   AuthRotateResponse,
 } from "../common/auth.ts";
-import type { HelloRequest, HelloResponse } from "../common/hello.ts";
+import type {
+  HelloInstanceRequest,
+  HelloSessionRequest,
+  HelloSessionResponse,
+  HelloUserRequest,
+} from "../common/hello.ts";
 import type { InstancePingRequest, InstancePingResponse } from "../common/ping.ts";
 import type {
   InstanceShutdownRequest,
@@ -33,10 +38,9 @@ import { FIXTURE_IDS, FIXTURE_NOW } from "./ids.ts";
 
 const { sid, instance, other_instance, endpoint, other_endpoint, request_id } = FIXTURE_IDS;
 
-export const HELLO_REQUEST: Static<typeof HelloRequest> = {
+export const HELLO_SESSION_REQUEST: Static<typeof HelloSessionRequest> = {
   request_id,
-  op: "hello",
-  role: "session",
+  op: "hello.session",
   protocol_version: 3,
   sid,
   client_version: "0.1.0",
@@ -51,12 +55,19 @@ export const HELLO_REQUEST: Static<typeof HelloRequest> = {
   effort: "high",
 };
 
-/** The other side of `hello`: an instance greeting a peer, which carries the
- * mesh claim in place of a session's meta. */
-export const HELLO_MESH_REQUEST: Static<typeof HelloRequest> = {
+/** A person greeting, which names neither a session nor a mesh claim. */
+export const HELLO_USER_REQUEST: Static<typeof HelloUserRequest> = {
+  request_id,
+  op: "hello.user",
+  protocol_version: 3,
+  client_version: "0.1.0",
+};
+
+/** An instance greeting a peer, which carries the mesh claim in place of a
+ * session's meta. */
+export const HELLO_INSTANCE_REQUEST: Static<typeof HelloInstanceRequest> = {
   request_id,
-  op: "hello",
-  role: "instance",
+  op: "hello.instance",
   protocol_version: 3,
   mesh: {
     ver: 1,
@@ -67,7 +78,9 @@ export const HELLO_MESH_REQUEST: Static<typeof HelloRequest> = {
   },
 };
 
-export const HELLO_RESPONSE: Static<typeof HelloResponse> = {
+/** One reply for all three greetings: what an instance answers does not turn
+ * on which of them asked. */
+export const HELLO_RESPONSE: Static<typeof HelloSessionResponse> = {
   ok: true,
   request_id,
   protocol_version: 3,
@@ -86,7 +99,7 @@ export const HELLO_RESPONSE: Static<typeof HelloResponse> = {
 
 export const INSTANCE_PING_REQUEST: Static<typeof InstancePingRequest> = {
   request_id,
-  op: "instance_ping",
+  op: "instance.ping",
 };
 
 export const INSTANCE_PING_RESPONSE: Static<typeof InstancePingResponse> = {
@@ -103,7 +116,7 @@ export const INSTANCE_PING_RESPONSE: Static<typeof InstancePingResponse> = {
 
 export const INSTANCE_SHUTDOWN_REQUEST: Static<typeof InstanceShutdownRequest> = {
   request_id,
-  op: "instance_shutdown",
+  op: "instance.shutdown",
 };
 
 export const INSTANCE_SHUTDOWN_RESPONSE: Static<typeof InstanceShutdownResponse> = {
@@ -113,7 +126,7 @@ export const INSTANCE_SHUTDOWN_RESPONSE: Static<typeof InstanceShutdownResponse>
 
 export const SESSION_STOPPING_REQUEST: Static<typeof SessionStoppingRequest> = {
   request_id,
-  op: "session_stopping",
+  op: "session.stopping",
   reason: "prompt_input_exit",
 };
 
@@ -125,7 +138,7 @@ export const SESSION_STOPPING_RESPONSE: Static<typeof SessionStoppingResponse> =
 
 export const TOPIC_SUBSCRIBE_REQUEST: Static<typeof TopicSubscribeRequest> = {
   request_id,
-  op: "topic_subscribe",
+  op: "topic.subscribe",
   topic: "peers",
 };
 
@@ -139,13 +152,13 @@ export const TOPIC_SUBSCRIBE_RESPONSE: Static<typeof TopicSubscribeResponse> = {
  * are spelled. */
 export const TOPIC_SUBSCRIBE_SESSION_REQUEST: Static<typeof TopicSubscribeRequest> = {
   request_id,
-  op: "topic_subscribe",
+  op: "topic.subscribe",
   topic: `transcript:${sid}`,
 };
 
 export const TOPIC_UNSUBSCRIBE_REQUEST: Static<typeof TopicUnsubscribeRequest> = {
   request_id,
-  op: "topic_unsubscribe",
+  op: "topic.unsubscribe",
   topic: "peers",
 };
 
@@ -169,7 +182,7 @@ const SUBJECT = "personal-1";
 
 export const AUTH_CHALLENGE_REQUEST: Static<typeof AuthChallengeRequest> = {
   request_id,
-  op: "auth_challenge",
+  op: "auth.challenge",
 };
 
 export const AUTH_CHALLENGE_RESPONSE: Static<typeof AuthChallengeResponse> = {
@@ -180,7 +193,7 @@ export const AUTH_CHALLENGE_RESPONSE: Static<typeof AuthChallengeResponse> = {
 
 export const AUTH_REGISTER_REQUEST: Static<typeof AuthRegisterRequest> = {
   request_id,
-  op: "auth_register",
+  op: "auth.register",
   token: REGISTER_TOKEN,
   code: REGISTER_CODE,
   device_label: "work laptop",
@@ -202,7 +215,7 @@ export const AUTH_REGISTER_RESPONSE: Static<typeof AuthRegisterResponse> = {
 
 export const AUTH_ASSERT_REQUEST: Static<typeof AuthAssertRequest> = {
   request_id,
-  op: "auth_assert",
+  op: "auth.assert",
   challenge: CHALLENGE,
   credential: {
     raw_id: "Y3JlZC1pZA",
@@ -220,26 +233,26 @@ export const AUTH_ASSERT_RESPONSE: Static<typeof AuthAssertResponse> = {
   access: ACCESS,
 };
 
-export const AUTH_REFRESH_TOKEN_REQUEST: Static<typeof AuthRefreshTokenRequest> = {
+export const AUTH_TOKEN_REFRESH_REQUEST: Static<typeof AuthTokenRefreshRequest> = {
   request_id,
-  op: "auth_refresh_token",
+  op: "auth.token.refresh",
   reason: "reload",
 };
 
-export const AUTH_REFRESH_TOKEN_RESPONSE: Static<typeof AuthRefreshTokenResponse> = {
+export const AUTH_TOKEN_REFRESH_RESPONSE: Static<typeof AuthTokenRefreshResponse> = {
   ok: true,
   request_id,
   sub: SUBJECT,
   access: ACCESS,
 };
 
-export const AUTH_REFRESH_REQUEST: Static<typeof AuthRefreshRequest> = {
+export const AUTH_EXTEND_REQUEST: Static<typeof AuthExtendRequest> = {
   request_id,
-  op: "auth_refresh",
+  op: "auth.extend",
   access_token: ACCESS.value,
 };
 
-export const AUTH_REFRESH_RESPONSE: Static<typeof AuthRefreshResponse> = {
+export const AUTH_EXTEND_RESPONSE: Static<typeof AuthExtendResponse> = {
   ok: true,
   request_id,
   auth_expires_at: FIXTURE_NOW + 20_000_000,
@@ -247,7 +260,7 @@ export const AUTH_REFRESH_RESPONSE: Static<typeof AuthRefreshResponse> = {
 
 export const AUTH_RESOLVE_REQUEST = {
   request_id,
-  op: "auth_resolve",
+  op: "auth.resolve",
   to_instance: instance,
   kind: "register",
   token: REGISTER_TOKEN,
@@ -275,7 +288,7 @@ export const AUTH_RESOLVE_RESPONSE = {
  * nothing beyond having spent it. */
 export const AUTH_RESOLVE_CHALLENGE_REQUEST = {
   request_id,
-  op: "auth_resolve",
+  op: "auth.resolve",
   to_instance: instance,
   kind: "challenge",
   challenge: CHALLENGE.challenge,
@@ -289,7 +302,7 @@ export const AUTH_RESOLVE_CHALLENGE_RESPONSE = {
 
 export const AUTH_ROTATE_REQUEST: Static<typeof AuthRotateRequest> = {
   request_id,
-  op: "auth_rotate",
+  op: "auth.rotate",
   to_instance: instance,
   refresh_token: REFRESH.value,
   reason: "reconnect",