@ccmsg/cli 0.8.2 → 0.9.1

package/src/instance/config.ts

@@ -1,6 +1,6 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute } from "node:path";
-import type { DumpPreset, Endpoint } from "@ccmsg/protocol";
+import { type DumpPreset, type Endpoint, TranscriptItemSelector } from "@ccmsg/protocol";
 import { DEFAULT_HARNESS, type Harness, HARNESSES, isHarness } from "../harness/index.ts";
 import { parseCidr } from "./client.ts";
 
@@ -47,7 +47,7 @@ export interface LauncherTemplateConfig {
 /** What the launcher may start, and where.
  *
  * Structured rather than a string because it is a form: the roots bound where a
- * session may run, and the recipes are what `launcher_config_read` answers
+ * session may run, and the recipes are what `launcher.config.read` answers
  * with. Present is what gives this instance the `launcher` capability. */
 export interface LauncherConfig {
   /** Absolute directories a session may be started in. A launch or a walk
@@ -55,7 +55,7 @@ export interface LauncherConfig {
   readonly root_dirs: readonly string[];
   /** In configured order; the first is the default recipe. */
   readonly templates: readonly LauncherTemplateConfig[];
-  /** How deep `dir_tree` walks when a request names no depth. */
+  /** How deep `dir.tree` walks when a request names no depth. */
   readonly depth: number;
   /** How long a launch may run before it is stopped. */
   readonly timeout_secs: number;
@@ -98,7 +98,7 @@ export interface UpstreamConfig {
  * not a property of the wire. A type name stays one to one with what a record
  * is, and the groupings people reach for are made by naming a set of them. */
 export interface DumpConfig {
-  /** In configured order, which is the order `dump_presets_read` answers in. */
+  /** In configured order, which is the order `dump.presets.read` answers in. */
   readonly presets: readonly DumpPreset[];
 }
 
@@ -330,9 +330,18 @@ export function parseConfig(file: string, fields: Record<string, unknown>): Inst
   };
 }
 
-/** One element of a selection, as the contract spells it: a type name, a
- * prefix of one, either negated with `-`, or `@name` for a preset. */
-const SELECTOR = /^-?(?:@[A-Za-z0-9][A-Za-z0-9_-]*|[a-z]+(?::[A-Za-z0-9_.-]+)*)$/;
+/** One element of a selection: a type name, a prefix of one, either negated
+ * with `-`, or `@name` for a preset. Taken from the contract's own schema
+ * rather than written again here, so a config file and a request are held to
+ * the one spelling. */
+const SELECTOR = new RegExp(
+  TranscriptItemSelector.pattern ??
+    // A selector schema with no pattern would let every string through here,
+    // which is the one outcome worse than refusing the config file.
+    (() => {
+      throw new Error("the contract's item selector states no pattern");
+    })(),
+);
 
 function dumpOf(file: string, raw: unknown): DumpConfig {
   if (raw === undefined) return { presets: [] };
@@ -368,9 +377,12 @@ function presetsOf(file: string, raw: unknown): DumpPreset[] {
     const types = stringsOf(file, `${at}.opts.types`, opts["types"]);
     const wrong = types.filter((element) => !SELECTOR.test(element));
     if (wrong.length > 0) {
+      // Named rather than dropped: a selection nothing can match would dump an
+      // empty file and say why nowhere. The preset is named beside the strings
+      // so the line to edit is the one the message points at.
       throw new ConfigError(
         file,
-        `${at}.opts.types must be item types, prefixes, exclusions or @presets, got ${wrong.join(", ")}`,
+        `dump.presets[${name}].opts.types must be item types, prefixes, exclusions or @presets, got ${wrong.join(", ")}`,
       );
     }
     return {
@@ -515,7 +527,7 @@ function upstreamOf(file: string, raw: unknown): UpstreamConfig {
   };
 }
 
-/** How deep `dir_tree` walks, and how long a launch may take, when the config
+/** How deep `dir.tree` walks, and how long a launch may take, when the config
  * says neither. */
 const DEFAULT_DEPTH = 2;
 const DEFAULT_TIMEOUT_SECS = 10;

package/src/instance/instance.ts

@@ -394,7 +394,7 @@ export class Instance {
       publish: (topic, data, instance) => {
         this.#topics.publish(topic, data, instance);
       },
-      // What a peer wrote on `auth_records`, folded into the set this instance
+      // What a peer wrote on `auth.records`, folded into the set this instance
       // holds. It is not relayed onward: every instance subscribes to every
       // peer, so a record reaches all of them without anyone repeating it, and
       // what this instance writes travels as its own (DR-0001 §2.6).
@@ -552,11 +552,11 @@ export class Instance {
     this.#topics.attach("transcript", this.#transcripts);
     // One tail feeds both: the bytes as they are appended, and what those
     // bytes were read as.
-    this.#topics.attach("transcript_items", this.#transcripts);
-    this.#topics.attach("session_status", this.#status);
-    this.#topics.attach("session_errors", this.#status);
-    this.#topics.attach("llm_requests", this.#gateway.requests);
-    this.#topics.attach("llm_status", this.#gateway.statusResource);
+    this.#topics.attach("transcript.items", this.#transcripts);
+    this.#topics.attach("session.status", this.#status);
+    this.#topics.attach("session.errors", this.#status);
+    this.#topics.attach("llm.requests", this.#gateway.requests);
+    this.#topics.attach("llm.status", this.#gateway.statusResource);
 
     // The one thing here that is written down and is nobody's derived value
     // (§3.6): what a person saved through a client, which no other party holds
@@ -574,7 +574,7 @@ export class Instance {
       self: this.self,
       ...(now === undefined ? {} : { now }),
       publish: (written) => {
-        this.#topics.publish("auth_records", { records: written });
+        this.#topics.publish("auth.records", { records: written });
       },
     });
     this.#auth = new Auth({
@@ -590,7 +590,7 @@ export class Instance {
         this.log.write(msg, fields);
       },
     });
-    this.#topics.attach("auth_records", new AuthTopic(this.self, records));
+    this.#topics.attach("auth.records", new AuthTopic(this.self, records));
 
     // The upstreams that answer a question rather than hold a value. Each is
     // built only where its config named one, and dispatch has already refused
@@ -618,8 +618,10 @@ export class Instance {
     const origin = config.upstream.sandbox_origin;
 
     this.#handlers = completeHandlers({
-      hello: this.#sessions.hello,
-      session_stopping: this.#sessions.stopping,
+      "hello.session": this.#sessions.helloSession,
+      "hello.user": this.#sessions.helloUser,
+      "hello.instance": this.#sessions.helloInstance,
+      "session.stopping": this.#sessions.stopping,
       ...topicHandlers(this.#topics),
       ...messagingHandlers(this.#delivery, this.#notify),
       ...fileHandlers(files),
@@ -643,8 +645,8 @@ export class Instance {
       ...gatewayHandlers(setup),
       ...kvHandlers(kv),
       ...authHandlers(this.#auth),
-      instance_ping: (): InstancePingResult => this.ping(),
-      instance_shutdown: () => {
+      "instance.ping": (): InstancePingResult => this.ping(),
+      "instance.shutdown": () => {
         // The reply goes out when this handler's value reaches the driver, so
         // stopping is deferred past that turn of the loop rather than run
         // here — the caller is told the request was accepted, which is what
@@ -852,7 +854,7 @@ export class Instance {
       }
       // Let in as a peer rather than on the entry token, and still unproven:
       // the greeting is the one thing it was admitted to make.
-      if (this.#mesh.unproven(conn) && opOf(frame) !== "hello") {
+      if (this.#mesh.unproven(conn) && opOf(frame) !== "hello.instance") {
         conn.close();
         return failure(
           requestIdOf(frame),

package/src/kv/store.ts

@@ -186,10 +186,11 @@ function forget(entries: Map<string, Held>, now: Timestamp): Map<string, Held> {
 
 export function kvHandlers(store: KvStore) {
   return {
-    kv_read: (input: HandlerInput): KvReadResult => store.read(input.args as unknown as KvReadArgs),
-    kv_write: (input: HandlerInput): KvWriteResult =>
+    "kv.read": (input: HandlerInput): KvReadResult =>
+      store.read(input.args as unknown as KvReadArgs),
+    "kv.write": (input: HandlerInput): KvWriteResult =>
       store.write(input.args as unknown as KvWriteArgs),
-    kv_delete: (input: HandlerInput): KvDeleteResult =>
+    "kv.delete": (input: HandlerInput): KvDeleteResult =>
       store.delete(input.args as unknown as KvDeleteArgs),
   };
 }

package/src/launcher/launcher.ts

@@ -126,10 +126,10 @@ export class Launcher {
 
 export function launcherHandlers(launcher: Launcher) {
   return {
-    launcher_config_read: (): LauncherConfigReadResult => launcher.configRead(),
-    launcher_run: (input: HandlerInput): Promise<LauncherRunResult> =>
+    "launcher.config.read": (): LauncherConfigReadResult => launcher.configRead(),
+    "launcher.run": (input: HandlerInput): Promise<LauncherRunResult> =>
       launcher.run(input.args as unknown as LauncherRunArgs),
-    dir_tree: (input: HandlerInput): DirTreeResult =>
+    "dir.tree": (input: HandlerInput): DirTreeResult =>
       launcher.tree(input.args as unknown as DirTreeArgs),
   };
 }

package/src/mesh/mesh.ts

@@ -122,7 +122,7 @@ export interface MeshHost {
   publish(topic: string, data: unknown, instance: InstanceId): void;
   /** Take a frame on a topic the relay does not carry.
    *
-   * `auth_records` is the one: its granularity is `element`, so a frame states
+   * `auth.records` is the one: its granularity is `element`, so a frame states
    * the entries that moved rather than a whole value per instance, and there is
    * nothing for the relay's last-value-per-instance table to hold. What
    * receives it is the set itself, which merges by key (DR-0001 §2.6). */
@@ -469,8 +469,8 @@ export class Mesh {
 
   /** Ask another instance one op, as this instance rather than for anybody.
    *
-   * What the person's authentication needs of a peer (`auth_resolve`,
-   * `auth_rotate`) is a fact only its issuer holds, asked for by the instance
+   * What the person's authentication needs of a peer (`auth.resolve`,
+   * `auth.rotate`) is a fact only its issuer holds, asked for by the instance
    * that needs it — so the `caller` is this instance's own role, and the
    * request travels the ordinary forwarding path (§7.3, DR-0001 §2.6).
    *
@@ -537,7 +537,7 @@ export class Mesh {
    * instance asks of every peer, and the frames come back unchanged (§7.4).
    * `peers` is never given up, because it is also the routing table. */
   demand(topic: string, wanted: boolean): void {
-    // `auth_records` is never given up and never asked for on demand: every
+    // `auth.records` is never given up and never asked for on demand: every
     // instance holds the whole set whether or not anything local is watching
     // it, the way `peers` is also the routing table (§7.4, DR-0001 §2.6).
     if (topic === AUTH_TOPIC || !isClusterTopic(topic)) return;
@@ -561,7 +561,7 @@ export class Mesh {
    * the ordering is the connection's rather than a delay chosen here. */
   #ask(conn: Requester, topic: string, wanted: boolean, afterAck = false): void {
     const frame = {
-      op: wanted ? "topic_subscribe" : "topic_unsubscribe",
+      op: wanted ? "topic.subscribe" : "topic.unsubscribe",
       request_id: `mesh-sub-${randomId()}`,
       topic,
       // The instance asks on behalf of whoever subscribed to it, and what they
@@ -569,7 +569,7 @@ export class Mesh {
       // any one session: a cluster topic is the same value for all of them
       // (§6.2), so there is nothing narrower to name.
       //
-      // `auth_records` is the exception, and the one topic no person may hear:
+      // `auth.records` is the exception, and the one topic no person may hear:
       // it carries the tokens that authenticate them, so the instance asks for
       // it as itself (DR-0001 §2.6).
       caller: (topic === AUTH_TOPIC
@@ -893,9 +893,8 @@ export class Mesh {
     }
     minted.conn = conn;
     conn.send({
-      op: "hello",
+      op: "hello.instance",
       request_id: `mesh-hello-${key.kid}`,
-      role: "instance",
       protocol_version: PROTOCOL_VERSION,
       mesh: { ver: MESH_VER, iss: self, aud: peer, id: this.deps.id, kid: key.kid },
     });

package/src/mesh/relay.ts

@@ -35,7 +35,7 @@ export const CLUSTER_TOPICS: readonly string[] = [
  * It is `element`-granular and its elements are the instances' own, so it is
  * asked for as the instance rather than on a person's behalf, and folded into
  * the set this instance holds rather than held here (DR-0001 §2.6). */
-export const AUTH_TOPIC = "auth_records";
+export const AUTH_TOPIC = "auth.records";
 
 export function isClusterTopic(topic: string): boolean {
   return CLUSTER_TOPICS.includes(topic);

package/src/messaging/delivery.ts

@@ -40,7 +40,7 @@ export interface SessionLookup {
 
 /** The rest of the cluster, for a message addressed outside this instance.
  *
- * `message_send` is a `cluster` op — any instance may be asked — but a message
+ * `message.send` is a `cluster` op — any instance may be asked — but a message
  * reaches a session through the session's own connections, which are held by
  * the instance it greeted. So the op is answered here by carrying it there
  * (§3.2 step 6 is about `instance-local` ops; this is the same forwarding for
@@ -99,7 +99,7 @@ export class Delivery implements UpstreamResource {
     this.#counter = deps.inbox.lastCounter(`${deps.self}/`);
   }
 
-  /** `message_send`. The op fails only for a sid nobody knows; every other
+  /** `message.send`. The op fails only for a sid nobody knows; every other
    * outcome is a success carrying what became of the message. */
   send = async (input: HandlerInput): Promise<MessageSendResult> => {
     const args = input.args as unknown as MessageSendArgs;
@@ -161,7 +161,7 @@ export class Delivery implements UpstreamResource {
         : undefined;
     }
     // The sender, as the owning instance will run the op as: the identity the
-    // connection greeted with, which is the same thing `message_send` reads to
+    // connection greeted with, which is the same thing `message.send` reads to
     // decide who a message is from (§4.1).
     const answer = await cluster.forward(owner, input.args, callerOf(input));
     if (answer.kind === "reply") {
@@ -366,7 +366,7 @@ export class Delivery implements UpstreamResource {
 }
 
 /** Who is asking, as another instance is told it (contract, `CallerIdentity`).
- * A connection with no settled greeting names nobody, and `message_send`
+ * A connection with no settled greeting names nobody, and `message.send`
  * refuses it before this is reached. */
 function callerOf(input: HandlerInput): CallerIdentity | undefined {
   const identity = input.identity;

package/src/messaging/direct.ts

@@ -59,7 +59,7 @@ export const DIRECT_ACK_MS = 2_000;
  * peer message at its inbound gate and reports the outcome from that same
  * decision, so a receipt for a message we have finished writing is one connect
  * and one line away on a socket of this same host. A quarter second is far
- * more than that costs and far less than a person waits for `message_send` to
+ * more than that costs and far less than a person waits for `message.send` to
  * answer. Nothing measured stands behind the number itself. */
 export const DIRECT_STATUS_MS = 250;
 
@@ -358,7 +358,7 @@ const DROPPED = HARNESSES.filter((harness) => harness !== "codex").flatMap((harn
  * belong to the interactive interface.
  *
  * The budget is here for what is not being predicted: a child that never
- * answers would hold `message_send` open for as long as it lived, and route
+ * answers would hold `message.send` open for as long as it lived, and route
  * (b) exists exactly so a route that does not come through costs a message
  * nothing (§4.1). It is generous next to a call that has been measured to
  * return at once. */

package/src/messaging/handlers.ts

@@ -6,9 +6,9 @@ import type { Notify } from "./notify.ts";
  * own entry point under the contract's name. */
 export function messagingHandlers(delivery: Delivery, notify: Notify) {
   return {
-    message_send: delivery.send,
-    notify_send: notify.send,
-    say_post: notify.post,
-    say_mark_read: notify.markRead,
+    "message.send": delivery.send,
+    "notify.send": notify.send,
+    "say.post": notify.post,
+    "say.unread.clear": notify.markRead,
   };
 }

package/src/messaging/inbox.ts

@@ -34,7 +34,7 @@ type Record_ =
 /** What was said to a session and has not reached it.
  *
  * The one thing here that nothing else can reconstruct (§3.6): the sender's
- * `message_send` has already been answered, no transcript holds a message that
+ * `message.send` has already been answered, no transcript holds a message that
  * was never handed over, and the text lives nowhere else. Losing this file
  * loses the words.
  *

package/src/messaging/notify.ts

@@ -3,8 +3,8 @@ import type {
   Notification,
   NotifySendArgs,
   NotifySendResult,
-  SayMarkReadArgs,
-  SayMarkReadResult,
+  SayUnreadClearArgs,
+  SayUnreadClearResult,
   SayPostArgs,
   SayPostResult,
   Sid,
@@ -29,8 +29,8 @@ export interface NotifyDeps {
 /** The `notify` topic and the three ops that speak on it.
  *
  * One object for all three because they are one thing seen from two sides: a
- * line reaching a person watching. `notify_send` is somebody telling a person
- * about a session; `say_post` is a session saying that it just spoke. Both end
+ * line reaching a person watching. `notify.send` is somebody telling a person
+ * about a session; `say.post` is a session saying that it just spoke. Both end
  * as the same frame, which is what keeps "a notification" from meaning two
  * shapes depending on which op raised it.
  *
@@ -44,7 +44,7 @@ export class Notify implements UpstreamResource {
 
   constructor(private readonly deps: NotifyDeps) {}
 
-  /** `notify_send`. The subject is the argument when it names one and the
+  /** `notify.send`. The subject is the argument when it names one and the
    * caller otherwise, so a session notifying about itself says only the text. */
   send = (input: HandlerInput): NotifySendResult => {
     const args = input.args as unknown as NotifySendArgs;
@@ -52,7 +52,7 @@ export class Notify implements UpstreamResource {
     return {};
   };
 
-  /** `say_post`. What was said is already in the caller's transcript, so this
+  /** `say.post`. What was said is already in the caller's transcript, so this
    * pushes the occurrence and raises the unread mark; the instance keeps no log
    * of its own. The op is open to sessions alone, so the subject is the caller
    * and there is nothing to address. */
@@ -64,9 +64,9 @@ export class Notify implements UpstreamResource {
     return { posted_at };
   };
 
-  /** `say_mark_read`. One session's mark, or every one when none is named. */
-  markRead = (input: HandlerInput): SayMarkReadResult => {
-    const { sid } = input.args as unknown as SayMarkReadArgs;
+  /** `say.unread.clear`. One session's mark, or every one when none is named. */
+  markRead = (input: HandlerInput): SayUnreadClearResult => {
+    const { sid } = input.args as unknown as SayUnreadClearArgs;
     if (sid === undefined) this.#unread.clear();
     else this.#unread.delete(sid);
     return {};
@@ -74,7 +74,7 @@ export class Notify implements UpstreamResource {
 
   /** The sessions that have spoken unheard. Nothing in this generation of the
    * contract carries the mark on the wire, so this is how the instance's own
-   * side reads what `say_mark_read` clears. */
+   * side reads what `say.unread.clear` clears. */
   unread(): readonly Sid[] {
     return [...this.#unread];
   }
@@ -113,7 +113,7 @@ export class Notify implements UpstreamResource {
   }
 
   /** The session the caller is. A person's connection names none, which is why
-   * `notify_send` takes the subject as an argument — one that omits it from a
+   * `notify.send` takes the subject as an argument — one that omits it from a
    * connection with no session has named nobody for the notification to be
    * about. */
   #caller(input: HandlerInput): Sid {

package/src/sessions/dump.ts

@@ -47,7 +47,7 @@ export interface DumpDeps {
  *
  * The subject is the session, or one agent below it when the request names
  * one. Every item type is read from wherever the subject stands — an agent's
- * `message:user:in` is the brief its parent gave it — so one selection carries
+ * `message.user.in` is the brief its parent gave it — so one selection carries
  * unchanged down a chain of agents, which is what makes the ledger's agent ids
  * a way to descend rather than just a list. */
 export function dumpWrite(args: SessionDumpWriteArgs, deps: DumpDeps): SessionDumpWriteResult {

package/src/sessions/handlers.ts

@@ -6,12 +6,12 @@ import {
   type SessionDumpWriteArgs,
   type SessionEnvReadArgs,
   type SessionEnvReadResult,
-  type SessionForkOriginArgs,
-  type SessionForkOriginResult,
+  type SessionForkOriginReadArgs,
+  type SessionForkOriginReadResult,
   type SessionKillArgs,
   type SessionKillResult,
-  type SessionLastLiveRemoveArgs,
-  type SessionLastLiveRemoveResult,
+  type SessionForgetArgs,
+  type SessionForgetResult,
   type SessionRenameArgs,
   type SessionRenameResult,
   type SessionSearchArgs,
@@ -69,7 +69,7 @@ export interface SessionOpsDeps {
 /** The ops that observe and operate on sessions.
  *
  * None of them decides who may call it: dispatch has settled that from the
- * attribute table. The one that narrows by role is `transcript_read`, and it
+ * attribute table. The one that narrows by role is `transcript.read`, and it
  * narrows through the same `sees` the file ops narrow through — the visible
  * range of a `scope: "role"` op is one rule, in one place, whatever it is
  * a range over. */
@@ -77,12 +77,12 @@ export function sessionHandlers(deps: SessionOpsDeps) {
   const viewer = (input: HandlerInput): Viewer => ({ role: input.role, sid: input.identity?.sid });
 
   return {
-    session_kill: async (input: HandlerInput): Promise<SessionKillResult> => {
+    "session.kill": async (input: HandlerInput): Promise<SessionKillResult> => {
       const args = input.args as unknown as SessionKillArgs;
       return await deps.processes.kill(args.sid, args.force === true);
     },
 
-    session_rename: async (input: HandlerInput): Promise<SessionRenameResult> => {
+    "session.rename": async (input: HandlerInput): Promise<SessionRenameResult> => {
       const args = input.args as unknown as SessionRenameArgs;
       const title = validTitle(args.title);
       const terminal = await deps.processes.terminal(args.sid);
@@ -93,20 +93,20 @@ export function sessionHandlers(deps: SessionOpsDeps) {
       return { terminal_id: terminal.id, instance: deps.self, title };
     },
 
-    session_env_read: async (input: HandlerInput): Promise<SessionEnvReadResult> => {
+    "session.env.read": async (input: HandlerInput): Promise<SessionEnvReadResult> => {
       const args = input.args as unknown as SessionEnvReadArgs;
       const { pid, env } = await deps.processes.environment(args.sid);
       return { pid, instance: deps.self, env };
     },
 
-    session_search: (input: HandlerInput) =>
+    "session.search": (input: HandlerInput) =>
       search(input.args as unknown as SessionSearchArgs, {
         self: deps.self,
         configHome: deps.configHome,
         files: deps.files,
       }),
 
-    session_dump_write: (input: HandlerInput) =>
+    "session.dump.write": (input: HandlerInput) =>
       dumpWrite(input.args as unknown as SessionDumpWriteArgs, {
         self: deps.self,
         stateDir: deps.stateDir,
@@ -120,22 +120,22 @@ export function sessionHandlers(deps: SessionOpsDeps) {
      * free-text field and let the instance refuse. A preset that references
      * another is answered as written: the expansion, and the refusal of a
      * cycle, happen where the config is read. */
-    dump_presets_read: (): DumpPresetsReadResult => ({ presets: [...deps.presets] }),
+    "dump.presets.read": (): DumpPresetsReadResult => ({ presets: [...deps.presets] }),
 
-    session_fork_origin: (input: HandlerInput): SessionForkOriginResult => {
-      const args = input.args as unknown as SessionForkOriginArgs;
+    "session.fork.origin.read": (input: HandlerInput): SessionForkOriginReadResult => {
+      const args = input.args as unknown as SessionForkOriginReadArgs;
       const origin = forkOrigin(args.sid, deps.files);
       return origin === undefined ? {} : { origin };
     },
 
-    session_last_live_remove: (input: HandlerInput): SessionLastLiveRemoveResult => {
-      const args = input.args as unknown as SessionLastLiveRemoveArgs;
+    "session.forget": (input: HandlerInput): SessionForgetResult => {
+      const args = input.args as unknown as SessionForgetArgs;
       // 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.
       return { removed: deps.forget(args.sid) };
     },
 
-    transcript_read: (input: HandlerInput): TranscriptReadResult => {
+    "transcript.read": (input: HandlerInput): TranscriptReadResult => {
       const args = input.args as unknown as TranscriptReadArgs;
       if (!sees(args.sid, viewer(input))) {
         // The role sets the visible range, not the permission (§3.2): outside
@@ -153,7 +153,7 @@ export function sessionHandlers(deps: SessionOpsDeps) {
      * The role narrows it the way it narrows the raw read: what a role may see
      * is one rule whatever is being read, and a caller that cannot see a
      * session cannot see it in either vocabulary. */
-    transcript_items_read: (input: HandlerInput): TranscriptItemsReadResult => {
+    "transcript.items.read": (input: HandlerInput): TranscriptItemsReadResult => {
       const args = input.args as unknown as TranscriptItemsReadArgs;
       if (!sees(args.sid, viewer(input))) {
         throw new OpError("not_found", `no transcript is known for ${args.sid}`);

package/src/sessions/harness.ts

@@ -164,7 +164,7 @@ export class HarnessSessions implements OwnSessions {
    *
    * Every answer comes from here rather than from anything the watch left
    * behind. Which sessions exist is an input to the classification (§5.1), and
-   * classifying happens inside `message_send`'s decision and inside the
+   * classifying happens inside `message.send`'s decision and inside the
    * recompute that writes `last_live` — neither of which can hand back a
    * promise without changing what it means, and neither of which may depend on
    * somebody being subscribed. The ops that signal a session's process read it

package/src/sessions/last-live.ts

@@ -106,7 +106,7 @@ export class LastLiveStore {
     this.#save();
   }
 
-  /** Drop one entry: `session_last_live_remove`, and a session registering
+  /** Drop one entry: `session.forget`, and a session registering
    * again, which is what moves it back to the connected list. */
   remove(sid: Sid): boolean {
     if (!this.#entries.delete(sid)) return false;