rt chat: archive a room, open a DM without posting (rt-client 0.7.0)

commands/__tests__/chat.test.ts

@@ -382,6 +382,25 @@ describe("rt chat CLI — additional verb behavior", () => {
     const rooms = JSON.parse(await runChat(["rooms", "--json", "--as", "solo"]));
     expect(rooms.rooms).toEqual([]);
   });
+
+  test("archive hides the room from rooms until reopened; --json reports the stamp", async () => {
+    await runChat(["join", "r", "--as", "a"]);
+    const out = JSON.parse(await runChat(["archive", "r", "--json", "--as", "a"]));
+    expect(out.ok).toBe(true);
+    expect(out.room).toBe("r");
+    expect(typeof out.archivedAt).toBe("number");
+    expect(JSON.parse(await runChat(["rooms", "--json", "--as", "a"])).rooms).toEqual([]);
+
+    const plain = await runChat(["archive", "r", "--reopen", "--as", "a"]);
+    expect(plain).toContain("reopened #r");
+    expect(JSON.parse(await runChat(["rooms", "--json", "--as", "a"])).rooms.map((x: { room: string }) => x.room)).toEqual(["r"]);
+  });
+
+  test("archive refuses a room that does not exist with exit 1", async () => {
+    const { code, stderr } = await runChatRaw(["archive", "ghost", "--as", "a"]);
+    expect(code).toBe(1);
+    expect(stderr).toContain("no such room");
+  });
 });
 
 // ─── sign-in / sign-out (presence) ──────────────────────────────────────────

commands/chat.ts

@@ -3,6 +3,7 @@
  *
  *   rt chat join <room> [--as <h>] [--wake-on mention|all|none]
  *   rt chat leave <room>
+ *   rt chat archive <room> [--reopen]              park a room for everyone; a post revives it
  *   rt chat post <room> <<'EOF' ... EOF          the body on stdin; <text> for a one-liner
  *   rt chat read [room] [--limit 20] [--full] [--since <dur>]
  *   rt chat read <room> --last <n>                 newest N regardless of cursor, then marks read
@@ -53,6 +54,7 @@ import { chatViewerUrl, readChatViewerUrlSetting } from "../lib/chat-viewer-url.
 import { planSessionRename, type RenamePlan } from "../lib/chat-rename.ts";
 import { parseDuration } from "./events.ts";
 import {
+  chatArchive,
   chatArm,
   chatAway,
   chatBack,
@@ -632,6 +634,29 @@ async function runLeave(args: string[]): Promise<void> {
   console.log(`✓ left #${room} (${handle})`);
 }
 
+async function runArchive(args: string[]): Promise<void> {
+  const room = positional(args);
+  if (!room) fail("usage: rt chat archive <room> [--reopen]");
+  requireValidName("room", room);
+
+  const handle = resolveHandle(args);
+  requireValidName("handle", handle);
+
+  const archived = !args.includes("--reopen");
+  const res = await chatArchive({ room, handle, archived });
+  const data = unwrap(res, "archive");
+
+  if (args.includes("--json")) {
+    console.log(JSON.stringify({ ok: true, room: data.room, archivedAt: data.archivedAt }));
+    return;
+  }
+  console.log(
+    archived
+      ? `archived #${room}: hidden from every member's rooms until someone posts into it`
+      : `reopened #${room}`,
+  );
+}
+
 /**
  * The body of a post or DM. Three sources, first match wins: `--file <path>`,
  * stdin (no text while stdin is not a terminal, which is what a heredoc looks
@@ -1405,11 +1430,12 @@ export async function chatTail(args: string[]): Promise<void> {
 // ─── dispatcher ────────────────────────────────────────────────────────────────
 
 const USAGE =
-  "usage: rt chat <join|leave|post|read|rooms|who|mark|tail|sign-in|sign-out|away|back|buddies|dm|pulse|invite> ...";
+  "usage: rt chat <join|leave|archive|post|read|rooms|who|mark|tail|sign-in|sign-out|away|back|buddies|dm|pulse|invite> ...";
 
 const VERBS: Record<string, (args: string[]) => Promise<void>> = {
   join: runJoin,
   leave: runLeave,
+  archive: runArchive,
   post: runPost,
   read: runRead,
   rooms: runRooms,
@@ -1435,6 +1461,7 @@ const VERB_HINTS: Record<string, string> = {
   join: "join a room",
   leave: "leave a room",
   mark: "mark a room read",
+  archive: "park a room (post revives it)",
   tail: "stream wakes for this handle",
   "sign-in": "sign in and set presence",
   "sign-out": "sign out",

lib/command-tree-def.ts

@@ -695,20 +695,21 @@ export const TREE: Record<string, CommandNode> = {
     ],
   },
 
-  // Self-dispatching leaf: chat() routes its own verbs (join/leave/post/read/
-  // rooms/who/mark/tail/sign-in/sign-out/away/back/buddies/dm/pulse/invite),
+  // Self-dispatching leaf: chat() routes its own verbs (join/leave/archive/
+  // post/read/rooms/who/mark/tail/sign-in/sign-out/away/back/buddies/dm/pulse/invite),
   // so all args flow through rather than a subcommand map.
   chat: {
     description: "Group chat for agents and their human, over the rt daemon",
     module: "./commands/chat.ts",
     fn: "chat",
     omitBehavior: "picker",
     args: [
-      { name: "Verb", type: "text", placeholder: "join | leave | post | read | rooms | who | mark | tail | sign-in | sign-out | away | back | buddies | dm | pulse | invite", hint: "The chat action to run" },
-      { name: "Room", type: "text", optional: true, placeholder: "build", hint: "Room name for join/leave/post/read/who/mark; the target handle for dm; the pane id for invite; omit on read/rooms/who to span everything, and on sign-in/sign-out/buddies/pulse/back/away, which take no room" },
+      { name: "Verb", type: "text", placeholder: "join | leave | archive | post | read | rooms | who | mark | tail | sign-in | sign-out | away | back | buddies | dm | pulse | invite", hint: "The chat action to run" },
+      { name: "Room", type: "text", optional: true, placeholder: "build", hint: "Room name for join/leave/archive/post/read/who/mark; the target handle for dm; the pane id for invite; omit on read/rooms/who to span everything, and on sign-in/sign-out/buddies/pulse/back/away, which take no room" },
       { name: "Text", type: "text", optional: true, placeholder: "@handle message", hint: "A one-line message body (every word after the room/handle) — post, dm; leave it out and feed the body on stdin (a heredoc) so paragraphs and lists survive; away takes this directly, with no room before it" },
       { name: "As handle", flag: "--as", type: "text", placeholder: "repo-tools-main", hint: "Override the derived handle for this invocation; refused while signed in (sign out first)" },
       { name: "Wake on", flag: "--wake-on", type: "text", placeholder: "mention | all | none", hint: "For join: when this handle's tail wakes (default mention)" },
+      { name: "Reopen", flag: "--reopen", type: "boolean", default: false, hint: "For archive: clear the archive instead of setting it" },
       { name: "Limit", flag: "--limit", type: "text", placeholder: "20", hint: "For read: max messages (default 20)" },
       { name: "Since", flag: "--since", type: "text", placeholder: "5m", hint: "For read: a non-advancing peek at messages newer than this duration" },
       { name: "Last", flag: "--last", type: "text", optional: true, placeholder: "10", hint: "read: the newest N messages regardless of your cursor, then mark read" },
@@ -722,7 +723,7 @@ export const TREE: Record<string, CommandNode> = {
       { name: "Body file", flag: "--file", type: "text", placeholder: "post.md", hint: "For post/dm: read the body from a file instead of stdin or the text" },
       { name: "As is", flag: "--as-is", type: "boolean", default: false, hint: "For post/dm: post a long single-line body anyway (500+ characters with no line break is refused by default)" },
       { name: "Quiet", flag: "--quiet", type: "boolean", default: false, hint: "For sign-out: suppress output (the SessionEnd hook's flag)" },
-      { name: "JSON", flag: "--json", type: "boolean", default: false, hint: "Emit machine-readable JSON instead of the plain rendering (join/leave/post/read/rooms/who/mark/buddies/dm/pulse/away/back/sign-in/sign-out/invite)" },
+      { name: "JSON", flag: "--json", type: "boolean", default: false, hint: "Emit machine-readable JSON instead of the plain rendering (join/leave/archive/post/read/rooms/who/mark/buddies/dm/pulse/away/back/sign-in/sign-out/invite)" },
     ],
   },
 

lib/daemon/__tests__/chat-handlers.test.ts

@@ -523,3 +523,96 @@ test("chat:invite is herdr unavailable when the socket is missing", async () =>
   if (res.ok) throw new Error("unreachable");
   expect(res.error.startsWith("herdr unavailable")).toBe(true);
 });
+
+test("chat:archive hides the room from chat:rooms until includeArchived asks, and reopen restores it", async () => {
+  const h = freshHandlers();
+  await h["chat:join"]({ room: "build", handle: "a" });
+  const res = await h["chat:archive"]({ room: "build", handle: "a", archived: true });
+  expect(res.ok).toBe(true);
+  if (!res.ok) throw new Error("unreachable");
+  expect(res.data.room).toBe("build");
+  expect(typeof res.data.archivedAt).toBe("number");
+
+  const hidden = await h["chat:rooms"]({ handle: "a" });
+  if (!hidden.ok) throw new Error("unreachable");
+  expect(hidden.data.rooms).toEqual([]);
+
+  const shown = await h["chat:rooms"]({ handle: "a", includeArchived: true });
+  if (!shown.ok) throw new Error("unreachable");
+  expect(shown.data.rooms).toHaveLength(1);
+  expect(shown.data.rooms[0]).toMatchObject({ room: "build", archivedAt: res.data.archivedAt });
+
+  const reopened = await h["chat:archive"]({ room: "build", handle: "a", archived: false });
+  if (!reopened.ok) throw new Error("unreachable");
+  expect(reopened.data).toEqual({ room: "build", archivedAt: null });
+  const back = await h["chat:rooms"]({ handle: "a" });
+  if (!back.ok) throw new Error("unreachable");
+  expect(back.data.rooms.map((r) => r.room)).toEqual(["build"]);
+});
+
+test("chat:archive refuses an unknown room and an invalid name with a reason", async () => {
+  const h = freshHandlers();
+  const missing = await h["chat:archive"]({ room: "nope", handle: "a", archived: true });
+  expect(missing.ok).toBe(false);
+  if (missing.ok) throw new Error("unreachable");
+  expect(missing.error).toContain("no such room");
+  const bad = await h["chat:archive"]({ room: "Has@Sigil", handle: "a", archived: true });
+  expect(bad.ok).toBe(false);
+  if (bad.ok) throw new Error("unreachable");
+  expect(bad.error).toContain("room");
+});
+
+test("chat:dm-open creates the pair's room without posting, then reuses it", async () => {
+  const emitted: string[] = [];
+  const h = freshHandlers((topic) => { emitted.push(topic); return 0; });
+  const first = await h["chat:dm-open"]({ from: "matt", to: "a" });
+  expect(first.ok).toBe(true);
+  if (!first.ok) throw new Error("unreachable");
+  expect(first.data.created).toBe(true);
+  expect(first.data.room).toMatch(/^dm-/);
+  expect(emitted).toEqual([]);
+
+  const again = await h["chat:dm-open"]({ from: "matt", to: "a" });
+  if (!again.ok) throw new Error("unreachable");
+  expect(again.data).toEqual({ room: first.data.room, created: false });
+
+  const messages = await h["chat:messages"]({ room: first.data.room });
+  if (!messages.ok) throw new Error("unreachable");
+  expect(messages.data.messages).toEqual([]);
+  const who = await h["chat:who"]({ room: first.data.room });
+  if (!who.ok) throw new Error("unreachable");
+  expect(who.data.members.map((m) => m.handle).sort()).toEqual(["a", "matt"]);
+});
+
+test("chat:dm-open refuses a self DM, an invalid handle, and an empty humanHandle setting", async () => {
+  const h = freshHandlers();
+  const self = await h["chat:dm-open"]({ from: "matt", to: "matt" });
+  expect(self.ok).toBe(false);
+  if (self.ok) throw new Error("unreachable");
+  expect(self.error).toMatch(/your own/i);
+
+  const bad = await h["chat:dm-open"]({ from: "matt", to: "a:b" });
+  expect(bad.ok).toBe(false);
+
+  setSetting("chat.humanHandle", "", "user");
+  try {
+    const empty = await h["chat:dm-open"]({ from: "matt", to: "a" });
+    expect(empty.ok).toBe(false);
+    if (empty.ok) throw new Error("unreachable");
+    expect(empty.error).toContain("chat.humanHandle");
+  } finally {
+    setSetting("chat.humanHandle", "matt", "user");
+  }
+});
+
+test("chat:dm-open refuses a reclaimed sender the same way chat:dm does", async () => {
+  // Same setup as `chat:dm refuses a reclaimed sender`: the
+  // first session goes stale, a second session claims the handle, and the
+  // stale session's own id no longer owns it.
+  const h = freshHandlers();
+  await h["chat:sign-in"]({ sessionId: "s1", baseHandle: "a" });
+  h.db.run("UPDATE chat_presence SET last_seen_at = last_seen_at - 7200000");
+  await h["chat:sign-in"]({ sessionId: "s2", baseHandle: "a" });
+  const res = await h["chat:dm-open"]({ from: "a", to: "b", sessionId: "s1" });
+  expect(res.ok).toBe(false);
+});

lib/daemon/handlers/chat.ts

@@ -16,6 +16,7 @@ import {
   markRead,
   unreadWakingCount,
   listRooms,
+  archiveRoom,
   roomDefaultWake,
   listMembers,
   armMember,
@@ -65,6 +66,8 @@ const CHAT_COMMANDS = [
   "chat:pulse",
   "chat:dm",
   "chat:invite",
+  "chat:archive",
+  "chat:dm-open",
 ] as const;
 
 /** Collapses the repeated try/catch every presence-assertion call site needs into one line: null on success, the refusal's message on throw. */
@@ -193,7 +196,7 @@ export function createChatHandlers(opts: {
     },
 
     "chat:rooms": async (payload: Commands["chat:rooms"]["payload"]): Promise<CommandResult<"chat:rooms">> => {
-      const rooms = listRooms(payload.handle, db).map((room) => {
+      const rooms = listRooms(payload.handle, db, { includeArchived: payload.includeArchived === true }).map((room) => {
         const defaultWake = roomDefaultWake(room.room, db);
         const withDefault = defaultWake ? { ...room, defaultWake } : room;
         const dm = dmParticipants(room.room, db);
@@ -376,5 +379,34 @@ export function createChatHandlers(opts: {
       const nudged = await herdr("agent.wait", { target: paneId, until: ["working"], timeout_ms: INVITE_WAIT_MS }, { timeoutMs: waitTimeout(INVITE_WAIT_MS) });
       return { ok: true, data: { paneId, delivered: nudged.ok ? "accepted" : "queued" } };
     },
+
+    "chat:archive": async (payload: Commands["chat:archive"]["payload"]): Promise<CommandResult<"chat:archive">> => {
+      const { room, handle, archived } = payload;
+      if (!isValidChatName(handle)) return { ok: false, error: `invalid handle "${handle}"` };
+      if (!isValidChatName(room)) return { ok: false, error: `invalid room "${room}"` };
+      if (typeof archived !== "boolean") return { ok: false, error: "archived must be true or false" };
+      try {
+        return { ok: true, data: archiveRoom(room, archived, db) };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    },
+
+    "chat:dm-open": async (payload: Commands["chat:dm-open"]["payload"]): Promise<CommandResult<"chat:dm-open">> => {
+      const { from, to, sessionId } = payload;
+      if (!isValidChatName(from)) return { ok: false, error: `invalid handle "${from}"` };
+      if (!isValidChatName(to)) return { ok: false, error: `invalid handle "${to}"` };
+      const err = assertionError(() => assertSessionOwnsHandle(from, sessionId, db));
+      if (err) return { ok: false, error: err };
+      const humanHandle = getSetting<string>("chat.humanHandle").value;
+      if (!isValidChatName(humanHandle)) {
+        return { ok: false, error: `chat: chat.humanHandle setting is empty or invalid ("${humanHandle}")` };
+      }
+      try {
+        return { ok: true, data: dmRoomFor(from, to, humanHandle, db) };
+      } catch (dmErr) {
+        return { ok: false, error: dmErr instanceof Error ? dmErr.message : String(dmErr) };
+      }
+    },
   };
 }

lib/state/__tests__/chat-store.test.ts

@@ -15,6 +15,7 @@ import { tmpdir } from "os";
 import { join } from "path";
 import { openStateDb } from "../db.ts";
 import {
+  archiveRoom,
   armMember,
   clearAllArmed,
   disarmMember,
@@ -29,6 +30,7 @@ import {
   postMessage,
   readUnread,
   recipientsFor,
+  roomArchivedAt,
   touchMember,
   unreadWakingCount,
 } from "../chat-store.ts";
@@ -257,3 +259,87 @@ test("startup clear covers presence arming", () => {
   clearAllArmed(db);
   expect(db.query("SELECT armed_at FROM chat_presence").get()).toMatchObject({ armed_at: null });
 });
+
+test("archive hides a room from every membership walk and keeps the member rows", () => {
+  const db = freshDb();
+  joinRoom({ room: "build", handle: "a" }, db);
+  joinRoom({ room: "build", handle: "b" }, db);
+  joinRoom({ room: "other", handle: "b" }, db);
+  postMessage({ room: "build", handle: "a", body: "@b look" }, db);
+
+  const stamped = archiveRoom("build", true, db);
+  expect(stamped.room).toBe("build");
+  expect(typeof stamped.archivedAt).toBe("number");
+  expect(roomArchivedAt("build", db)).toBe(stamped.archivedAt);
+
+  expect(listRooms("b", db).map(r => r.room)).toEqual(["other"]);
+  expect(listRooms("b", db, { includeArchived: true }).map(r => [r.room, r.archivedAt !== undefined])).toEqual([["build", true], ["other", false]]);
+  expect(unreadWakingCount("b", db)).toEqual([]);
+  expect(readUnread({ handle: "b", limit: 20 }, db)).toEqual([]);
+  expect(listMembers("build", db).map(m => m.handle)).toEqual(["a", "b"]);
+});
+
+test("a room named explicitly still answers while archived", () => {
+  const db = freshDb();
+  joinRoom({ room: "build", handle: "a" }, db);
+  joinRoom({ room: "build", handle: "b" }, db);
+  postMessage({ room: "build", handle: "a", body: "hi" }, db);
+  archiveRoom("build", true, db);
+  const read = readUnread({ handle: "b", room: "build", limit: 20 }, db);
+  expect(read).toHaveLength(1);
+  expect(read[0]!.messages.map(m => m.body)).toEqual(["hi"]);
+  expect(listMessages({ room: "build", limit: 20 }, db)).toHaveLength(1);
+});
+
+test("a post into an archived room revives it and wakes the members who were there", () => {
+  const db = freshDb();
+  joinRoom({ room: "build", handle: "a" }, db);
+  joinRoom({ room: "build", handle: "b", wakeOn: "all" }, db);
+  archiveRoom("build", true, db);
+  expect(listRooms("a", db)).toEqual([]);
+
+  const posted = postMessage({ room: "build", handle: "a", body: "back to it" }, db)!;
+  expect(posted.recipients).toEqual(["b"]);
+  expect(roomArchivedAt("build", db)).toBeNull();
+  expect(listRooms("a", db).map(r => r.room)).toEqual(["build"]);
+  expect(listRooms("b", db).map(r => [r.room, r.unread])).toEqual([["build", 1]]);
+});
+
+test("archive refuses a room that does not exist, reopen clears the stamp, and both are idempotent", () => {
+  const db = freshDb();
+  expect(() => archiveRoom("nope", true, db)).toThrow(/no such room/);
+  expect(roomArchivedAt("nope", db)).toBeUndefined();
+  joinRoom({ room: "build", handle: "a" }, db);
+  const first = archiveRoom("build", true, db).archivedAt;
+  expect(archiveRoom("build", true, db).archivedAt).toBe(first);
+  expect(archiveRoom("build", false, db)).toEqual({ room: "build", archivedAt: null });
+  expect(archiveRoom("build", false, db)).toEqual({ room: "build", archivedAt: null });
+  expect(listRooms("a", db).map(r => r.room)).toEqual(["build"]);
+});
+
+test("room-less markRead skips an archived room, naming it still clears the cursor", () => {
+  const db = freshDb();
+  joinRoom({ room: "build", handle: "a" }, db);
+  joinRoom({ room: "build", handle: "b" }, db);
+  joinRoom({ room: "other", handle: "a" }, db);
+  joinRoom({ room: "other", handle: "b" }, db);
+  postMessage({ room: "build", handle: "a", body: "skip me" }, db);
+  postMessage({ room: "other", handle: "a", body: "clear me" }, db);
+  archiveRoom("build", true, db);
+  archiveRoom("other", true, db);
+
+  markRead("b", undefined, db);
+  expect(readUnread({ handle: "b", room: "build", limit: 20 }, db)).toHaveLength(1);
+
+  markRead("b", "other", db);
+  expect(readUnread({ handle: "b", room: "other", limit: 20 }, db)).toHaveLength(0);
+});
+
+test("join by name does not revive an archived room", () => {
+  const db = freshDb();
+  joinRoom({ room: "build", handle: "a" }, db);
+  archiveRoom("build", true, db);
+  joinRoom({ room: "build", handle: "c" }, db);
+  expect(roomArchivedAt("build", db)).not.toBeNull();
+  expect(listRooms("c", db)).toEqual([]);
+});