@cueloop/daemon 0.1.0-alpha.79 → 0.1.0-alpha.80

package/src/client.ts

@@ -4,16 +4,20 @@
  * autostart spawns a detached daemon when the socket is dead, then attaches.
  */
 
-import { existsSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import * as v from "valibot";
 import type {
   Annotation,
   Artifact,
   DiffFileStatus,
+  DiffFileContents,
   HunkRejection,
   ShareLink,
   Thread,
-  VerdictKind,
+  HarnessBinding,
+  Delivery,
+  PendingDelivery,
+  MessageOutcome,
   WorkspaceKey,
 } from "@cueloop/schema";
 import {
@@ -30,7 +34,14 @@ import type { SharedMerge } from "./api";
 
 export type { SharedMerge } from "./api";
 import { cueloopHome, ownerTokenPath, socketPath } from "./paths";
-import { Params, ThreadRecordSchema, DiffFileContentsSchema } from "./validate";
+import {
+  Params,
+  ThreadRecordSchema,
+  DiffFileContentsSchema,
+  HarnessBindingSchema,
+  DeliverySchema,
+  PendingDeliverySchema,
+} from "./validate";
 import type { WorkingTreeDiff } from "./working-tree";
 import { DAEMON_VERSION } from "./version";
 
@@ -64,7 +75,7 @@ const HerdrTabResultSchema = v.nullable(v.object({ tabId: v.string(), paneId: v.
  * blob-backed one. Depending on this interface - not DaemonClient - is what
  * lets the same <App> render a local session or a decrypted share unchanged.
  */
-export interface SessionClient {
+export interface ThreadClient {
   onEvent(listener: (event: EventFrame) => void): () => void;
   subscribe(): Promise<void>;
   sessionGet(id: string): Promise<Thread>;
@@ -123,12 +134,25 @@ export interface SessionClient {
   sessionDelete(id: string): Promise<void>;
   /** Record the caller's own identity name (collaborator self-naming on a share). */
   sessionSetSelfName(id: string, name: string): Promise<Thread>;
-  sessionResolve(
+  sessionSendMessage(
     id: string,
-    verdictKind: VerdictKind,
+    outcome: MessageOutcome,
     summary: string,
     actionBodies?: Record<string, string>,
   ): Promise<Thread>;
+  harnessBind?(
+    threadId: string,
+    harness: string,
+    harnessSessionId: string,
+  ): Promise<HarnessBinding>;
+  harnessGetBinding?(bindingId: string): Promise<HarnessBinding>;
+  harnessConsumeApprovedRetry?(
+    bindingId: string,
+    messageId: string,
+    content: string,
+  ): Promise<boolean>;
+  deliveryPending?(bindingId: string): Promise<PendingDelivery[]>;
+  deliveryAcknowledge?(deliveryId: string): Promise<Delivery>;
   close(): void;
 }
 
@@ -159,7 +183,7 @@ function readOwnerToken(home: string): string | undefined {
   return parsed.output;
 }
 
-export class DaemonClient implements SessionClient {
+export class DaemonClient implements ThreadClient {
   private socket: Awaited<ReturnType<typeof Bun.connect>> | null = null;
   private writer: BackpressureWriter | null = null;
   private pending = new Map<number, PendingRequest>();
@@ -201,15 +225,15 @@ export class DaemonClient implements SessionClient {
       // caller hears why instead of the client replacing a running daemon
       if (!options.autostart || err instanceof DaemonClientError) throw err;
     }
-    // Socket dead, absent, or just-replaced: clean a stale file and spawn detached.
+    // Socket dead, absent, or just-replaced: let the new daemon own socket cleanup.
     return client.attachFreshDaemon(home, path);
   }
 
   /**
    * Tear down a daemon from an earlier build so a fresh one can bind: ask it to
    * shut down (owner-gated) or, failing that, signal its pid, then wait for it to
-   * release the socket. Best-effort - attachFreshDaemon's stale-socket and
-   * stale-lock cleanup recovers even a daemon that never ran its own teardown.
+   * release the socket. Best-effort - the next daemon reclaims stale socket
+   * and lock files after it takes ownership.
    */
   private async stopStaleDaemon(path: string): Promise<void> {
     const pid = this.daemonPid;
@@ -241,9 +265,8 @@ export class DaemonClient implements SessionClient {
     this.pending.clear();
   }
 
-  /** Clean any stale socket, spawn a detached daemon, and dial it until it answers. */
+  /** Spawn a detached daemon and dial the lock owner until it answers. */
   private async attachFreshDaemon(home: string, path: string): Promise<DaemonClient> {
-    if (existsSync(path)) rmSync(path, { force: true });
     spawnDaemon(home);
     // Generous: a cold or loaded machine pays for a runtime start before the
     // socket exists, and giving up early looks to callers like a broken daemon.
@@ -513,30 +536,62 @@ export class DaemonClient implements SessionClient {
   sessionSetSelfName(id: string, _name: string): Promise<Thread> {
     return this.sessionGet(id);
   }
-  sessionResolve(
+  sessionSendMessage(
     id: string,
-    verdictKind: VerdictKind,
+    outcome: MessageOutcome,
     summary: string,
     actionBodies?: Record<string, string>,
   ): Promise<Thread> {
     return this.request(
-      "session.resolve",
-      { id, verdictKind, summary, actionBodies },
+      "session.sendMessage",
+      { id, outcome, summary, actionBodies },
       ThreadRecordSchema,
     );
   }
+  harnessBind(
+    threadId: string,
+    harness: string,
+    harnessSessionId: string,
+  ): Promise<HarnessBinding> {
+    return this.request(
+      "harness.bind",
+      { threadId, harness, harnessSessionId },
+      HarnessBindingSchema,
+    );
+  }
+  harnessGetBinding(bindingId: string): Promise<HarnessBinding> {
+    return this.request("harness.getBinding", { bindingId }, HarnessBindingSchema);
+  }
+  harnessConsumeApprovedRetry(
+    bindingId: string,
+    messageId: string,
+    content: string,
+  ): Promise<boolean> {
+    return this.request(
+      "harness.consumeApprovedRetry",
+      { bindingId, messageId, content },
+      v.boolean(),
+    );
+  }
+  deliveryPending(bindingId: string): Promise<PendingDelivery[]> {
+    return this.request("delivery.pending", { bindingId }, v.array(PendingDeliverySchema));
+  }
+  deliveryAcknowledge(deliveryId: string): Promise<Delivery> {
+    return this.request("delivery.acknowledge", { deliveryId }, DeliverySchema);
+  }
   sessionSubmitRevision(
     id: string,
     content: string,
     addressedAnnotationIds: string[] = [],
+    files?: DiffFileContents[],
   ): Promise<Thread> {
     return this.request(
       "session.submitRevision",
-      { id, content, addressedAnnotationIds },
+      { id, content, addressedAnnotationIds, files },
       ThreadRecordSchema,
     );
   }
-  /** herdr adapter scratch: the tab opened for a review; local-only, off the SessionClient contract. */
+  /** herdr adapter scratch: the tab opened for a review; local-only, off the ThreadClient contract. */
   herdrGetTab(id: string): Promise<HerdrTabHandle | null> {
     return this.request("herdr.getTab", { id }, HerdrTabResultSchema);
   }

package/src/diff-hot-reload.test.ts

@@ -10,7 +10,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { DaemonCore } from "./api";
 import { workingTreeDiff } from "./working-tree";
-import { resolveWorkspace } from "./review";
+import { resolveWorkspace } from "./thread-review";
 import type { Artifact } from "@cueloop/schema";
 
 function git(args: string[], cwd: string): void {
@@ -134,7 +134,7 @@ describe("session.refreshDiff", () => {
     // Given a diff session that has been resolved
     const session = await openDiffSession();
 
-    core.sessionResolve(session.id, "approve", "");
+    core.sessionSendMessage(session.id, "approved", "");
     const resolvedContent = core.sessionGet(session.id).artifact.content;
 
     writeFileSync(join(repo, "a.ts"), "export const a = 99;\n");

package/src/harness-delivery.test.ts

@@ -0,0 +1,193 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonCore } from "./api";
+import { harnessStatePath } from "./paths";
+
+let home: string;
+let cores: DaemonCore[];
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-harness-delivery-"));
+  cores = [];
+});
+
+afterEach(() => {
+  for (const core of cores) core.dispose();
+  rmSync(home, { recursive: true, force: true });
+});
+
+function core(): DaemonCore {
+  const instance = new DaemonCore(home);
+
+  cores.push(instance);
+
+  return instance;
+}
+
+function createPlan(instance: DaemonCore) {
+  return instance.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan", meta: {} },
+  });
+}
+
+describe("durable harness delivery", () => {
+  test("redelivers after reload until the harness acknowledges the Message", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = first.sessionSendMessage(thread.id, "changes_requested", "Add detail.");
+    const initial = first.deliveryPending(binding.id);
+
+    expect(initial).toHaveLength(1);
+    expect(initial[0]!.message).toEqual(sent.message!);
+
+    const reloaded = core();
+    const redelivered = reloaded.deliveryPending(binding.id);
+
+    expect(redelivered).toEqual(initial);
+    reloaded.deliveryAcknowledge(redelivered[0]!.delivery.id);
+
+    expect(core().deliveryPending(binding.id)).toEqual([]);
+  });
+
+  test("retains an expired Thread until its pending Message is acknowledged", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    first.sessionSendMessage(thread.id, "approved", "Ready.");
+    const oldThread = first.sessionGet(thread.id);
+
+    first.store.upsert({ ...oldThread, createdAt: "2020-01-01T00:00:00.000Z" });
+
+    const reloaded = core();
+    const delivery = reloaded.deliveryPending(binding.id)[0];
+
+    expect(delivery?.message.body).toContain("Ready.");
+    reloaded.deliveryAcknowledge(delivery!.delivery.id);
+
+    expect(core().store.get(thread.id)).toBeUndefined();
+  });
+
+  test("rebuilds a delivery if the Thread saved its Message before enqueue", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = first.sessionSendMessage(thread.id, "approved", "Ready.");
+    first.store.upsert({
+      ...first.sessionGet(thread.id),
+      createdAt: "2020-01-01T00:00:00.000Z",
+    });
+
+    writeFileSync(harnessStatePath(home), JSON.stringify({ bindings: [binding], deliveries: [] }));
+
+    const recovered = core().deliveryPending(binding.id);
+
+    expect(recovered).toHaveLength(1);
+    expect(recovered[0]!.message).toEqual(sent.message!);
+  });
+
+  test("routes an approved retry as a new Message", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "changes_requested", "Try once more.");
+    const first = instance.deliveryPending(binding.id)[0]!;
+
+    instance.deliveryAcknowledge(first.delivery.id);
+    instance.sessionSubmitRevision(thread.id, "# Plan");
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const retry = instance.deliveryPending(binding.id);
+
+    expect(retry).toHaveLength(1);
+    expect(retry[0]!.message.outcome).toBe("approved");
+    expect(retry[0]!.message.id).not.toBe(first.message.id);
+  });
+
+  test("keeps an older pending Message available after a Thread revision", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "changes_requested", "Add detail.");
+    const first = instance.deliveryPending(binding.id)[0]!;
+
+    instance.sessionSubmitRevision(thread.id, "# Revised plan");
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+
+    const pending = core().deliveryPending(binding.id);
+
+    expect(pending.map((item) => item.message.id)).toEqual([first.message.id, expect.any(String)]);
+    expect(pending[0]!.message.body).toBe(first.message.body);
+  });
+
+  test("defaults delivery to the submitting binding only", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const submitter = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const other = instance.harnessBind({
+      threadId: thread.id,
+      harness: "other",
+      harnessSessionId: "other_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+
+    expect(instance.deliveryPending(submitter.id)).toHaveLength(1);
+    expect(instance.deliveryPending(other.id)).toEqual([]);
+  });
+
+  test("consumes the unchanged approved retry once across daemon reload", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const messageId = sent.message!.id;
+
+    expect(() => instance.harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toThrow(
+      "no unchanged approved plan",
+    );
+
+    const delivery = instance.deliveryPending(binding.id)[0]!.delivery;
+
+    instance.deliveryAcknowledge(delivery.id);
+
+    expect(instance.harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toBe(true);
+    expect(core().harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toBe(false);
+    expect(() => core().harnessConsumeApprovedRetry(binding.id, messageId, "# Changed")).toThrow(
+      "no unchanged approved plan",
+    );
+  });
+});

package/src/harness-state-store.test.ts

@@ -0,0 +1,65 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { HarnessStateStore } from "./harness-state-store";
+import { harnessStatePath } from "./paths";
+
+let home: string;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-harness-state-"));
+});
+
+afterEach(() => {
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("HarnessStateStore", () => {
+  test("redelivers an unacknowledged Message after reload", () => {
+    const store = new HarnessStateStore(home);
+    const binding = store.bind({
+      threadId: "ses_1",
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const delivery = store.enqueue({ bindingId: binding.id, messageId: "msg_1" });
+
+    expect(store.pending(binding.id)).toEqual([delivery]);
+
+    const reloaded = new HarnessStateStore(home);
+
+    expect(reloaded.pending(binding.id)).toEqual([delivery]);
+  });
+
+  test("does not redeliver an acknowledged Message", () => {
+    const store = new HarnessStateStore(home);
+    const binding = store.bind({
+      threadId: "ses_1",
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const delivery = store.enqueue({ bindingId: binding.id, messageId: "msg_1" });
+
+    store.acknowledge(delivery.id, "2026-09-20T20:00:00.000Z");
+
+    expect(new HarnessStateStore(home).pending(binding.id)).toEqual([]);
+  });
+
+  test("reuses the binding for the same harness session and thread", () => {
+    const store = new HarnessStateStore(home);
+    const input = {
+      threadId: "ses_1",
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    };
+
+    expect(store.bind(input)).toEqual(store.bind(input));
+  });
+
+  test("does not discard pending deliveries when persisted state is corrupt", () => {
+    writeFileSync(harnessStatePath(home), "{broken");
+
+    expect(() => new HarnessStateStore(home)).toThrow();
+  });
+});

package/src/harness-state-store.ts

@@ -0,0 +1,182 @@
+/**
+ * Durable harness routing state. Bindings identify where a Thread came from;
+ * deliveries record which Message still needs to reach that binding. Keeping
+ * both outside Thread records prevents harness identity from leaking into the
+ * product primitive and makes redelivery independent of the review lifecycle.
+ */
+
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import type { Delivery, HarnessBinding } from "@cueloop/schema";
+import * as v from "valibot";
+import { harnessStatePath } from "./paths";
+import { DeliverySchema, HarnessBindingSchema } from "./validate";
+
+type BindInput = Pick<HarnessBinding, "threadId" | "harness" | "harnessSessionId">;
+type EnqueueInput = Pick<Delivery, "bindingId" | "messageId">;
+
+const HarnessStateSchema = v.object({
+  bindings: v.array(HarnessBindingSchema),
+  deliveries: v.array(DeliverySchema),
+});
+const FileErrorSchema = v.object({ code: v.string() });
+
+export class HarnessStateStore {
+  private readonly path: string;
+  private bindings = new Map<string, HarnessBinding>();
+  private deliveries = new Map<string, Delivery>();
+
+  constructor(home: string) {
+    this.path = harnessStatePath(home);
+    this.load();
+  }
+
+  bind(input: BindInput): HarnessBinding {
+    const existing = [...this.bindings.values()].find(
+      (binding) =>
+        binding.threadId === input.threadId &&
+        binding.harness === input.harness &&
+        binding.harnessSessionId === input.harnessSessionId,
+    );
+
+    if (existing) return existing;
+    const binding: HarnessBinding = {
+      ...input,
+      id: newRoutingId("bind"),
+      createdAt: new Date().toISOString(),
+    };
+
+    this.bindings.set(binding.id, binding);
+    this.persist();
+
+    return binding;
+  }
+
+  binding(id: string): HarnessBinding | null {
+    return this.bindings.get(id) ?? null;
+  }
+
+  consumeApprovedRetry(bindingId: string, messageId: string): boolean {
+    const binding = this.bindings.get(bindingId);
+
+    if (!binding) throw new Error(`no harness binding ${bindingId}`);
+
+    if (binding.approvedRetryMessageId === messageId) return false;
+
+    this.bindings.set(bindingId, { ...binding, approvedRetryMessageId: messageId });
+    this.persist();
+
+    return true;
+  }
+
+  /** The first binding is the submitter; other bindings need explicit future routing. */
+  submittingBinding(threadId: string): HarnessBinding | null {
+    return [...this.bindings.values()].find((binding) => binding.threadId === threadId) ?? null;
+  }
+
+  enqueue(input: EnqueueInput): Delivery {
+    const existing = [...this.deliveries.values()].find(
+      (delivery) =>
+        delivery.bindingId === input.bindingId && delivery.messageId === input.messageId,
+    );
+
+    if (existing) return existing;
+    const delivery: Delivery = {
+      ...input,
+      id: newRoutingId("del"),
+      status: "pending",
+      createdAt: new Date().toISOString(),
+    };
+
+    this.deliveries.set(delivery.id, delivery);
+    this.persist();
+
+    return delivery;
+  }
+
+  pending(bindingId: string): Delivery[] {
+    return [...this.deliveries.values()].filter(
+      (delivery) => delivery.bindingId === bindingId && delivery.status === "pending",
+    );
+  }
+
+  /** A pending delivery keeps its Thread's immutable Message body available for redelivery. */
+  pendingThreadIds(): Set<string> {
+    const ids = new Set<string>();
+
+    for (const delivery of this.deliveries.values()) {
+      if (delivery.status !== "pending") continue;
+      const binding = this.bindings.get(delivery.bindingId);
+
+      if (binding) ids.add(binding.threadId);
+    }
+
+    return ids;
+  }
+
+  acknowledged(bindingId: string, messageId: string): boolean {
+    return [...this.deliveries.values()].some(
+      (delivery) =>
+        delivery.bindingId === bindingId &&
+        delivery.messageId === messageId &&
+        delivery.status === "acknowledged",
+    );
+  }
+
+  delivery(deliveryId: string): Delivery | null {
+    return this.deliveries.get(deliveryId) ?? null;
+  }
+
+  acknowledge(deliveryId: string, acknowledgedAt = new Date().toISOString()): Delivery {
+    const delivery = this.deliveries.get(deliveryId);
+
+    if (!delivery) throw new Error(`no delivery ${deliveryId}`);
+
+    if (delivery.status === "acknowledged") return delivery;
+    const acknowledged: Delivery = {
+      ...delivery,
+      status: "acknowledged",
+      acknowledgedAt,
+    };
+
+    this.deliveries.set(deliveryId, acknowledged);
+    this.persist();
+
+    return acknowledged;
+  }
+
+  private load(): void {
+    let serialized: string;
+
+    try {
+      serialized = readFileSync(this.path, "utf8");
+    } catch (error) {
+      const parsed = v.safeParse(FileErrorSchema, error);
+
+      if (parsed.success && parsed.output.code === "ENOENT") {
+        return;
+      }
+
+      throw error;
+    }
+
+    const state = v.parse(HarnessStateSchema, JSON.parse(serialized));
+
+    this.bindings = new Map(state.bindings.map((binding) => [binding.id, binding]));
+    this.deliveries = new Map(state.deliveries.map((delivery) => [delivery.id, delivery]));
+  }
+
+  private persist(): void {
+    const temporaryPath = this.path + ".tmp";
+    const state = {
+      bindings: [...this.bindings.values()],
+      deliveries: [...this.deliveries.values()],
+    };
+
+    writeFileSync(temporaryPath, JSON.stringify(state, null, 2));
+    renameSync(temporaryPath, this.path);
+  }
+}
+
+function newRoutingId(prefix: "bind" | "del"): string {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}

package/src/herdr-pane.test.ts

@@ -66,7 +66,7 @@ function newSession(overrides: Partial<Thread> = {}): Thread {
     artifact: { type: "plan", content: "# P", meta: { cwd: "/repo/work", title: "Rollout Plan" } },
     revisions: [{ revision: 1, content: "# P", submittedAt: "now" }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "now",
     ...overrides,

package/src/index.ts

@@ -1,6 +1,6 @@
 /**
  * The daemon's public surface. Consumers reach the client and the review
- * helpers through the ./client and ./review subpaths; this barrel carries
+ * helpers through the ./client and ./thread-review subpaths; this barrel carries
  * only the two names imported bare: the server and the home-dir resolver.
  */
 

package/src/paths.ts

@@ -64,3 +64,8 @@ export function ownerTokenPath(home = cueloopHome()): string {
 export function herdrTabsPath(home = cueloopHome()): string {
   return join(home, "herdr-tabs.json");
 }
+
+/** Harness bindings and Message deliveries, stored independently of Thread records. */
+export function harnessStatePath(home = cueloopHome()): string {
+  return join(home, "harness-state.json");
+}

package/src/retention.test.ts

@@ -36,7 +36,7 @@ function session(id: string, createdAt: string, status: SessionStatus = "resolve
     artifact: { type: "plan", content: "", meta: {} },
     revisions: [],
     annotations: [],
-    verdict: null,
+    message: null,
     status,
     createdAt,
   };
@@ -126,6 +126,15 @@ describe("pruneExpiredSessions", () => {
     expect(store.get("ses_new")).toBeDefined();
   });
 
+  test("keeps an expired resolved Thread while its Message is awaiting delivery", () => {
+    const store = new ThreadStore(tempDir("cueloop-retention-home-"));
+
+    store.upsert(session("ses_waiting", daysAgo(40)));
+
+    expect(pruneExpiredSessions(store, 30, NOW_MS, new Set(["ses_waiting"]))).toEqual([]);
+    expect(store.get("ses_waiting")).toBeDefined();
+  });
+
   test("never deletes an active pending session however old", () => {
     // Arrange
     const home = tempDir("cueloop-retention-home-");