agent-yes 1.290.7 → 1.291.0

package/dist/webrtcLink-CnQf9pmu.js

@@ -0,0 +1,73 @@
+import { u as parseSecret } from "./e2e-z1xpwSAg.js";
+
+//#region ts/webrtcLink.ts
+const SIGNAL_SUBPROTOCOL = "ay-signal-1";
+const DEFAULT_SIGHOST = "s.agent-yes.com";
+function parseFragment(frag) {
+	if (/^\??[A-Za-z_]+=/.test(frag)) {
+		const q = new URLSearchParams(frag.replace(/^\?/, ""));
+		const room = q.get("room");
+		const token = q.get("s");
+		if (!room || !token) return null;
+		return {
+			room,
+			token,
+			host: q.get("sig") || DEFAULT_SIGHOST
+		};
+	}
+	const at = frag.split("@");
+	const seg = at[0];
+	const i = seg.indexOf(":");
+	if (i < 0) return null;
+	return {
+		room: seg.slice(0, i),
+		token: seg.slice(i + 1),
+		host: at[1] || DEFAULT_SIGHOST
+	};
+}
+/** Parse a share link WITHOUT validating/stripping the secret's version marker. */
+function parseRaw(link) {
+	const wr = /^webrtc:\/\/([^:]+):([^@]+)@(.+)$/.exec(link);
+	if (wr) return {
+		room: wr[1],
+		token: wr[2],
+		host: wr[3]
+	};
+	if (/^https?:\/\//.test(link) && link.includes("#")) return parseFragment(link.split("#")[1] ?? "");
+	return null;
+}
+/**
+* Parse a share link into { room, secret, signaling-host }. Accepts:
+*   webrtc://<room>:<token>@<host>                    (internal / legacy form)
+*   https://<anyhost>/room/#room=<id>&s=<token>[&sig=<host>]
+*   https://<anyhost>/w/#<room>:<token>[@<sighost>]   (older positional form)
+* Returns null if the string isn't a recognizable share link.
+*/
+function parseWebrtcLink(link) {
+	const raw = parseRaw(link);
+	if (!raw) return null;
+	const { s } = parseSecret(raw.token);
+	return {
+		room: raw.room,
+		s,
+		host: raw.host
+	};
+}
+/**
+* Normalize any accepted share-link spelling to the internal
+* `webrtc://<room>:<token>@<host>` form that startShare/parseShareUrl consume.
+* Returns the RAW token, so a legacy markerless room round-trips unchanged
+* instead of being handed a marker it never had.
+*/
+function toWebrtcUrl(link) {
+	const raw = parseRaw(link);
+	return raw ? `webrtc://${raw.room}:${raw.token}@${raw.host}` : null;
+}
+/** True if `spec` looks like a WebRTC share link (vs. an http remote or alias). */
+function isWebrtcSpec(spec) {
+	return spec.startsWith("webrtc://") || /^https?:\/\//.test(spec) && spec.includes("#");
+}
+
+//#endregion
+export { toWebrtcUrl as i, isWebrtcSpec as n, parseWebrtcLink as r, SIGNAL_SUBPROTOCOL as t };
+//# sourceMappingURL=webrtcLink-CnQf9pmu.js.map

package/dist/{webrtcRemote-L5NxhLLR.js → webrtcRemote-yvMYsij3.js}

@@ -1,5 +1,5 @@
 import { a as computeTranscriptHash, c as open, d as randomHex, f as seal, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, s as deriveDirKeys } from "./e2e-z1xpwSAg.js";
-import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-DLaJfTcB.js";
+import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-CnQf9pmu.js";
 import { RTCPeerConnection } from "node-datachannel/polyfill";
 
 //#region ts/signalingHint.ts
@@ -297,4 +297,4 @@ async function startWebrtcBridge(link) {
 
 //#endregion
 export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-L5NxhLLR.js.map
+//# sourceMappingURL=webrtcRemote-yvMYsij3.js.map

package/dist/{widget-OvkqW2Z6.js → widget-DhBSNUey.js}

@@ -28,7 +28,7 @@ function parseFlags(args, known) {
 }
 /** Resolve the local daemon base URL + token (flags override discovery). */
 async function daemonTarget(flags) {
-	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-B2nisui8.js");
+	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-CJDQq_Jp.js");
 	const base = typeof flags.base === "string" ? flags.base : await resolveDaemonHttpBase();
 	if (!base) throw new Error("no running ay serve daemon found — start `ay serve` or pass --base <url> (e.g. http://127.0.0.1:PORT)");
 	const token = typeof flags.token === "string" ? flags.token : await loadTokenReadOnly() ?? "";
@@ -186,7 +186,7 @@ async function cmdMint(args) {
 	const bad = caps.filter((c) => !KNOWN_CAPS.has(c));
 	if (bad.length) throw new Error(`unknown cap(s): ${bad.join(", ")} (valid: ${[...KNOWN_CAPS].join(", ")})`);
 	const ttlSec = parseTtlSec(typeof flags.ttl === "string" ? flags.ttl : "15m");
-	const { mintScopedTermToken } = await import("./serve-B2nisui8.js");
+	const { mintScopedTermToken } = await import("./serve-CJDQq_Jp.js");
 	const r = await mintScopedTermToken(target, {
 		ttlSec,
 		caps
@@ -202,4 +202,4 @@ async function cmdMint(args) {
 
 //#endregion
 export { cmdMint, cmdWidget };
-//# sourceMappingURL=widget-OvkqW2Z6.js.map
+//# sourceMappingURL=widget-DhBSNUey.js.map

package/dist/widgets.js

@@ -2,7 +2,7 @@ import "./e2e-z1xpwSAg.js";
 import "./channels-C3w3eAES.js";
 import "./peer-BZyUyCt3.js";
 import { t as AyChannel } from "./browser-XQnbPssj.js";
-import { t as AyTerminal } from "./browser-oqC3Ln2a.js";
+import { t as AyTerminal } from "./browser-wkzxw6lx.js";
 import { AyWidget } from "./widget.js";
 
 export { AyChannel, AyTerminal, AyWidget };

package/dist/{ws-BeMouYAU.js → ws-CMX0pkti.js}

@@ -1,4 +1,4 @@
-import { F as listRecords } from "./subcommands-D6LBtVPM.js";
+import { F as listRecords } from "./subcommands-yWgVRM2r.js";
 import { a as getProvisionRoot } from "./workspaceConfig-DTvPtr5j.js";
 import { existsSync } from "fs";
 import { lstat, opendir } from "fs/promises";
@@ -424,4 +424,4 @@ async function cmdWs(args) {
 
 //#endregion
 export { isPathInside as a, walkWorkspaces as c, importProvisionModule as i, workspaceStatus as l, cmdWs as n, loadProvision as o, collectWorkspaces as r, resolveOperand as s, WS_JSON_SCHEMA as t };
-//# sourceMappingURL=ws-BeMouYAU.js.map
+//# sourceMappingURL=ws-CMX0pkti.js.map

package/dist/{ws-qZy7Giub.js → ws-DZ9YAXlY.js}

@@ -1,14 +1,14 @@
 import "./logger-CDIsZ-Pp.js";
 import "./JsonlStore-BqF7AQ6E.js";
-import "./globalPidIndex-DoaKEUkO.js";
-import "./pidStore-B73xnAeT.js";
-import "./messageLog-CVRSTLza.js";
+import "./globalPidIndex-CRH9L9tn.js";
+import "./pidStore-DXWqzTSz.js";
+import "./messageLog-Brx3w6zT.js";
 import "./e2e-z1xpwSAg.js";
 import "./configShared-DKTgiz7K.js";
-import "./subcommands-D6LBtVPM.js";
+import "./subcommands-yWgVRM2r.js";
 import "./notifyStore-2SWKGwZI.js";
-import "./webrtcLink-DLaJfTcB.js";
-import "./remotes-DTXPW8U1.js";
-import { a as isPathInside, c as walkWorkspaces, i as importProvisionModule, l as workspaceStatus, n as cmdWs, o as loadProvision, r as collectWorkspaces, s as resolveOperand, t as WS_JSON_SCHEMA } from "./ws-BeMouYAU.js";
+import "./webrtcLink-CnQf9pmu.js";
+import "./remotes-tmKwrr20.js";
+import { a as isPathInside, c as walkWorkspaces, i as importProvisionModule, l as workspaceStatus, n as cmdWs, o as loadProvision, r as collectWorkspaces, s as resolveOperand, t as WS_JSON_SCHEMA } from "./ws-CMX0pkti.js";
 
 export { WS_JSON_SCHEMA, cmdWs, collectWorkspaces, isPathInside, loadProvision, walkWorkspaces, workspaceStatus };

package/lab/ui/console-logic.js

@@ -619,13 +619,33 @@ export function layeredRows(entries) {
   // parent — which is what makes single-node layers vanish.
   const roomNodes = [];
   for (const [rid, re] of groupBy(entries, (e) => e._room || "")) {
-    const peerGroups = groupBy(re, (e) => e._host || "");
+    // Group by SOURCE, not by the device label. A label is not an identity: two
+    // machines routinely report the same `user@host` — cloned images and
+    // container fleets are the normal provisioning case, and several daemons on
+    // one box report it too. Grouping by `_host` merged those into one peer
+    // group, so their agents landed in a single PID forest and could be shown
+    // parented to each other, and the layer then looked single-membered and was
+    // hidden entirely — two machines rendered as unlabelled sibling rows with
+    // nothing saying which box was which. `_src` is one machine by construction
+    // (`<room>/<peerId>` for a codehost peer, the room id for an ay-share room).
+    const peerGroups = groupBy(re, (e) => e._src || e._host || "");
     const multiPeer = peerGroups.length > 1;
+    // Labels only have to be unique for READING; identity is `_src` above. When
+    // two sources really do share a label, suffix a short slice of the source so
+    // the operator can still tell the rows apart before sending a command to one.
+    const labelCounts = new Map();
+    for (const [, pe] of peerGroups) {
+      const l = pe[0]?._host || "";
+      if (l) labelCounts.set(l, (labelCounts.get(l) || 0) + 1);
+    }
     const underRoom = [];
-    for (const [host, pe] of peerGroups) {
+    for (const [src, pe] of peerGroups) {
       const agentNodes = agentForestNodes(pe).map(toAgentNode);
-      if (multiPeer && host)
-        underRoom.push({ kind: "peer", label: host, room: rid, host, children: agentNodes });
+      const host = pe[0]?._host || "";
+      const label =
+        host && labelCounts.get(host) > 1 ? `${host} (${String(src).slice(-6)})` : host;
+      if (multiPeer && label)
+        underRoom.push({ kind: "peer", label, room: rid, host, src, children: agentNodes });
       else underRoom.push(...agentNodes); // single/unlabelled peer hidden
     }
     if (multiRoom && rid) roomNodes.push({ kind: "room", label: rid, children: underRoom });
@@ -646,6 +666,9 @@ export function layeredRows(entries) {
       entry: node.entry,
       room: node.room, // peer headers: (room,host) keys the connection-type cache
       host: node.host,
+      // The peer's source id. `host` can repeat across machines, so anything
+      // keying per-machine state off a header must use this, not (room,host).
+      src: node.src,
       parentEntry: node.kind === "agent" ? parentAgent : null,
       branch: railPrefix(ancestorsLast),
       depth: ancestorsLast.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.290.7",
+  "version": "1.291.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/crossTreeClaim.bun.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "bun:test";
+import { envelopeAttribution } from "./subcommands.ts";
+import { senderLabel, type MessageRecord } from "./messageLog.ts";
+
+const rec = (over: Partial<MessageRecord>): MessageRecord => ({
+  at: 1,
+  from: { pid: 20298, cli: "claude", cwd: "/x/acme/tree/dev", agent_id: "lane-dev" },
+  to: { pid: 2, cli: "claude", cwd: "/x/acme/tree/qa", agent_id: "lane-qa" },
+  body: "hi",
+  wrapped: true,
+  ...over,
+});
+
+describe("a different tree claiming a lane is the contradiction", () => {
+  // Measured on real traffic before this change: the rule keyed on "is some
+  // OTHER registered lane my ancestor", and it ran inverted — LOUD on a lane's
+  // own nested processes (same tree, benign) and SILENT while another worktree
+  // sent two documents under this lane's name. The working directory is what
+  // actually separates them.
+  it("is LOUD in the envelope, because the receiving model reads only that", () => {
+    expect(envelopeAttribution("env-uncorroborated")).toContain("UNCORROBORATED");
+  });
+
+  it("stays quiet for a lane's own detached process in its own tree", () => {
+    expect(envelopeAttribution("env-unverified")).toBe("");
+  });
+
+  it("keeps the honest path silent", () => {
+    expect(envelopeAttribution("env")).toBe("");
+  });
+
+  it("renders the distinction in a listing, where a human reads deliberately", () => {
+    expect(senderLabel(rec({ from_via: "env-uncorroborated" }))).toContain("UNCORROBORATED");
+    expect(senderLabel(rec({ from_via: "env-unverified" }))).toContain("unverified");
+    expect(senderLabel(rec({ from_via: "env" }))).toBe("claude #20298");
+  });
+
+  it("still records what was measured about the real sender", () => {
+    // The audit that found the misattribution used exactly this: `from` said
+    // tree/dev, `sender_observed` said a process in tree/billings. Without the
+    // observation there is nothing to compare the claim against.
+    const r = rec({
+      from_via: "env-uncorroborated",
+      sender_observed: { user: "alice", host: "box", cwd: "/x/acme/tree/billings", pid: 47240 },
+    });
+    expect(r.sender_observed!.cwd).not.toBe(r.from!.cwd);
+    expect(senderLabel(r)).toContain("UNCORROBORATED");
+  });
+});
+
+describe("a sibling worktree of the same repo is the same lane", () => {
+  // Predicted by a lane before it fired, from its own fleet layout: lanes work
+  // in LINKED WORKTREES that are sibling directories, not children —
+  // ~/ws/org/_wt/feature-x alongside ~/ws/org/repo/tree/dev. A bare `ay send`
+  // from a shell there inherits AGENT_YES_PID honestly, and a path-containment
+  // check alone would accuse it.
+  //
+  // git answers it exactly: linked worktrees of one repository share a git
+  // common dir; a separate clone has its own. Measured on the reporting fleet —
+  // the sibling worktree resolved to the lane's own .git, and the worktree that
+  // had actually been misattributing resolved to a different one. A "same
+  // parent directory" heuristic would NOT separate them: both live under the
+  // same ancestor.
+  it("keeps the honest and the malign case distinguishable", () => {
+    // The property that matters, stated as the invariant rather than mocked:
+    // sharing a repo is what makes a foreign directory the same lane, and NOT
+    // sharing one is what makes it a different lane.
+    expect(envelopeAttribution("env-unverified")).toBe("");
+    expect(envelopeAttribution("env-uncorroborated")).toContain("UNCORROBORATED");
+  });
+
+  it("renders the two outcomes differently in a listing", () => {
+    expect(senderLabel(rec({ from_via: "env-unverified" }))).toContain("unverified");
+    expect(senderLabel(rec({ from_via: "env-uncorroborated" }))).toContain("UNCORROBORATED");
+  });
+});

package/ts/crossTreeClaim.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { envelopeAttribution } from "./subcommands.ts";
+import { senderLabel, type MessageRecord } from "./messageLog.ts";
+
+const rec = (over: Partial<MessageRecord>): MessageRecord => ({
+  at: 1,
+  from: { pid: 20298, cli: "claude", cwd: "/x/acme/tree/dev", agent_id: "lane-dev" },
+  to: { pid: 2, cli: "claude", cwd: "/x/acme/tree/qa", agent_id: "lane-qa" },
+  body: "hi",
+  wrapped: true,
+  ...over,
+});
+
+describe("a different tree claiming a lane is the contradiction", () => {
+  // Measured on real traffic before this change: the rule keyed on "is some
+  // OTHER registered lane my ancestor", and it ran inverted — LOUD on a lane's
+  // own nested processes (same tree, benign) and SILENT while another worktree
+  // sent two documents under this lane's name. The working directory is what
+  // actually separates them.
+  it("is LOUD in the envelope, because the receiving model reads only that", () => {
+    expect(envelopeAttribution("env-uncorroborated")).toContain("UNCORROBORATED");
+  });
+
+  it("stays quiet for a lane's own detached process in its own tree", () => {
+    expect(envelopeAttribution("env-unverified")).toBe("");
+  });
+
+  it("keeps the honest path silent", () => {
+    expect(envelopeAttribution("env")).toBe("");
+  });
+
+  it("renders the distinction in a listing, where a human reads deliberately", () => {
+    expect(senderLabel(rec({ from_via: "env-uncorroborated" }))).toContain("UNCORROBORATED");
+    expect(senderLabel(rec({ from_via: "env-unverified" }))).toContain("unverified");
+    expect(senderLabel(rec({ from_via: "env" }))).toBe("claude #20298");
+  });
+
+  it("still records what was measured about the real sender", () => {
+    // The audit that found the misattribution used exactly this: `from` said
+    // tree/dev, `sender_observed` said a process in tree/billings. Without the
+    // observation there is nothing to compare the claim against.
+    const r = rec({
+      from_via: "env-uncorroborated",
+      sender_observed: { user: "alice", host: "box", cwd: "/x/acme/tree/billings", pid: 47240 },
+    });
+    expect(r.sender_observed!.cwd).not.toBe(r.from!.cwd);
+    expect(senderLabel(r)).toContain("UNCORROBORATED");
+  });
+});
+
+describe("a sibling worktree of the same repo is the same lane", () => {
+  // Predicted by a lane before it fired, from its own fleet layout: lanes work
+  // in LINKED WORKTREES that are sibling directories, not children —
+  // ~/ws/org/_wt/feature-x alongside ~/ws/org/repo/tree/dev. A bare `ay send`
+  // from a shell there inherits AGENT_YES_PID honestly, and a path-containment
+  // check alone would accuse it.
+  //
+  // git answers it exactly: linked worktrees of one repository share a git
+  // common dir; a separate clone has its own. Measured on the reporting fleet —
+  // the sibling worktree resolved to the lane's own .git, and the worktree that
+  // had actually been misattributing resolved to a different one. A "same
+  // parent directory" heuristic would NOT separate them: both live under the
+  // same ancestor.
+  it("keeps the honest and the malign case distinguishable", () => {
+    // The property that matters, stated as the invariant rather than mocked:
+    // sharing a repo is what makes a foreign directory the same lane, and NOT
+    // sharing one is what makes it a different lane.
+    expect(envelopeAttribution("env-unverified")).toBe("");
+    expect(envelopeAttribution("env-uncorroborated")).toContain("UNCORROBORATED");
+  });
+
+  it("renders the two outcomes differently in a listing", () => {
+    expect(senderLabel(rec({ from_via: "env-unverified" }))).toContain("unverified");
+    expect(senderLabel(rec({ from_via: "env-uncorroborated" }))).toContain("UNCORROBORATED");
+  });
+});

package/ts/globalPidIndex.spec.ts

@@ -389,6 +389,159 @@ describe("globalPidIndex", () => {
     });
   });
 
+  describe("sweepOrphanLogs", () => {
+    const DAY = 24 * 60 * 60 * 1000;
+
+    // The sweep always includes the caller's own cwd. Pin it inside the temp
+    // home so the suite can never reach the real repo's `.agent-yes/`.
+    beforeEach(() => {
+      vi.spyOn(process, "cwd").mockReturnValue(testHome);
+    });
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    /** Backdate a file so it falls outside the retention window. */
+    async function backdate(file: string, ageMs: number) {
+      const { utimes } = await import("fs/promises");
+      const when = new Date(Date.now() - ageMs);
+      await utimes(file, when, when);
+    }
+
+    it("reclaims a dead pid's logs that no index record points at", async () => {
+      const mod = await loadModule();
+      const { mkdir, writeFile } = await import("fs/promises");
+      const { existsSync } = await import("fs");
+
+      // A project dir the index reaches only via a *sibling* record — the
+      // orphan's own record was already compacted away.
+      const projectCwd = path.join(testHome, "proj");
+      const dir = path.join(projectCwd, ".agent-yes");
+      await mkdir(dir, { recursive: true });
+
+      const orphanRaw = path.join(dir, "999999.raw.log");
+      const orphanDebug = path.join(dir, "999999.debug.log");
+      for (const f of [orphanRaw, orphanDebug]) {
+        await writeFile(f, "0123456789"); // 10 bytes each
+        await backdate(f, 30 * DAY);
+      }
+
+      // The only record in the index belongs to a different, live session.
+      const liveRaw = path.join(dir, `${process.pid}.raw.log`);
+      await writeFile(liveRaw, "x");
+      await backdate(liveRaw, 30 * DAY);
+      await mod.appendGlobalPid({
+        pid: process.pid,
+        cli: "claude",
+        prompt: null,
+        cwd: projectCwd,
+        log_file: liveRaw,
+        status: "active",
+        exit_code: null,
+        exit_reason: null,
+        started_at: Date.now(),
+      });
+
+      const res = await mod.sweepOrphanLogs();
+
+      expect(res.removed.sort()).toEqual([orphanDebug, orphanRaw].sort());
+      expect(res.freedBytes).toBe(20);
+      expect(existsSync(orphanRaw)).toBe(false);
+      expect(existsSync(orphanDebug)).toBe(false);
+      expect(existsSync(liveRaw)).toBe(true); // pid still running
+    });
+
+    it("keeps logs inside the retention window and non-log files", async () => {
+      const mod = await loadModule();
+      const { mkdir, writeFile } = await import("fs/promises");
+      const { existsSync } = await import("fs");
+
+      const projectCwd = path.join(testHome, "proj");
+      const dir = path.join(projectCwd, ".agent-yes");
+      await mkdir(dir, { recursive: true });
+
+      const recent = path.join(dir, "999998.raw.log"); // dead pid, but fresh
+      await writeFile(recent, "x");
+
+      // Runtime state that shares the dir and must never be swept.
+      const inbox = path.join(dir, "inbox.jsonl");
+      const sqlite = path.join(dir, "pid.sqlite");
+      const records = path.join(dir, "pid-records.jsonl");
+      for (const f of [inbox, sqlite, records]) {
+        await writeFile(f, "x");
+        await backdate(f, 30 * DAY);
+      }
+
+      await mod.appendGlobalPid({
+        pid: 999998,
+        cli: "claude",
+        prompt: null,
+        cwd: projectCwd,
+        log_file: recent,
+        status: "exited",
+        exit_code: 0,
+        exit_reason: null,
+        started_at: Date.now(),
+      });
+
+      const res = await mod.sweepOrphanLogs();
+
+      expect(res.removed).toEqual([]);
+      for (const f of [recent, inbox, sqlite, records]) expect(existsSync(f)).toBe(true);
+    });
+
+    it("does not throw when the index is empty and the cwd has no .agent-yes", async () => {
+      const mod = await loadModule();
+      const res = await mod.sweepOrphanLogs();
+      expect(res.removed).toEqual([]);
+      expect(res.freedBytes).toBe(0);
+    });
+  });
+
+  describe("gcLogs", () => {
+    beforeEach(() => {
+      vi.spyOn(process, "cwd").mockReturnValue(testHome);
+    });
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it("counts a file once when both passes would claim it", async () => {
+      const mod = await loadModule();
+      const { mkdir, writeFile, utimes } = await import("fs/promises");
+      const { existsSync } = await import("fs");
+
+      const projectCwd = path.join(testHome, "proj");
+      const dir = path.join(projectCwd, ".agent-yes");
+      await mkdir(dir, { recursive: true });
+
+      // Dead + old in BOTH senses: the index still has its record (so the
+      // retention pass claims it) and its mtime is stale (so the sweep would
+      // too). It must be reported exactly once.
+      const raw = path.join(dir, "999999.raw.log");
+      await writeFile(raw, "01234"); // 5 bytes
+      const old = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+      await utimes(raw, old, old);
+      await mod.appendGlobalPid({
+        pid: 999999,
+        cli: "claude",
+        prompt: null,
+        cwd: projectCwd,
+        log_file: raw,
+        status: "exited",
+        exit_code: 0,
+        exit_reason: null,
+        started_at: old.getTime(),
+      });
+
+      const res = await mod.gcLogs();
+
+      expect(res.removed).toEqual([raw]);
+      expect(res.freedBytes).toBe(5);
+      expect(existsSync(raw)).toBe(false);
+    });
+  });
+
   it("skips corrupt lines without throwing", async () => {
     const mod = await loadModule();
     await mod.appendGlobalPid({