@ccmsg/cli 0.2.13 → 0.3.1

package/src/sessions/registry.ts

@@ -19,16 +19,32 @@ import {
 } from "@ccmsg/protocol";
 import { type HandlerInput, OpError, type Requester } from "../dispatch/index.ts";
 import { within } from "../files/index.ts";
+import { HARNESS, type Harness } from "../harness/index.ts";
 import type { TranscriptFacts } from "../transcript/index.ts";
 import type { TopicValue, UpstreamResource } from "../topics/index.ts";
 import { classify, type SessionInputs } from "./classify.ts";
-import { HarnessSessions, isWaiting } from "./harness.ts";
+import { isWaiting, type OwnSessions, ownSessions } from "./harness.ts";
 import { LastLiveStore, type StoredEntry } from "./last-live.ts";
 import { stoppedOn } from "./status.ts";
 import { TerminalCache, type TerminalReader } from "./terminals.ts";
 
+/** What the harness says at one instant: the rows it reports, and which
+ * sessions it says are there (§3.8).
+ *
+ * Two readings of one moment, passed together so a caller answering several
+ * questions about that moment reads once. They are the same set for a harness
+ * that reports a row per session and differ for one that reports none, which
+ * is why the classification reads `present` and never the rows' keys. */
+interface Own {
+  readonly rows: ReadonlyMap<Sid, AgentInfo>;
+  readonly present: ReadonlySet<Sid>;
+}
+
 /** What the sessions domain needs from the instance around it. */
 export interface SessionsDeps {
+  /** Which harness this config home runs (§3.8). It decides what says a
+   * session is there and, through that, what `agents` can report. */
+  readonly harness: Harness;
   readonly self: InstanceId;
   /** Where this instance says it is reached, which `hello` states beside the
    * id: the caller got here by some URL of its own — a proxy's, an alias — and
@@ -82,6 +98,12 @@ export interface SessionsDeps {
    * domain cannot judge: a peer's, whose claim is settled by an exchange of its
    * own rather than by anything a session says (§7.2). */
   readonly mesh?: MeshSource;
+  /** Where a person opens the terminal a session runs in, which `hello` states
+   * as `terminal_gateway`. The same value that gates the `terminal` capability
+   * (`sessionCapabilities`), so a client told the capability is on is told
+   * where to reach it in the same greeting. Absent on an instance with no
+   * gateway configured. */
+  readonly terminalGateway?: string;
 }
 
 /** What `hello` needs of the mesh: verify the greeting of a peer, and say which
@@ -155,7 +177,7 @@ interface Connected {
  * built, and never stored (M4). */
 export class Sessions implements UpstreamResource {
   readonly #connected = new Map<Sid, Connected>();
-  readonly #harness: HarnessSessions;
+  readonly #harness: OwnSessions;
   readonly #terminals: TerminalCache | undefined;
   readonly #lastLive: LastLiveStore;
   /** Sessions seen live since the last recompute, kept so the moment one stops
@@ -191,8 +213,9 @@ export class Sessions implements UpstreamResource {
   readonly #stopping = new Map<Sid, Timestamp>();
 
   constructor(private readonly deps: SessionsDeps) {
-    this.#harness = new HarnessSessions(
-      join(deps.configHome, "sessions"),
+    this.#harness = ownSessions(
+      deps.harness,
+      deps.configHome,
       deps.self,
       () => this.changed(),
       deps.pollMs,
@@ -203,7 +226,7 @@ export class Sessions implements UpstreamResource {
       deps.terminals === undefined
         ? undefined
         : new TerminalCache(deps.terminals, () => this.changed());
-    this.#live = this.#liveNow(Date.now(), this.#rows());
+    this.#live = this.#liveNow(Date.now(), this.#own());
   }
 
   /** `hello`, which is where a session becomes something this instance can
@@ -274,6 +297,9 @@ export class Sessions implements UpstreamResource {
       capabilities: [...this.deps.capabilities],
       version: this.deps.version,
       started_at: this.deps.startedAt,
+      ...(this.deps.terminalGateway === undefined
+        ? {}
+        : { terminal_gateway: this.deps.terminalGateway }),
       ...(expiresAt === undefined ? {} : { auth_expires_at: expiresAt }),
     };
   }
@@ -283,18 +309,18 @@ export class Sessions implements UpstreamResource {
   classify(
     sid: Sid,
     now: Timestamp = Date.now(),
-    rows: ReadonlyMap<Sid, AgentInfo> = this.#rows(),
+    own: Own = this.#own(),
   ): SessionState | undefined {
-    return classify(this.inputs(sid, rows), now);
+    return classify(this.inputs(sid, own), now);
   }
 
   /** The harness's sessions as they are at this instant. One read serves one
    * question, and a caller answering several about the same instant passes the
    * result on rather than reading again. */
-  #rows(): ReadonlyMap<Sid, AgentInfo> {
-    const rows = this.#harness.scan();
+  #own(): Own {
+    const rows = this.#harness.rows();
     const terminals = this.#terminals;
-    if (terminals === undefined) return rows;
+    if (terminals === undefined) return { rows, present: this.#harness.present() };
     // What the scan found is what exists: a pid that has left it is one whose
     // terminal is no longer anybody's, and one that has arrived is read once.
     terminals.observe([...rows.values()].map((row) => row.pid));
@@ -314,7 +340,7 @@ export class Sessions implements UpstreamResource {
             },
       );
     }
-    return named;
+    return { rows: named, present: this.#harness.present() };
   }
 
   /** Everything the classification of one session reads, exposed so the rule
@@ -327,21 +353,22 @@ export class Sessions implements UpstreamResource {
    * "a session exists" mean "somebody is listening", which is how a live
    * session becomes `session_not_found` to a sender and how a session that is
    * still running is written into `last_live` as gone. */
-  inputs(sid: Sid, rows: ReadonlyMap<Sid, AgentInfo> = this.#rows()): SessionInputs {
-    const row = rows.get(sid);
+  inputs(sid: Sid, own: Own = this.#own()): SessionInputs {
+    const row = own.rows.get(sid);
+    const present = own.present.has(sid);
     const stored = this.#lastLive.get(sid);
     const facts = this.deps.transcript?.facts(sid);
-    const gatewayActiveAt = this.#gatewayActiveAt(sid, row !== undefined);
+    const gatewayActiveAt = this.#gatewayActiveAt(sid, present);
     return {
       connected: this.#connected.has(sid),
       ...(gatewayActiveAt === undefined ? {} : { gateway_active_at: gatewayActiveAt }),
       ...(facts === undefined || stoppedOn(facts) === undefined ? {} : { api_error_stopped: true }),
-      ...(row === undefined
+      ...(!present
         ? {}
         : {
             harness: {
-              waiting: isWaiting(row),
-              ...(row.terminal_id === undefined ? {} : { terminal_id: row.terminal_id }),
+              waiting: row !== undefined && isWaiting(row),
+              ...(row?.terminal_id === undefined ? {} : { terminal_id: row.terminal_id }),
             },
           }),
       ...(stored === undefined ? {} : { last_live: { stopped_at: stored.stopped_at } }),
@@ -379,7 +406,7 @@ export class Sessions implements UpstreamResource {
    * so a session that named neither is one no path is admitted for. */
   where(sid: Sid): { root?: string; cwd?: string } {
     const meta = this.#connected.get(sid)?.meta;
-    const cwd = meta?.cwd ?? this.#rows().get(sid)?.cwd;
+    const cwd = meta?.cwd ?? this.#own().rows.get(sid)?.cwd;
     // The container when the session named one, the working directory
     // otherwise — the same order `repo_root` is meant in (§4.2).
     const root = meta?.repo_root ?? cwd;
@@ -394,7 +421,7 @@ export class Sessions implements UpstreamResource {
    * through this: the watch runs only while somebody is subscribed (§6.3), and
    * a pid from a poll that has not run is a number belonging to nobody. */
   rowsNow(): ReadonlyMap<Sid, AgentInfo> {
-    return this.#rows();
+    return this.#own().rows;
   }
 
   /** Drop one entry from `last_live`, which is what
@@ -445,8 +472,8 @@ export class Sessions implements UpstreamResource {
   }
 
   snapshot(topic: string): readonly TopicValue[] {
-    const rows = this.#rows();
-    const data = topic === "agents" ? this.agents(rows) : this.peers(Date.now(), rows);
+    const own = this.#own();
+    const data = topic === "agents" ? this.agents(own) : this.peers(Date.now(), own);
     return [{ instance: this.deps.self, data }];
   }
 
@@ -473,14 +500,14 @@ export class Sessions implements UpstreamResource {
    * from stating that nothing is reachable. */
   peers(
     now: Timestamp = Date.now(),
-    rows: ReadonlyMap<Sid, AgentInfo> = this.#rows(),
+    own: Own = this.#own(),
   ): { peers: PeerInfo[]; last_live: LastLiveSession[]; instances?: InstanceInfo[] } {
     const instances = this.deps.mesh?.instances();
     return {
-      peers: [...this.#connected.values()].map((session) => this.#peer(session, now, rows)),
+      peers: [...this.#connected.values()].map((session) => this.#peer(session, now, own)),
       last_live: this.#lastLive.entries(now).map((entry) => ({
         ...entry,
-        state: this.classify(entry.sid, now, rows) ?? "disappeared",
+        state: this.classify(entry.sid, now, own) ?? "disappeared",
         pinned: this.#pinned(entry.sid),
       })),
       ...(instances === undefined ? {} : { instances }),
@@ -493,8 +520,8 @@ export class Sessions implements UpstreamResource {
    * make every confirmation poll a value the list did not have before, so the
    * one suppression every topic shares (M5) would let a five-second heartbeat
    * through for a directory that had not changed. */
-  agents(rows: ReadonlyMap<Sid, AgentInfo> = this.#rows()): { agents: AgentInfo[] } {
-    return { agents: [...rows.values()] };
+  agents(own: Own = this.#own()): { agents: AgentInfo[] } {
+    return { agents: [...own.rows.values()] };
   }
 
   /** Bind a session to this instance, and take what it says about itself. Its
@@ -515,7 +542,7 @@ export class Sessions implements UpstreamResource {
     const held = this.#connected.get(sid);
     const meta = {
       ...this.#stated.get(sid),
-      ...metaOf(args, this.deps.configHome, (refused) => {
+      ...metaOf(this.deps, args, (refused) => {
         this.deps.log?.("transcript_path not taken", { sid, path: args.transcript_path, refused });
       }),
     };
@@ -552,8 +579,8 @@ export class Sessions implements UpstreamResource {
    * mechanism and is written once for every topic (M5) — a payload equal to
    * the last one goes no further than that. */
   private changed(now: Timestamp = Date.now()): void {
-    const rows = this.#rows();
-    const live = this.#liveNow(now, rows);
+    const own = this.#own();
+    const live = this.#liveNow(now, own);
     for (const [sid, entry] of this.#live) {
       if (live.has(sid)) continue;
       // The declaration came first and the departure has now arrived, which is
@@ -571,23 +598,23 @@ export class Sessions implements UpstreamResource {
       this.#stated.delete(sid);
     }
     this.#live = live;
-    this.deps.publish("peers", this.peers(now, rows));
-    this.deps.publish("agents", this.agents(rows));
+    this.deps.publish("peers", this.peers(now, own));
+    this.deps.publish("agents", this.agents(own));
     this.deps.onChanged?.();
   }
 
   /** Every session live right now, in the form its `last_live` entry takes if
    * it stops being live. */
-  #liveNow(now: Timestamp, rows: ReadonlyMap<Sid, AgentInfo>): Map<Sid, StoredEntry> {
+  #liveNow(now: Timestamp, own: Own): Map<Sid, StoredEntry> {
     const live = new Map<Sid, StoredEntry>();
-    for (const sid of this.#connected.keys()) live.set(sid, this.#entry(sid, now, rows));
-    for (const sid of rows.keys()) live.set(sid, this.#entry(sid, now, rows));
+    for (const sid of this.#connected.keys()) live.set(sid, this.#entry(sid, now, own));
+    for (const sid of own.present) live.set(sid, this.#entry(sid, now, own));
     return live;
   }
 
-  #entry(sid: Sid, now: Timestamp, rows: ReadonlyMap<Sid, AgentInfo>): StoredEntry {
+  #entry(sid: Sid, now: Timestamp, own: Own): StoredEntry {
     const held = this.#connected.get(sid);
-    const row = rows.get(sid);
+    const row = own.rows.get(sid);
     // What answered last, not what the session named when it greeted: the
     // greeting is one instant and `/model` moves afterwards, so the fold is
     // asked first and the greeting only fills in for a transcript that has
@@ -602,7 +629,7 @@ export class Sessions implements UpstreamResource {
       // The harness knows a title for a session that stated none itself, so
       // it goes first and what the session named overrides it.
       ...(row?.name === undefined ? {} : { title: row.name }),
-      ...this.#where(sid, rows),
+      ...this.#where(sid, own),
       ...(model === undefined ? {} : { model }),
       ...(effort === undefined ? {} : { effort }),
       ...(held === undefined ? {} : { connected_at: held.connected_at }),
@@ -610,7 +637,7 @@ export class Sessions implements UpstreamResource {
     };
   }
 
-  #peer(session: Connected, now: Timestamp, rows: ReadonlyMap<Sid, AgentInfo>): PeerInfo {
+  #peer(session: Connected, now: Timestamp, own: Own): PeerInfo {
     // The two "last activity" values are different questions (§5.3): the one
     // above moves on every request the session makes, this one only when a
     // person speaks, and the fold is the only place that knows the second.
@@ -618,12 +645,12 @@ export class Sessions implements UpstreamResource {
     // What the gateway last saw run for this session: an attribute of the row
     // beside the classification, not folded into it (§5.1). Absent from an
     // instance with no gateway, where nothing observes inference at all.
-    const gatewayActiveAt = this.#gatewayActiveAt(session.sid, rows.has(session.sid));
+    const gatewayActiveAt = this.#gatewayActiveAt(session.sid, own.present.has(session.sid));
     return {
       sid: session.sid,
       instance: this.deps.self,
-      ...this.#where(session.sid, rows),
-      state: this.classify(session.sid, now, rows) ?? "live",
+      ...this.#where(session.sid, own),
+      state: this.classify(session.sid, now, own) ?? "live",
       pinned: this.#pinned(session.sid),
       connected_at: session.connected_at,
       last_activity_at: session.last_activity_at,
@@ -675,10 +702,10 @@ export class Sessions implements UpstreamResource {
    * until one does. */
   #where(
     sid: Sid,
-    rows: ReadonlyMap<Sid, AgentInfo>,
+    own: Own,
   ): Pick<PeerInfo, "repo" | "ws" | "cwd" | "transcript_path" | "repo_root" | "branch" | "title"> {
     const meta = this.#stated.get(sid) ?? {};
-    const cwd = meta.cwd ?? rows.get(sid)?.cwd ?? "";
+    const cwd = meta.cwd ?? own.rows.get(sid)?.cwd ?? "";
     return {
       repo: meta.repo ?? "",
       ws: meta.ws ?? "",
@@ -697,7 +724,7 @@ export class Sessions implements UpstreamResource {
  *
  * `transcript_path` is the exception, because it is the one field that is not
  * only displayed: it names a file this instance then reads and follows. What is
- * taken is a path under this config home's `projects/`, resolved, and nothing
+ * taken is a path under this config home's transcript tree, resolved, and nothing
  * else — a session naming a file elsewhere is a session that named nothing,
  * which is what a session that stayed silent already is (M6). It is not an
  * error: how a session describes itself is its own business, and the instance
@@ -705,8 +732,8 @@ export class Sessions implements UpstreamResource {
  * not taken is told to `refused`, which is the operator's answer to a field
  * that is simply absent from what `peers` says. */
 function metaOf(
+  deps: Pick<SessionsDeps, "configHome" | "harness">,
   args: HelloArgs,
-  configHome: string,
   refused: (reason: string) => void,
 ): SessionMeta {
   const meta: Record<string, string> = {};
@@ -714,7 +741,7 @@ function metaOf(
     const value = args[field];
     if (value === undefined) continue;
     if (field === "transcript_path") {
-      const taken = ownTranscript(value, configHome);
+      const taken = ownTranscript(value, deps);
       if (typeof taken === "string") meta[field] = taken;
       else refused(taken.refused);
       continue;
@@ -727,7 +754,7 @@ function metaOf(
 /** A transcript path this instance will read, or nothing.
 
  * The test is where the file would be, not whether it is there. M6 is a
- * boundary on what this instance reads, and a path inside `projects/` stays
+ * boundary on what this instance reads, and a path inside the tree stays
  * inside it whether or not anything has been written there yet — a session
  * greeting at its very start names a transcript the harness has created
  * neither the file nor the directory for, and refusing it would mean the one
@@ -741,23 +768,27 @@ function metaOf(
  * along it that leads out of the tree lands outside and is refused. What is
  * already there must be a file: a directory by that name is not a transcript.
  *
- * `projects/` itself is settled the same way, so a config home whose first
+ * The tree itself is settled the same way, so a config home whose first
  * session has yet to write anything is a boundary all the same: the directory
  * that is there is followed, the part that is not is taken as spelled, and the
  * comparison is between two paths resolved by one rule. The config home is not
  * treated that way — an instance answers for a home it is running out of, and
  * one that is not there names no tree to be inside of. */
-function ownTranscript(named: string, configHome: string): string | Refused {
+function ownTranscript(
+  named: string,
+  deps: Pick<SessionsDeps, "configHome" | "harness">,
+): string | Refused {
   if (!isAbsolute(named)) return { refused: "not an absolute path" };
-  let projects: string | undefined;
+  let tree: string | undefined;
   try {
-    projects = resolveAsFarAsItGoes(join(realpathSync(configHome), "projects"));
+    const home = realpathSync(deps.configHome);
+    tree = resolveAsFarAsItGoes(join(home, HARNESS[deps.harness].transcripts));
   } catch {
     return { refused: "the config home is not there" };
   }
   const settled = resolveAsFarAsItGoes(named);
-  if (projects === undefined || settled === undefined || !within(settled, projects)) {
-    return { refused: "outside this config home's projects tree" };
+  if (tree === undefined || settled === undefined || !within(settled, tree)) {
+    return { refused: "outside this config home's transcript tree" };
   }
   const stat = statSync(settled, { throwIfNoEntry: false });
   if (stat !== undefined && !stat.isFile()) return { refused: "not a file" };

package/src/sessions/search.ts

@@ -239,11 +239,11 @@ function says(text: string, clauses: readonly Clause[]): boolean {
 
 /** Whether the project directory could be the working directory asked for.
  *
- * The harness flattens a working directory into one name, and the flattening
- * is lossy — separators, dots and underscores all become dashes — so this only
+ * A harness that files by working directory flattens it into one name, and the
+ * flattening is lossy — separators, dots and underscores all become dashes — so this only
  * narrows what is opened. What decides a hit is the transcript's own `cwd`. */
-function looksLike(project: string, words: readonly string[]): boolean {
-  if (words.length === 0) return true;
+function looksLike(project: string | undefined, words: readonly string[]): boolean {
+  if (words.length === 0 || project === undefined) return true;
   const flat = flatten(project);
   return words.every((word) => flat.includes(flatten(word)));
 }

package/src/transcript/files.ts

@@ -1,19 +1,59 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import type { Sid } from "@ccmsg/protocol";
+import { type Harness, HARNESS } from "../harness/index.ts";
 import { OpError } from "../dispatch/index.ts";
 
-/** Where the harness keeps transcripts under a config home: one directory per
- * working directory, one `<sid>.jsonl` in it. */
-const PROJECTS = "projects";
 const SUFFIX = ".jsonl";
 
-/** A session id as the harness names files by. Validated before it is joined
+/** Where one harness keeps transcripts under its config home, and how a file
+ * there says which session it belongs to (§3.8).
+ *
+ * Two facts, because the two harnesses file the same thing differently. Claude
+ * Code keeps one directory per working directory and names the file after the
+ * session; Codex keeps one directory per date and names the file after the
+ * thread with the moment it started in front. The `depth` is how many
+ * directories stand between the root and a file, which is what the walk needs
+ * and what the naming does not say.
+ *
+ * A Codex rollout that was reverted carries a second id after the thread's own,
+ * separated by `_`: the thread is the same and the file is a new one, so the
+ * name still answers "which session" and that is what is read out of it. */
+interface TranscriptLayout {
+  readonly depth: number;
+  /** The session a file belongs to, or nothing when the name is not one this
+   * harness writes. */
+  readonly sidOf: (name: string) => Sid | undefined;
+  /** What that session's file is called, where the name follows from the sid.
+   * Absent where it does not, which is what makes the walk the only way in. */
+  readonly nameOf?: (sid: Sid) => string;
+}
+
+/** A session id as Claude Code names files by. Validated before it is joined
  * to a path, so a sid is a name rather than a route: no separator and no dot
  * can appear in it, which makes traversal unrepresentable rather than
  * unlikely. */
 const SID = /^[0-9a-fA-F-]{8,64}$/;
 
+/** A Codex rollout, as its recorder writes the name: the moment it opened, the
+ * thread UUID, and the rollout's own id after it when the thread was reverted.
+ * The thread UUID is what a sid is here (measured against codex-cli 0.153.4). */
+const ROLLOUT =
+  /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})(?:_[0-9a-fA-F-]{36})?\.jsonl$/;
+
+const LAYOUTS: Record<Harness, TranscriptLayout> = {
+  claude: {
+    depth: 1,
+    sidOf: (name) => {
+      if (!name.endsWith(SUFFIX)) return undefined;
+      const sid = name.slice(0, -SUFFIX.length);
+      return SID.test(sid) ? sid : undefined;
+    },
+    nameOf: (sid) => `${sid}${SUFFIX}`,
+  },
+  codex: { depth: 3, sidOf: (name) => ROLLOUT.exec(name)?.[1] },
+};
+
 /** The agent id and run id shapes the harness writes under a session's own
  * directory, and the name a teammate is addressed by. Each is validated on the
  * same footing as a sid, for the same reason: all three name a file. */
@@ -30,6 +70,8 @@ const TEAMMATE = /^[A-Za-z0-9_-]{1,64}$/;
  * (M6) — nothing searches for another one. */
 export interface TranscriptFilesDeps {
   readonly configHome: string;
+  /** Which harness's tree is under it (§3.8). */
+  readonly harness: Harness;
   /** Where a connected session said its transcript is (§5.1). A session that
    * never greeted has none, and the walk below answers for it. */
   readonly announced: (sid: Sid) => string | undefined;
@@ -42,10 +84,10 @@ export class TranscriptFiles {
    *
    * Two ways to the one file, in the order of what each is good for: what the
    * session announced is exact and costs no search, and the walk finds the
-   * file by the identity it carries in its name (`<sid>.jsonl`) for a session
-   * that never greeted or is no longer running. Both stay inside this
-   * instance's `projects/` — the announced path because it was taken only if
-   * it was inside it, the walk because that tree is what it walks (M6). */
+   * file by the identity it carries in its name for a session that never
+   * greeted or is no longer running. Both stay inside this harness's own
+   * transcript tree — the announced path because it was taken only if it was
+   * inside it, the walk because that tree is what it walks (M6). */
   path(sid: Sid): string | undefined {
     const announced = this.deps.announced(sid);
     if (announced !== undefined && isFile(announced)) return announced;
@@ -117,21 +159,23 @@ export class TranscriptFiles {
    * the file and what a `stat` already said about it, so neither has to stat
    * again to decide whether to open it. */
   all(): TranscriptFile[] {
+    const layout = LAYOUTS[this.deps.harness];
     const found: TranscriptFile[] = [];
-    const projects = join(this.deps.configHome, PROJECTS);
-    for (const project of names(projects)) {
-      const dir = join(projects, project);
+    for (const dir of directories(this.#root(), layout.depth)) {
       for (const entry of names(dir)) {
-        if (!entry.endsWith(SUFFIX)) continue;
-        const sid = entry.slice(0, -SUFFIX.length);
-        if (!SID.test(sid)) continue;
+        const sid = layout.sidOf(entry);
+        if (sid === undefined) continue;
         const file = join(dir, entry);
         const stat = statOf(file);
         if (stat === undefined) continue;
         found.push({
           sid,
           file,
-          project,
+          // Only a layout that files by working directory has one to state,
+          // and the field is a prefilter: a tree that says nothing about where
+          // a session ran narrows nothing, and the transcript's own `cwd`
+          // decides as it already does.
+          ...(this.deps.harness === "claude" ? { project: basename(dir) } : {}),
           size: stat.size,
           created_at: Math.round(stat.birthtimeMs || stat.ctimeMs),
           updated_at: Math.round(stat.mtimeMs),
@@ -142,17 +186,52 @@ export class TranscriptFiles {
     return found;
   }
 
+  /** The root of this harness's transcript tree, which is the boundary every
+   * path below is inside of (M6). */
+  #root(): string {
+    return join(this.deps.configHome, HARNESS[this.deps.harness].transcripts);
+  }
+
+  /** The session's file, found by the identity its name carries.
+   *
+   * A layout whose name follows from the sid is joined rather than searched,
+   * which is one `stat` per directory instead of a listing; one whose name
+   * carries more than the sid is walked, because the rest of the name is
+   * exactly what this does not know. */
   private find(sid: Sid): string | undefined {
-    if (!SID.test(sid)) return undefined;
-    const projects = join(this.deps.configHome, PROJECTS);
-    for (const project of names(projects)) {
-      const file = join(projects, project, `${sid}${SUFFIX}`);
-      if (isFile(file)) return file;
+    const layout = LAYOUTS[this.deps.harness];
+    const dirs = directories(this.#root(), layout.depth);
+    const nameOf = layout.nameOf;
+    if (nameOf !== undefined) {
+      if (!SID.test(sid)) return undefined;
+      for (const dir of dirs) {
+        const file = join(dir, nameOf(sid));
+        if (isFile(file)) return file;
+      }
+      return undefined;
+    }
+    for (const dir of dirs) {
+      for (const entry of names(dir)) {
+        if (layout.sidOf(entry) === sid && isFile(join(dir, entry))) return join(dir, entry);
+      }
     }
     return undefined;
   }
 }
 
+/** Every directory transcripts sit in, at the depth the layout files them at.
+ *
+ * Names are read rather than dates computed: what is there is what the harness
+ * wrote, and a tree with a directory nobody expected is one whose files are
+ * still found. */
+function directories(root: string, depth: number): string[] {
+  let level = [root];
+  for (let step = 0; step < depth; step += 1) {
+    level = level.flatMap((dir) => names(dir).map((entry) => join(dir, entry)));
+  }
+  return level;
+}
+
 export interface AgentNames {
   readonly agent_id?: string;
   readonly run_id?: string;
@@ -165,8 +244,10 @@ export interface TranscriptFile {
   readonly file: string;
   /** The project directory's name, which is the working directory flattened.
    * A lossy spelling — separators and dots all become dashes — so it prefilters
-   * a search and never decides it. */
-  readonly project: string;
+   * a search and never decides it. Absent where the harness files transcripts
+   * by something other than the working directory, which leaves nothing to
+   * prefilter on. */
+  readonly project?: string;
   readonly size: number;
   readonly created_at: number;
   readonly updated_at: number;