@ccmsg/cli 0.8.2 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccmsg/cli",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "The ccmsg daemon, CLI and agent plugins for one instance (= one config home)",
   "license": "MIT",
   "author": "kawaz",
@@ -20,7 +20,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ccmsg/protocol": "1.20.0"
+    "@ccmsg/protocol": "1.22.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.0",

package/src/auth/auth.ts

@@ -4,9 +4,9 @@ import type {
   AuthChallenge,
   AuthChallengeResult,
   AuthRecord,
-  AuthRefreshArgs,
+  AuthExtendArgs,
   AuthRefreshReason,
-  AuthRefreshResult,
+  AuthExtendResult,
   AuthRegisterArgs,
   AuthResolveArgs,
   AuthResolveResult,
@@ -339,7 +339,7 @@ export class Auth {
     return closed;
   }
 
-  /** Take what a peer wrote on `auth_records`, and act on the removals in it. */
+  /** Take what a peer wrote on `auth.records`, and act on the removals in it. */
   merge(records: readonly AuthRecord[]): void {
     const { removed } = this.deps.records.merge(records);
     for (const sub of removed) this.disconnect(sub);
@@ -372,7 +372,7 @@ export class Auth {
       this.spend(challenge.challenge);
       return;
     }
-    await this.#atIssuer(challenge.issuer, "auth_resolve", {
+    await this.#atIssuer(challenge.issuer, "auth.resolve", {
       kind: "challenge",
       challenge: challenge.challenge,
     } satisfies AuthResolveArgs);
@@ -497,7 +497,7 @@ export class Auth {
   async #claimsOf(args: AuthRegisterArgs): Promise<RegisterClaims> {
     const stated = claimsOf(args.token);
     if (stated.iss === this.deps.self) return this.resolveRegistration(args.token, args.code);
-    const answer = (await this.#atIssuer(stated.iss, "auth_resolve", {
+    const answer = (await this.#atIssuer(stated.iss, "auth.resolve", {
       kind: "register",
       token: args.token,
       code: args.code,
@@ -510,7 +510,7 @@ export class Auth {
 
   /** Check a registration URL against the secret that signed it, and spend it.
    *
-   * Only the issuer can run this, which is what `auth_resolve` is for. The code
+   * Only the issuer can run this, which is what `auth.resolve` is for. The code
    * is checked here too: it was issued with the secret and is held beside it,
    * and letting another instance check it would be putting the one defence
    * against a leaked URL somewhere the URL's holder could reach. */
@@ -690,7 +690,7 @@ export class Auth {
       // remembered as a time and nothing else. The issuer writes them
       // unchecked, as it does the ones it observes itself (contract,
       // `AuthRotateArgs`).
-      const answer = (await this.#atIssuer(held.body.iss, "auth_rotate", {
+      const answer = (await this.#atIssuer(held.body.iss, "auth.rotate", {
         refresh_token: value,
         ...(from.reason === undefined ? {} : { reason: from.reason }),
         ...(from.ip === undefined ? {} : { ip: from.ip }),
@@ -718,7 +718,7 @@ export class Auth {
       return;
     }
     try {
-      await this.#atIssuer(owner.body.iss, "auth_rotate", {
+      await this.#atIssuer(owner.body.iss, "auth.rotate", {
         refresh_token: value,
       } satisfies AuthRotateArgs);
     } catch {
@@ -729,7 +729,7 @@ export class Auth {
   }
 
   /** Rotate a family this instance minted. The one writer's own operation, and
-   * what `auth_rotate` runs on its behalf. */
+   * what `auth.rotate` runs on its behalf. */
   rotate(value: Base64Url, from: RefreshFrom = {}): AuthRotateResult {
     const held = this.deps.records.byRefresh(value);
     if (held === undefined) {
@@ -862,7 +862,7 @@ export class Auth {
   }
 
   /** Extend a live connection with a token got from `/auth/refresh` (§2.5). */
-  extend(conn: Requester, args: AuthRefreshArgs): AuthRefreshResult {
+  extend(conn: Requester, args: AuthExtendArgs): AuthExtendResult {
     const held = this.#authorized.get(conn);
     if (held === undefined) {
       throw new OpError("auth_invalid", "この接続は token で開かれたものではありません");
@@ -919,9 +919,9 @@ export class Auth {
  * answers for another instance. */
 export function authHandlers(auth: Auth) {
   return {
-    auth_refresh: (input: HandlerInput): AuthRefreshResult =>
-      auth.extend(input.conn, input.args as unknown as AuthRefreshArgs),
-    auth_resolve: (input: HandlerInput): AuthResolveResult => {
+    "auth.extend": (input: HandlerInput): AuthExtendResult =>
+      auth.extend(input.conn, input.args as unknown as AuthExtendArgs),
+    "auth.resolve": (input: HandlerInput): AuthResolveResult => {
       const args = input.args as unknown as AuthResolveArgs;
       if (args.kind === "challenge") {
         auth.spend(args.challenge);
@@ -932,7 +932,7 @@ export function authHandlers(auth: Auth) {
       // the URL and the count of tries against it (§2.2).
       return { kind: "register", claims: auth.resolveRegistration(args.token, args.code) };
     },
-    auth_rotate: (input: HandlerInput): AuthRotateResult => {
+    "auth.rotate": (input: HandlerInput): AuthRotateResult => {
       const args = input.args as unknown as AuthRotateArgs;
       // The receiving instance's account of the person, taken as stated: it is
       // the only one that saw them, and `last_refresh` is a hint nothing is

package/src/auth/http.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import {
   type AuthAssertArgs,
-  type AuthRefreshTokenArgs,
+  type AuthTokenRefreshArgs,
   type AuthRegisterArgs,
   type ErrorCode,
   type InstanceId,
@@ -24,10 +24,10 @@ type Route = (typeof ROUTES)[number];
 /** Which op each route carries. The route is a name a proxy can see; the op is
  * what the attribute table and the schemas are keyed by. */
 const OP_OF: Record<Route, OpName> = {
-  challenge: "auth_challenge",
-  register: "auth_register",
-  assert: "auth_assert",
-  refresh: "auth_refresh_token",
+  challenge: "auth.challenge",
+  register: "auth.register",
+  assert: "auth.assert",
+  refresh: "auth.token.refresh",
 };
 
 /** Cap on an `/auth/*` body. Everything these take is a handful of base64url
@@ -197,7 +197,7 @@ export async function handleAuth(
         if (held === undefined) {
           return refusal("auth_invalid", "この要求には refresh token がありません", cors);
         }
-        const { reason } = args as unknown as AuthRefreshTokenArgs;
+        const { reason } = args as unknown as AuthTokenRefreshArgs;
         const minted = await deps.auth.refreshToken(held, {
           ...(reason === undefined ? {} : { reason }),
           ...(seen.ip === undefined ? {} : { ip: seen.ip }),

package/src/auth/records.ts

@@ -63,7 +63,7 @@ export interface RecordsDeps {
    * from a peer refusable on sight: a family this instance minted is written by
    * this instance alone (DR-0001 §2.4). */
   readonly self: InstanceId;
-  /** Hand what this instance wrote to the peers, on the `auth_records` topic. */
+  /** Hand what this instance wrote to the peers, on the `auth.records` topic. */
   readonly publish: (records: readonly AuthRecord[]) => void;
   readonly now?: () => Timestamp;
 }

package/src/auth/topic.ts

@@ -3,7 +3,7 @@ import type { Requester } from "../dispatch/index.ts";
 import type { TopicValue, UpstreamResource } from "../topics/index.ts";
 import type { AuthRecords } from "./records.ts";
 
-/** `auth_records` as the topic mechanism sees it (DR-0001 §2.6).
+/** `auth.records` as the topic mechanism sees it (DR-0001 §2.6).
  *
  * The records are here whether anyone is subscribed or not — they are what
  * authenticates a person, not a watch on something — so there is nothing to

package/src/cli.ts

@@ -202,7 +202,7 @@ const ROOT: Command = {
         },
         {
           name: "stop",
-          summary: "監督者に、子を止めさせる (instance_shutdown、以後は上げ直さない)",
+          summary: "監督者に、子を止めさせる (instance.shutdown、以後は上げ直さない)",
           usage: "ccmsg daemon stop <dir> | --all",
           run: (args) => supervised("supervise_stop", args),
         },
@@ -214,7 +214,7 @@ const ROOT: Command = {
         },
         {
           name: "status",
-          summary: "監督者が各子に instance_ping して version・network・peers を答える",
+          summary: "監督者が各子に instance.ping して version・network・peers を答える",
           usage: "ccmsg daemon status [dir] | --all",
           bare: true,
           run: (args) => supervised("supervise_status", args, true),
@@ -395,7 +395,7 @@ const ROOT: Command = {
           summary: "この instance が持つ preset の名前と中身を並べる",
           usage: "ccmsg dump presets",
           bare: true,
-          run: () => instanceAsk({ op: "dump_presets_read" }),
+          run: () => instanceAsk({ op: "dump.presets.read" }),
         },
       ],
       run: (args) => dump(args),
@@ -585,7 +585,7 @@ async function runInstance(dir: string | undefined): Promise<unknown> {
   }
   const instance = outcome;
   // A signal is a request to leave, and leaving is the ordered shutdown of
-  // §8.5 — the same one `instance_shutdown` runs, so a client sees the same
+  // §8.5 — the same one `instance.shutdown` runs, so a client sees the same
   // departure either way. The listeners are removed once it has run, because a
   // signal listener keeps the event loop alive and the process would sit at an
   // empty loop instead of exiting.
@@ -852,8 +852,8 @@ function peers(args: readonly string[]): Promise<unknown> {
     "peers",
     parsed.flags.has("all"),
     sid === undefined || sid === ""
-      ? { op: "hello", role: "user", protocol_version: PROTOCOL_VERSION }
-      : { op: "hello", role: "session", sid, protocol_version: PROTOCOL_VERSION, ...statedMeta() },
+      ? { op: "hello.user", protocol_version: PROTOCOL_VERSION }
+      : { op: "hello.session", sid, protocol_version: PROTOCOL_VERSION, ...statedMeta() },
   );
 }
 
@@ -864,8 +864,7 @@ function peers(args: readonly string[]): Promise<unknown> {
 function agents(args: readonly string[]): Promise<unknown> {
   const parsed = options(args, [], ["all", "json"]);
   return topic("agents", parsed.flags.has("all"), {
-    op: "hello",
-    role: "user",
+    op: "hello.user",
     protocol_version: PROTOCOL_VERSION,
   });
 }
@@ -919,7 +918,7 @@ async function dump(args: readonly string[]): Promise<unknown> {
     );
   }
   const written = (await instanceAsk({
-    op: "session_dump_write",
+    op: "session.dump.write",
     ...dumpArgs(subject, parsed.named),
   })) as unknown as SessionDumpWriteResult;
   const body = readFileSync(written.path, "utf8");
@@ -1028,10 +1027,10 @@ function post(args: readonly string[]): Promise<unknown> {
  * delivered envelope as `ccmsg-from`.
  *
  * Without `--to` the answer is for a person, because that is the one message
- * whose reply line carries no addressee: `user` is not a sid and `message_send`
+ * whose reply line carries no addressee: `user` is not a sid and `message.send`
  * addresses a sid, so there is nothing to send to. The contract leaves how such
  * an answer arrives to the instance and names the route — it reaches them as a
- * notification, which is `notify_send`. The caller runs the line either way and
+ * notification, which is `notify.send`. The caller runs the line either way and
  * does not have to know which of the two it became. */
 function reply(args: readonly string[]): Promise<unknown> {
   const parsed = options(args, ["sid", "to"]);
@@ -1080,7 +1079,7 @@ export async function stopping(args: readonly string[], read?: Read): Promise<un
   // what the working directory reveals.
   return await call(
     parsed.named.get("sid") ?? event.sid,
-    { op: "session_stopping", ...(reason === undefined ? {} : { reason }) },
+    { op: "session.stopping", ...(reason === undefined ? {} : { reason }) },
     stated(parsed.named, event),
   );
 }
@@ -1113,8 +1112,7 @@ export async function hello(args: readonly string[], read?: Read): Promise<unkno
   if (conn === undefined) return { greeted: false, reason: "no_instance" };
   try {
     await conn.ask({
-      op: "hello",
-      role: "session",
+      op: "hello.session",
       sid,
       protocol_version: PROTOCOL_VERSION,
       ...meta,
@@ -1224,19 +1222,19 @@ async function plugin(
   return outcome;
 }
 
-/** One `message_send`. */
+/** One `message.send`. */
 function send(named: string | undefined, args: MessageSendArgs): Promise<unknown> {
-  return call(named, { op: "message_send", ...args });
+  return call(named, { op: "message.send", ...args });
 }
 
-/** One `notify_send`. */
+/** One `notify.send`. */
 function announce(named: string | undefined, args: NotifySendArgs): Promise<unknown> {
-  return call(named, { op: "notify_send", ...args });
+  return call(named, { op: "notify.send", ...args });
 }
 
 /** One op, spoken as the session this process runs inside.
  *
- * The greeting is `role: "session"` because that is what the caller is: the
+ * The greeting is `hello.session` because that is what the caller is: the
  * instance takes the sender and the subject from the connection rather than
  * from the arguments, so a connection that greeted as anything else has nobody
  * to answer and nothing to be about.
@@ -1259,7 +1257,7 @@ async function call(
     );
   }
   return await exchange(
-    { op: "hello", role: "session", sid, protocol_version: PROTOCOL_VERSION, ...meta },
+    { op: "hello.session", sid, protocol_version: PROTOCOL_VERSION, ...meta },
     request,
   );
 }
@@ -1269,7 +1267,7 @@ async function call(
  * Which is who is asking: reading a transcript is not something a session is a
  * party to, and the ops that do it are open to a person and to nobody else. */
 function instanceAsk(request: Record<string, unknown>): Promise<unknown> {
-  return exchange({ op: "hello", role: "user", protocol_version: PROTOCOL_VERSION }, request);
+  return exchange({ op: "hello.user", protocol_version: PROTOCOL_VERSION }, request);
 }
 
 /** Greet this config home's instance, ask it one thing, and answer with what
@@ -1354,13 +1352,12 @@ async function posted(text: string): Promise<void> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   const record = async (): Promise<void> => {
     const greeting = await conn.ask({
-      op: "hello",
-      role: "session",
+      op: "hello.session",
       sid,
       protocol_version: PROTOCOL_VERSION,
       ...statedMeta(),
     });
-    if (greeting["ok"] === true) await conn.ask({ op: "say_post", text });
+    if (greeting["ok"] === true) await conn.ask({ op: "say.post", text });
   };
   const budget = new Promise<void>((resolve) => {
     timer = setTimeout(resolve, SAY_POST_MS);

package/src/daemon/control.ts

@@ -49,10 +49,10 @@ export async function connect(path: string): Promise<Conn | undefined> {
 
 /** Greet as the person running the command.
  *
- * `role: "user"` because that is what the caller is: the lifecycle ops belong
+ * `hello.user` because that is what the caller is: the lifecycle ops belong
  * to whoever operates the host, not to a session speaking from inside a turn. */
 export function greetAsUser(conn: Conn): Promise<Record<string, unknown>> {
-  return conn.ask({ op: "hello", role: "user", protocol_version: PROTOCOL_VERSION });
+  return conn.ask({ op: "hello.user", protocol_version: PROTOCOL_VERSION });
 }
 
 /** Reassemble the replies of one exchange, by arrival order. */

package/src/daemon/registry.ts

@@ -110,31 +110,31 @@ const STARTING_PRESETS = [
   {
     name: "file",
     description: "ファイル操作。読み書きと探索をひとまとめに",
-    opts: { types: ["tool:Read", "tool:Write", "tool:Edit", "tool:Glob", "tool:Grep"] },
+    opts: { types: ["tool.Read", "tool.Write", "tool.Edit", "tool.Glob", "tool.Grep"] },
   },
   {
     name: "howto",
     description: "調査のノウハウだけ。何を考えて何を叩いて何を読み書きしたか",
     opts: {
-      types: ["thinking", "message:user", "message:parent", "message:sub", "tool:Bash", "@file"],
+      types: ["thinking", "message.user", "message.parent", "message.sub", "tool.Bash", "@file"],
     },
   },
   {
     name: "journal",
     description: "日記用。人との往復と worker の答え、思考は要点だけ",
     opts: {
-      types: ["message:user", "message:parent", "message:sub:in", "message:team:in", "thinking"],
+      types: ["message.user", "message.parent", "message.sub.in", "message.team.in", "thinking"],
     },
   },
   {
     name: "handoff",
     description: "後継セッションへの引き継ぎ。直近の会話と、走っているものの台帳",
-    opts: { types: ["message", "system:task", "ids"] },
+    opts: { types: ["message", "system.task", "ids"] },
   },
   {
     name: "audit",
     description: "何をしたかの追跡。会話は落として操作と通知だけ",
-    opts: { types: ["@file", "tool:Bash", "notice", "ids"] },
+    opts: { types: ["@file", "tool.Bash", "notice", "ids"] },
   },
 ];
 
@@ -225,7 +225,7 @@ export async function status(target: Target): Promise<StatusRow> {
     if (greeting["ok"] !== true) return row;
     const peers =
       (greeting["instances"] as { id: InstanceId; endpoint: Endpoint }[] | undefined) ?? [];
-    const answer = await conn.ask({ op: "instance_ping" });
+    const answer = await conn.ask({ op: "instance.ping" });
     if (answer["ok"] !== true) return row;
     const ping = answer as unknown as InstancePingResult;
     return {
@@ -259,7 +259,7 @@ export async function stop(target: Target): Promise<{ dir: string; stopped: bool
     if (greeting["ok"] !== true) {
       throw new CommandError("forbidden", `hello が拒否されました: ${JSON.stringify(greeting)}`);
     }
-    const answer = await conn.ask({ op: "instance_shutdown" });
+    const answer = await conn.ask({ op: "instance.shutdown" });
     if (answer["ok"] !== true) {
       throw new CommandError("internal_error", `停止を拒否されました: ${JSON.stringify(answer)}`);
     }

package/src/daemon/snapshot.ts

@@ -2,12 +2,12 @@ import type { InstanceId } from "@ccmsg/protocol";
 import type { Conn } from "./control.ts";
 import { CommandError } from "./link.ts";
 
-/** One instance's whole value on a topic, as the frame carried it.
+/** What one instance opened a topic with, as the frame carried it.
  *
- * The pair rather than the payload alone, because a cluster topic is a whole
- * value *per instance* (§6.2): two instances state the same topic name, and a
- * payload with the name of its author taken off could not be told from the
- * other's. */
+ * The pair rather than the payload alone, because two instances state the same
+ * topic name: a payload with the name of its author taken off could not be told
+ * from the other's, and which instance said it is half of what a cluster read
+ * answers. */
 export interface Snapshot {
   readonly instance: InstanceId;
   readonly data: unknown;
@@ -46,17 +46,19 @@ interface Greeted {
  * frame is deferred behind the acknowledgement and is therefore already on the
  * wire; the relayed ones are what the budget is for.
  *
- * Later frames are folded in the same way a subscriber would fold them: a
- * second frame from an instance replaces that instance's entry and leaves the
- * others alone. Nothing else is waited for — the first frame from every
- * expected instance ends the read. */
+ * The opening frame is the whole of what its instance holds, whichever kind of
+ * topic it is: a `per_instance_whole` one states that instance's reading
+ * entire, and an `element` one opens with every row it has rather than with the
+ * rows that just changed. So one frame per instance is a complete read, and
+ * nothing after it is waited for — the first frame from every expected instance
+ * ends it. */
 export async function snapshots(
   conn: Conn,
   topic: string,
   expected: readonly InstanceId[],
   budgetMs: number = SNAPSHOT_BUDGET_MS,
 ): Promise<Snapshot[]> {
-  const ack = await conn.ask({ op: "topic_subscribe", topic });
+  const ack = await conn.ask({ op: "topic.subscribe", topic });
   if (ack["ok"] !== true) {
     const error = ack["error"] as { code?: string; msg?: string } | undefined;
     throw new CommandError(

package/src/daemon/supervise.ts

@@ -273,7 +273,7 @@ export class Supervisor {
    *
    * Asked over its own socket rather than signalled, so what runs is the
    * ordered shutdown of §8.5 — the same departure a client sees from an
-   * `instance_shutdown`. */
+   * `instance.shutdown`. */
   async stopOne(dir: string): Promise<{ dir: string; stopped: boolean }> {
     const unit = this.#units.get(dir);
     if (unit === undefined) throw new CommandError("not_found", `${dir} は登録されていません`);

package/src/files/containment.ts

@@ -16,7 +16,7 @@ export interface SessionRoots {
    * session greeted with, or its working directory. Absent when the session
    * greeted with neither, which admits no contained path at all. */
   readonly root?: string;
-  /** Where `file_write` puts a file. Kept apart from `root`, which may be the
+  /** Where `file.write` puts a file. Kept apart from `root`, which may be the
    * container above the working copy. */
   readonly cwd?: string;
   /** Absolute folder paths, each admitting its whole subtree. */
@@ -40,7 +40,7 @@ export interface Located {
   readonly path: string;
   /** The same path with its own last segment unresolved: what was named, not
    * what it points at. An op that acts on the name rather than on the file —
-   * `file_delete`, which unlinks a name — asks what kind of thing was named,
+   * `file.delete`, which unlinks a name — asks what kind of thing was named,
    * and only this distinguishes a file from a symlink to one. */
   readonly named: string;
 }
@@ -101,7 +101,7 @@ export class Containment {
     return undefined;
   }
 
-  /** Where `file_write` writes, which is the one destination no kind names: the
+  /** Where `file.write` writes, which is the one destination no kind names: the
    * session's working directory, and within it the inbox the destination is
    * fixed to (DR-0019). A name that leaves the inbox is refused as unwritable
    * rather than as forbidden — the path is reachable, and only writing there
@@ -195,7 +195,7 @@ export class Containment {
  * about rather than one it guesses a range for. An op with no `scope` states
  * no role, and has none to narrow by: dispatch already settled who may call it.
  *
- * The visible range is one function rather than one per op: `transcript_read`
+ * The visible range is one function rather than one per op: `transcript.read`
  * and the file ops narrow by the same rule, and two spellings of it could come
  * apart while both still passing their own tests. */
 export function sees(sid: Sid, viewer: Viewer): boolean {
@@ -223,7 +223,7 @@ export interface DirArgs {
   readonly path?: string;
 }
 
-/** The directory `file_write` writes into, relative to the working directory. */
+/** The directory `file.write` writes into, relative to the working directory. */
 const INBOX = join("docs", "inbox");
 
 const KINDS = ["contained", "workspace", "external"] as const;

package/src/files/files.ts

@@ -28,8 +28,8 @@ import type {
   FileFindResult,
   FileReadArgs,
   FileReadResult,
-  FileStatBatchArgs,
-  FileStatBatchResult,
+  FileStatArgs,
+  FileStatResult,
   FileStatEntry,
   FileWriteArgs,
   FileWriteResult,
@@ -38,7 +38,7 @@ import type {
 import { type HandlerInput, OpError } from "../dispatch/index.ts";
 import type { Containment, Located, Viewer } from "./containment.ts";
 
-/** How much of a file `file_read` carries. Larger files are answered with their
+/** How much of a file `file.read` carries. Larger files are answered with their
  * head and `truncated`, so one file can never cost the connection more than
  * this however big it grew (DR-0008 §5). */
 const READ_LIMIT = 512 * 1024;
@@ -65,7 +65,7 @@ export function fileHandlers(paths: Containment) {
   const viewer = (input: HandlerInput): Viewer => ({ role: input.role, sid: input.identity?.sid });
 
   return {
-    dir_list: (input: HandlerInput): DirListResult => {
+    "dir.list": (input: HandlerInput): DirListResult => {
       const args = input.args as unknown as DirListArgs;
       const at = paths.root(args, viewer(input));
       const stat = existing(at);
@@ -73,7 +73,7 @@ export function fileHandlers(paths: Containment) {
       return { sid: args.sid, path: at.path, entries: entriesOf(at.real) };
     },
 
-    file_read: (input: HandlerInput): FileReadResult => {
+    "file.read": (input: HandlerInput): FileReadResult => {
       const args = input.args as unknown as FileReadArgs;
       const at = paths.locate(args, viewer(input));
       const stat = existing(at);
@@ -95,7 +95,7 @@ export function fileHandlers(paths: Containment) {
       };
     },
 
-    file_write: (input: HandlerInput): FileWriteResult => {
+    "file.write": (input: HandlerInput): FileWriteResult => {
       const args = input.args as unknown as FileWriteArgs;
       const at = paths.inbox(args.sid, args.path, viewer(input));
       // The inbox takes new notes, so an existing name is refused rather than
@@ -106,7 +106,7 @@ export function fileHandlers(paths: Containment) {
       return { sid: args.sid, path: at.path };
     },
 
-    file_create: (input: HandlerInput): FileCreateResult => {
+    "file.create": (input: HandlerInput): FileCreateResult => {
       const args = input.args as unknown as FileCreateArgs;
       const at = paths.locate(args, viewer(input));
       const parent = dirname(at.real);
@@ -117,7 +117,7 @@ export function fileHandlers(paths: Containment) {
       return { sid: args.sid, path: at.path };
     },
 
-    file_edit: (input: HandlerInput): FileEditResult => {
+    "file.edit": (input: HandlerInput): FileEditResult => {
       const args = input.args as unknown as FileEditArgs;
       const at = paths.locate(args, viewer(input));
       const stat = existing(at);
@@ -133,7 +133,7 @@ export function fileHandlers(paths: Containment) {
       return { sid: args.sid, path: at.path, size: after.size, mtime_at: mtimeOf(after) };
     },
 
-    file_delete: (input: HandlerInput): FileDeleteResult => {
+    "file.delete": (input: HandlerInput): FileDeleteResult => {
       const args = input.args as unknown as FileDeleteArgs;
       const at = paths.locate(args, viewer(input));
       // What is unlinked is what is named, so this reads the name itself rather
@@ -150,7 +150,7 @@ export function fileHandlers(paths: Containment) {
       return { sid: args.sid, path: at.path };
     },
 
-    file_find: (input: HandlerInput): FileFindResult => {
+    "file.find": (input: HandlerInput): FileFindResult => {
       const args = input.args as unknown as FileFindArgs;
       const at = paths.root(
         { sid: args.sid, kind: args.kind, ...(args.root === undefined ? {} : { path: args.root }) },
@@ -164,8 +164,8 @@ export function fileHandlers(paths: Containment) {
       return { sid: args.sid, hits: walk.hits, truncated: walk.truncated };
     },
 
-    file_stat_batch: (input: HandlerInput): FileStatBatchResult => {
-      const args = input.args as unknown as FileStatBatchArgs;
+    "file.stat": (input: HandlerInput): FileStatResult => {
+      const args = input.args as unknown as FileStatArgs;
       const results = args.paths.map((path): FileStatEntry | null => {
         const at = paths.identify(args.sid, path, viewer(input));
         if (at === undefined || !isFile(at.real)) return null;

package/src/greeting/meta.ts

@@ -1,11 +1,14 @@
 import { basename, dirname } from "node:path";
-import type { HelloArgs } from "@ccmsg/protocol";
+import type { HelloSessionArgs } from "@ccmsg/protocol";
 
 /** What a session can say about itself when it greets: the contract's shared
  * fields, each of them optional because a greeting states what it knows and
  * the instance leaves the rest unknown (contract, `SessionMetaFields`). */
 export type StatedMeta = Partial<
-  Pick<HelloArgs, "repo" | "ws" | "cwd" | "repo_root" | "branch" | "transcript_path" | "title">
+  Pick<
+    HelloSessionArgs,
+    "repo" | "ws" | "cwd" | "repo_root" | "branch" | "transcript_path" | "title"
+  >
 >;
 
 /** How a question is put to the version control the session works under. The