@jeffober/thatch 0.1.44 → 0.1.45

package/src/index.ts

@@ -70,9 +70,7 @@ const WRAPUP_COMMANDS: Record<string, { token: string; kind: "compact" | "exit"
  * the caller supplies the list (see startupSessionId for where it comes
  * from). The framework passes no session id to plugins and resuming a
  * session fires no events, so the command line is the only signal that a
- * fresh harness is the new home of a continued session. `-c/--continue`
- * (continue last) resolves no id here - that session registers on its
- * first idle like any other.
+ * fresh harness is the new home of a continued session.
  */
 export function startupSessionIdFromArgv(argv: string[]): string | null {
   for (let i = 0; i < argv.length; i++) {
@@ -83,6 +81,39 @@ export function startupSessionIdFromArgv(argv: string[]): string | null {
   return null;
 }
 
+/**
+ * Whether the harness was started with `-c`/`--continue` (continue the most
+ * recent session). Pure. Yargs-style boolean flags only: `--continue=false`
+ * reads as the negation, everything else as a plain switch. The session id
+ * itself is not on the command line - the harness resolves "most recent
+ * top-level session" at startup, which the plugin replicates via the SDK
+ * (continuesLastSessionId).
+ */
+export function continuesLastSessionFromArgv(argv: string[]): boolean {
+  for (const arg of argv) {
+    if (arg === "-c" || arg === "--continue") return true;
+    if (arg.startsWith("--continue=")) return arg.slice("--continue=".length) !== "false";
+  }
+  return false;
+}
+
+/**
+ * Picks the session `opencode -c` continues: the most recently updated
+ * top-level session. Pure; the caller supplies the session list from
+ * client.session.list() (directory-scoped, like the plugin's own client).
+ * The server's list order is not trusted - the TUI re-sorts by
+ * time.updated before picking, and so does this.
+ */
+export function continuesLastSessionId(
+  sessions: { id: string; parentID?: string; time?: { updated?: number } }[],
+): string | null {
+  return (
+    [...sessions]
+      .sort((a, b) => (b.time?.updated ?? 0) - (a.time?.updated ?? 0))
+      .find((s) => !s.parentID)?.id ?? null
+  );
+}
+
 // The plugin does not run in the process's main thread: opencode's TUI
 // spawns a worker thread (cli/tui/worker.js) to host the server, and worker
 // threads get their own argv (just the worker script) with none of the CLI
@@ -254,16 +285,29 @@ export const server: Plugin = async ({ client, worktree }) => {
   });
   watchers.start();
 
+  // The session this harness was launched to resume, resolved at startup:
+  // `-s <id>` names it on the command line, `-c` means "most recent in this
+  // directory" and resolves through the SDK. Either way the poller hosts it
+  // from the first beat, so the heartbeat and delivery are live before the
+  // user's first prompt.
+  let resumedSession: string | null = null;
+
+  // Chat names assigned by the startup resume paths (-s and -c) wait here
+  // until the session's first message or idle event, which toast them. At
+  // plugin-init time the TUI is not yet connected, so an immediate toast
+  // would be dropped silently.
+  const chatStartupNames = new Map<string, string>();
+
   const chatPoller = new ChatPoller({
     store: db,
     hostedSessions: () => {
       // Hosting = the sessions this harness serves: those seen as events
-      // here (used in this TUI) plus the `-s` startup session. Sub-agent
+      // here (used in this TUI) plus the resumed startup session. Sub-agent
       // children are excluded even if someone registered one - a
       // registered child would be heartbeat-ed fresh-forever and burn
       // nudge budget on undeliverable wake prompts.
       const hosted = [...sessionStatus.keys()];
-      if (startupSession) hosted.push(startupSession);
+      if (resumedSession) hosted.push(resumedSession);
       return hosted.filter((id) => !childToParent.has(id));
     },
     deliver: async (sessionID, senders, count) => {
@@ -293,42 +337,68 @@ export const server: Plugin = async ({ client, worktree }) => {
 
   // Startup registration: `opencode -s <id>` continues a session whose
   // directory row may predate this process (its harness died, or the
-  // machine restarted). The framework passes no session id to plugins and
+  // machine restarted); `opencode -c` continues the most recent session in
+  // this directory. The framework passes no session id to plugins and
   // resuming fires no events, so the command line is the source (see
   // startupSessionId). Registering here RECLAIMS the row - the name is
   // owned by the session id and never changes - and refreshes its
-  // heartbeat synchronously: local SQLite, it cannot fail on a server that
-  // is still starting. The async tail (title fetch, asleep-mail delivery)
-  // is best-effort - the poller retries whatever it misses, and the first
+  // heartbeat: synchronously for -s (local SQLite, it cannot fail on a
+  // server that is still starting); for -c after an SDK list call resolves
+  // the target. The async tail (title fetch, asleep-mail delivery) is
+  // best-effort - the poller retries whatever it misses, and the first
   // idle converges the topic.
+  const reclaimTail = (sessionID: string) => {
+    void (async () => {
+      try {
+        const { data } = await client.session.get({ path: { id: sessionID } });
+        const title = data?.title ?? "";
+        const topic = title && !isDefaultSessionTitle(title) ? title : null;
+        if (topic) db.refreshChatTopic(sessionID, topic);
+      } catch {
+        // Server may still be starting; the topic converges on the
+        // session's first idle either way.
+      }
+      try {
+        // Asleep-mail: deliver what queued while this session was away,
+        // through the normal path (gate, nudge, toast, stamps).
+        await chatPoller.deliverPending();
+      } catch {
+        // The poller cycle retries delivery; nothing to do here.
+      }
+    })();
+  };
   const osArgs = osProcessArgs();
   const startupSession = startupSessionId(osArgs);
+  const continueLast = !startupSession && (continuesLastSessionFromArgv(process.argv) || continuesLastSessionFromArgv(osArgs));
   const autoRegisterOn = chatAutoRegister(loadConfig(dbPath).config);
   const tombstoned = startupSession ? db.hasChatLeaveTombstone(startupSession) : false;
-  debug("chat:startup", `init: argv=${JSON.stringify(process.argv.slice(0, 8))} osArgs=${JSON.stringify(osArgs.slice(0, 8))} parsed=${startupSession} chatOn=${chatOn} autoRegister=${autoRegisterOn} tombstone=${startupSession ? tombstoned : "n/a"}`);
+  debug("chat:startup", `init: argv=${JSON.stringify(process.argv.slice(0, 8))} osArgs=${JSON.stringify(osArgs.slice(0, 8))} parsed=${startupSession} continue=${continueLast} chatOn=${chatOn} autoRegister=${autoRegisterOn} tombstone=${startupSession ? tombstoned : "n/a"}`);
   if (chatOn && autoRegisterOn && startupSession && !tombstoned) {
+    resumedSession = startupSession;
     const res = db.registerChatSession(startupSession, repo, null, "opencode", null, detectWorktreeKind(worktree));
     debug("chat:startup", `registration for ${startupSession}: ok=${res.ok} name=${res.ok ? res.name : res.error}`);
     if (res.ok) {
-      void (async () => {
-        try {
-          const { data } = await client.session.get({ path: { id: startupSession } });
-          const title = data?.title ?? "";
-          const topic = title && !isDefaultSessionTitle(title) ? title : null;
-          if (topic) db.refreshChatTopic(startupSession, topic);
-        } catch {
-          // Server may still be starting; the topic converges on the
-          // session's first idle either way.
-        }
-        try {
-          // Asleep-mail: deliver what queued while this session was away,
-          // through the normal path (gate, nudge, toast, stamps).
-          await chatPoller.deliverPending();
-        } catch {
-          // The poller cycle retries delivery; nothing to do here.
-        }
-      })();
+      chatStartupNames.set(startupSession, res.name);
+      reclaimTail(startupSession);
     }
+  } else if (chatOn && autoRegisterOn && continueLast) {
+    void (async () => {
+      try {
+        const { data } = await client.session.list();
+        const target = continuesLastSessionId(data ?? []);
+        debug("chat:startup", `-c resolved: ${target ?? "none"}`);
+        if (!target || db.hasChatLeaveTombstone(target)) return;
+        resumedSession = target;
+        const res = db.registerChatSession(target, repo, null, "opencode", null, detectWorktreeKind(worktree));
+        debug("chat:startup", `registration for ${target}: ok=${res.ok} name=${res.ok ? res.name : res.error}`);
+        if (res.ok) {
+          chatStartupNames.set(target, res.name);
+          reclaimTail(target);
+        }
+      } catch (err) {
+        console.error(`[thatch] chat -c startup registration failed: ${err}`);
+      }
+    })();
   }
 
   // Sessions currently being compacted. chat.message nudges are skipped while
@@ -692,6 +762,42 @@ export const server: Plugin = async ({ client, worktree }) => {
       // nothing (and fire spurious toasts when thresholds cross). Skip
       // them entirely.
       if (isChatEchoParts(output.parts)) return;
+
+      // Prompt-path registration: a brand-new session joins the chat
+      // directory the moment its first real user message arrives - before
+      // the model runs - so it is addressable within that first turn (the
+      // first-idle path alone leaves a turn-long dark window). Local
+      // SQLite, so it runs inline; on an already-registered session this
+      // is a free mid-turn heartbeat touch. Sub-agent children are excluded
+      // (they register only by mistake, and their deletion tombstones the
+      // row), as are sessions that left via chat_unregister. The idle path
+      // below stays as the backstop and converges the topic.
+      if (
+        chatOn &&
+        chatAutoRegister(loadConfig(dbPath).config) &&
+        input.sessionID &&
+        !childToParent.has(input.sessionID) &&
+        !db.hasChatLeaveTombstone(input.sessionID)
+      ) {
+        try {
+          const res = db.registerChatSession(input.sessionID, repo, null, "opencode", null, detectWorktreeKind(worktree));
+          // First registration - or a startup resume reclaiming its name,
+          // announced here because the TUI was not connected at init - is
+          // the one moment the user should notice: a quiet toast, not a
+          // conversation message.
+          if (res.ok && (res.created || chatStartupNames.has(input.sessionID))) {
+            chatStartupNames.delete(input.sessionID);
+            try {
+              await client.tui.showToast({ body: { message: res.created ? `registered in chat as ${res.name}` : `rejoined chat as ${res.name}`, variant: "info", duration: 4000 } });
+            } catch {
+              // Headless or disconnected TUI - registration stands.
+            }
+          }
+        } catch (err) {
+          console.error(`[thatch] chat prompt-register failed for ${input.sessionID}: ${err}`);
+        }
+      }
+
       if (compacting.has(input.sessionID)) {
         // The session is marked as compacting. If this message is the
         // compaction summary generation itself (has a compaction-type part),
@@ -1085,11 +1191,14 @@ export const server: Plugin = async ({ client, worktree }) => {
               // registration is once-per-session, so later idles must
               // refresh it explicitly.
               if (res.ok && topic) db.refreshChatTopic(sessionID, topic);
-              if (res.ok && res.created) {
-                // First registration is the one moment the user should
-                // notice: a quiet toast, not a conversation message.
+              // First registration - or a startup resume reclaiming its
+              // name, announced here because the TUI was not connected at
+              // init - is the one moment the user should notice: a quiet
+              // toast, not a conversation message.
+              if (res.ok && (res.created || chatStartupNames.has(sessionID))) {
+                chatStartupNames.delete(sessionID);
                 try {
-                  await client.tui.showToast({ body: { message: `registered in chat as ${res.name}`, variant: "info", duration: 4000 } });
+                  await client.tui.showToast({ body: { message: res.created ? `registered in chat as ${res.name}` : `rejoined chat as ${res.name}`, variant: "info", duration: 4000 } });
                 } catch {
                   // Headless or disconnected TUI - registration stands.
                 }

package/src/mcp.ts

@@ -6,6 +6,8 @@ import { BgeEmbeddingModel } from "./embeddings";
 import { detectRepo } from "./git";
 import { checkSetup, setupClaudeCode, setupCursor } from "./setup";
 import { TOOL_DEFS, type CoreContext, type ToolDef } from "./tool-defs";
+import { actionDefs, type ActionDef } from "./commands";
+import { mcpToolName } from "./prompts";
 import { SidebandServer, sidebandSocketPath } from "./sideband";
 import { peekQueue, consumeQueue, resetMissedCount } from "./extract-queue";
 import { buildExtractionPayload } from "./extraction";
@@ -44,11 +46,13 @@ const SERVER_NAME = "thatch";
 const SERVER_VERSION = pkg.version;
 
 /**
- * MCP capabilities declared in the initialize response. Thatch is a tools-only
- * server - no resources, prompts, or subscriptions.
+ * MCP capabilities declared in the initialize response. Tools plus the
+ * prompts that Cursor surfaces as slash commands; no resources or
+ * subscriptions.
  */
 const CAPABILITIES = {
   tools: { listChanged: false },
+  prompts: { listChanged: false },
 };
 
 // ---------------------------------------------------------------------------
@@ -77,6 +81,25 @@ export function compileTools(): Map<string, CompiledTool> {
   return map;
 }
 
+// ---------------------------------------------------------------------------
+// Prompt index - the on-demand actions Cursor surfaces as slash commands
+// ---------------------------------------------------------------------------
+
+/**
+ * The prompts the MCP server exposes: the shared actions minus the
+ * opencode-only ones. Prompts render the same instruction bodies as the
+ * command files (src/commands.ts) without the $ARGUMENTS section - the
+ * optional focus argument stands in for it.
+ */
+export function compilePrompts(): Map<string, ActionDef> {
+  const map = new Map<string, ActionDef>();
+  for (const def of actionDefs(mcpToolName)) {
+    if (def.opencodeOnly) continue;
+    map.set(def.name, def);
+  }
+  return map;
+}
+
 // ---------------------------------------------------------------------------
 // MCP server
 // ---------------------------------------------------------------------------
@@ -152,6 +175,7 @@ export async function runMcpServer(): Promise<void> {
     },
   };
   const tools = compileTools();
+  const prompts = compilePrompts();
 
   // Check whether `thatch setup` was run for the current host. If not, or if
   // markers are broken, surface a warning on the first tools/call response so
@@ -248,7 +272,7 @@ export async function runMcpServer(): Promise<void> {
 
       // Notifications (no id) are fire-and-forget - no response expected.
       const isNotification = req.id === null || req.id === undefined;
-      const res = await dispatch(req, tools, ctx);
+      const res = await dispatch(req, tools, prompts, ctx);
       if (res === null || isNotification) continue;
 
       // Surface the setup warning on the first tools/call response so the
@@ -290,6 +314,7 @@ export async function runMcpServer(): Promise<void> {
 async function dispatch(
   req: JsonRpcRequest,
   tools: Map<string, CompiledTool>,
+  prompts: Map<string, ActionDef>,
   ctx: CoreContext,
 ): Promise<JsonRpcResponse | null> {
   const { id, method } = req;
@@ -355,6 +380,40 @@ async function dispatch(
         }
       }
 
+      case "prompts/list":
+        return ok(id, {
+          prompts: [...prompts.values()].map((p) => ({
+            name: p.name,
+            description: p.description,
+            arguments: [
+              {
+                name: "focus",
+                description: "Optional scope for the action, e.g. which store to work on",
+                required: false,
+              },
+            ],
+          })),
+        });
+
+      case "prompts/get": {
+        const prompt = prompts.get(req.params?.name);
+        if (!prompt) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: METHOD_NOT_FOUND, message: `Unknown prompt: ${req.params?.name}` },
+          };
+        }
+        const focus = req.params?.arguments?.focus;
+        const text = focus
+          ? `${prompt.body}\n\nFocus: ${focus}`
+          : prompt.body;
+        return ok(id, {
+          description: prompt.description,
+          messages: [{ role: "user", content: { type: "text", text } }],
+        });
+      }
+
       case "ping":
         return ok(id, {});
 

package/src/prompts.ts

@@ -620,6 +620,59 @@ export function versionWarningNudge(message: string): string {
   return `[thatch] ${message} This is a system nudge, not user input. After informing the user, continue with their request.`;
 }
 
+// ---------------------------------------------------------------------------
+// Prompt cores - behavior instruction bodies shared by nudges and /thatch
+// command files (src/commands.ts). A core is the host-agnostic instruction
+// body for one behavior. The nudge envelope adds escalation tiers and the
+// stop-and-wait ending; the command envelope adds frontmatter and the
+// user-message section. The stop-and-wait ending is nudge-only: a /thatch
+// command IS user input, so it must not inherit it.
+//
+// Cores take a ToolNamer because tool spellings differ per host
+// (thatch_find_duplicates on opencode, mcp__thatch__find_duplicates on MCP
+// hosts); the renderer for each host passes its own namer.
+// ---------------------------------------------------------------------------
+
+/** Maps a bare tool name to the host's spelling. */
+export type ToolNamer = (name: string) => string;
+
+export const opencodeToolName: ToolNamer = (name) => `thatch_${name}`;
+export const mcpToolName: ToolNamer = (name) => `mcp__thatch__${name}`;
+
+/**
+ * The extraction instruction body. sessionIdArg is either ` with session_id
+ * "X"` (the nudge path: the sub-agent's session differs from the parent's)
+ * or an omit note (the invoking session's ID is the default).
+ */
+export function extractionCore(fetchTool: string, drainTool: string, sessionIdArg: string): string {
+  return `Call ${fetchTool}${sessionIdArg} to retrieve the queued tool interactions, then run the thatch-fact-extractor skill to extract durable facts. Call ${drainTool}${sessionIdArg} when finished, even if nothing was worth saving.`;
+}
+
+/**
+ * The memory consolidation (defrag) instruction body. Shared by the
+ * /thatch/defrag command file and the MCP prompt of the same name.
+ */
+export function defragCore(tool: ToolNamer): string {
+  return `Run ${tool("find_duplicates")} to surface duplicate-candidate memory pairs and clusters. For each pair or cluster, read every memory with ${tool("memory_show")}, classify the relationship, and consolidate per the thatch-dedup-classifier skill: merge duplicates (${tool("memory_remember")} with overwrite: true, then ${tool("memory_forget")} the rest), update supplements, keep contradictions, and call ${tool("dedup_mark_checked")} on every pair you are not deleting so it stops being re-reported. Call ${tool("find_duplicates")} again at the end to verify the store is clean, and summarize what you merged, kept, and deleted.`;
+}
+
+/**
+ * The memory hygiene instruction body. Shared by the /thatch/hygiene command
+ * file and the MCP prompt of the same name. Drives the thatch CLI (not
+ * memory tools), so it needs no tool namer.
+ */
+export function hygieneCore(): string {
+  return `Run the shell command "thatch hygiene" to print the hygiene report for the current repo store. It lists duplicate-candidate pairs pending review, memories gone stale, and memories scoped to deleted branches. For each finding, act: consolidate duplicates with the thatch-dedup-classifier workflow, correct or overwrite stale memories that are simply out of date, and consolidate branch-scoped memories into one archived record when their branch is gone. Ask the user before forgetting anything that may still matter. Re-run "thatch hygiene" at the end to confirm the store is healthy, and summarize what you changed.`;
+}
+
+/**
+ * The session reflection instruction body. Shared by the /thatch/reflect
+ * command file and the MCP prompt of the same name.
+ */
+export function reflectCore(tool: ToolNamer): string {
+  return `Run the thatch-session-reflection skill to persist what this session learned: follow the skill's instructions and record each distinct learning with ${tool("memory_remember")}. When the skill's checklist is worked through, report a one-line summary of what you saved.`;
+}
+
 /**
  * Extraction nudge with escalation. Both the opencode plugin (src/index.ts)
  * and the Claude Code/Cursor CLI (bin/thatch flush-tools) call this with
@@ -682,7 +735,8 @@ function buildExtractionNudge(
   sessionID: string,
 ): string {
   const acknowledge = `After dispatching, call ${drainTool} to acknowledge.`;
-  const subAgentPrompt = `Call ${fetchTool} with session_id "${sessionID}" to retrieve the queued tool interactions, then run the thatch-fact-extractor skill to extract durable facts. Call ${drainTool} with session_id "${sessionID}" when finished, even if nothing was worth saving.`;
+  const sessionIdArg = ` with session_id "${sessionID}"`;
+  const subAgentPrompt = extractionCore(fetchTool, drainTool, sessionIdArg);
 
   if (missedCount >= 3) {
     return `[thatch] YOU ARE IGNORING EXTRACTION INSTRUCTIONS. ` +

package/src/setup.ts

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { join } from "node:path";
 import { claudeInstructions, cursorInstructions } from "./prompts";
 import { installSkills, type InstallReport } from "./skills";
+import { installClaudeCommands } from "./commands";
 
 // ---------------------------------------------------------------------------
 // Path resolution
@@ -320,6 +321,8 @@ export interface SetupResult {
   settings: string;
   /** Skill install report for the directory this run wrote to. */
   skills: InstallReport;
+  /** Command files (the /thatch/* actions) written by this run, if any. */
+  commands: string[];
   /** Thatch skills in the opposite scope's dir, if any; never written by this run. */
   otherScopeSkills: OtherScopeSkills | null;
   global: boolean;
@@ -360,6 +363,11 @@ export function setupClaudeCode(
   writeHooks(paths.settingsPath, thatchBin);
   const skills = installSkills(paths.skillsDir);
 
+  // Command files (the /thatch/* actions Claude Code reads as slash
+  // commands) live beside skills under the .claude dir, same scope rules.
+  const claudeDir = global ? claudeConfigDir(home) : join(projectDir, ".claude");
+  const commands = installClaudeCommands(claudeDir);
+
   // The scope this run did NOT write to. Local runs leave user-scope copies
   // behind (pre-existing global installs); global runs leave project-local
   // copies in the repo. Either way the user should hear about them.
@@ -372,6 +380,7 @@ export function setupClaudeCode(
     claudeMd: paths.claudeMdPath,
     settings: paths.settingsPath,
     skills,
+    commands,
     otherScopeSkills: otherScopeInfo(otherDir),
     global,
     mcpAddCommand: global

package/src/tool-defs.ts

@@ -20,7 +20,7 @@ import { sendNotification, defaultSpawner, type NotifyChannel, type Spawner } fr
 import { predictionVerb, chatInboxFrame } from "./prompts";
 import { resolveOpencodeDbPath, SessionDB, partToTimelineEntry, partToFullJson, messageToFullJson } from "./session-db";
 import { PR_EVENT_TYPES, BRANCH_EVENT_TYPES, commandTargetLabel, type WatcherRegistry, type PrWatcherEventType, type BranchWatcherEventType } from "./watchers";
-import { CHAT_STALE_MS, chatLiveness, humanAge, renderChatParticipant, splitChatRoster, type ChatHostKind } from "./chat";
+import { CHAT_STALE_MS, chatLiveness, humanAge, renderChatParticipant, sortChatRoster, splitChatRoster, type ChatHostKind } from "./chat";
 import { detectWorktreeKind } from "./git";
 
 // Near-duplicate thresholds for matcher/prediction/behavior dedup at
@@ -452,18 +452,29 @@ const getExtractionPayloadDef: ToolDef = {
     "Retrieve the queued tool interactions for extraction. Call this with " +
     "the session_id from the extraction nudge to get the JSON payload " +
     "(interactions, projectStore, globalStore). Then run the " +
-    "thatch-fact-extractor skill on the returned payload.",
+    "thatch-fact-extractor skill on the returned payload. Omit session_id " +
+    "when acting on the session you are running in.",
   args: {
-    session_id: z.string().describe(
-      "The session ID from the extraction nudge. This is the parent session " +
-      "whose tool interactions are queued for extraction.",
+    session_id: z.string().optional().describe(
+      "The session whose tool interactions are queued for extraction. " +
+      "Omit when acting on the session you are running in - the invoking " +
+      "session's ID is used. Pass the parent session's ID when running " +
+      "inside a sub-agent dispatched to process another session's queue.",
     ),
   },
-  async execute(args, ctx) {
+  async execute(args, ctx, host) {
     if (!ctx.extractionPayloadProvider) {
       return "Extraction payload retrieval is not available in this host.";
     }
-    const payload = ctx.extractionPayloadProvider(args.session_id as string);
+    // The zod shape is shared across hosts, so optionality cannot be
+    // per-host at the schema level: MCP hosts have no session context to
+    // fall back on, so an omitted session_id only resolves on the
+    // opencode path, where the wrapper supplies the invoking session.
+    const sessionID = (args.session_id as string | undefined) ?? host?.sessionID;
+    if (!sessionID) {
+      return 'session_id is required on this host (it has no session context). Pass the parent session\'s session_id from the extraction nudge.';
+    }
+    const payload = ctx.extractionPayloadProvider(sessionID);
     if (!payload) {
       return "No queued tool interactions found for this session.";
     }
@@ -1722,7 +1733,7 @@ const chatListDef: ToolDef = {
       return "No sessions registered. Sessions join the directory automatically on their first idle (opencode), or via chat_register - you would be the first.";
     }
     const unread = ctx.db.unreadChatCount(identity.sessionID);
-    const { active, stale } = splitChatRoster(sessions);
+    const { active, stale } = splitChatRoster(sortChatRoster(sessions));
     const line = (s: (typeof sessions)[number]) => {
       const self = s.session_id === identity.sessionID;
       const liveness = chatLiveness(s);