@cueloop/daemon 0.1.0-alpha.87 → 0.1.0-alpha.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.87",
+  "version": "0.1.0-alpha.89",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -38,7 +38,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.87",
+    "@cueloop/schema": "0.1.0-alpha.89",
     "@pierre/diffs": "^1.4.1",
     "effect": "^4.0.0-rc.116",
     "smol-toml": "^1.8.0",

package/src/api.ts

@@ -106,6 +106,7 @@ export interface SharedMerge {
 export type EventName =
   | "session.created"
   | "session.updated"
+  | "session.deleted"
   | "message.sent"
   | "session.revised"
   | "inbox.changed";
@@ -124,7 +125,7 @@ export class DaemonCore {
   readonly herdrThreadSurfaces: HerdrThreadSurfaceStore;
   readonly ghosttyThreadSurfaces: GhosttyThreadSurfaceStore;
   readonly harnessState: HarnessStateStore;
-  private waiters = new Map<string, ((session: Thread) => void)[]>();
+  private waiters = new Map<string, ((session: Thread | null) => void)[]>();
   private listeners = new Set<EventListener>();
   private seq = 0;
   /** Drives diff hot-reload: watches each live diff session's repo for working-tree changes. */
@@ -158,6 +159,9 @@ export class DaemonCore {
       this.herdrThreadSurfaces.delete(threadId);
       this.ghosttyThreadSurfaces.delete(threadId);
     }
+    this.harnessState.deleteOrphanedThreadState(
+      new Set(this.store.list().map((session) => session.id)),
+    );
     this.diffWatcher = new DiffWatcher((repoRoot) => void this.refreshDiffsForRepo(repoRoot));
     this.prPoller = new PrReviewPoller((sessionId, refs) =>
       this.markPrRefreshAvailable(sessionId, refs),
@@ -377,7 +381,7 @@ export class DaemonCore {
         if (waiterIndex !== -1) list.splice(waiterIndex, 1);
         resolve(null);
       }, timeoutMs);
-      const waiter = (session: Thread) => {
+      const waiter = (session: Thread | null) => {
         if (done) return;
         done = true;
         clearTimeout(timer);
@@ -656,7 +660,7 @@ export class DaemonCore {
     return session;
   }
 
-  /** Remove a session for good (inbox delete); resolved or pending, both go. */
+  /** Remove a Thread and all local state that refers to it. */
   sessionDelete(id: string): void {
     const session = this.store.get(id);
 
@@ -665,6 +669,12 @@ export class DaemonCore {
     this.diffRefreshGenerations.delete(id);
     this.herdrThreadSurfaces.delete(id);
     this.ghosttyThreadSurfaces.delete(id);
+    this.harnessState.deleteThreadState(id);
+    const parked = this.waiters.get(id) ?? [];
+
+    this.waiters.delete(id);
+    for (const parkedWaiter of parked) parkedWaiter(null);
+    this.emit("session.deleted", id);
     this.emit("inbox.changed", id);
   }
 

package/src/harness-delivery.test.ts

@@ -66,6 +66,49 @@ describe("durable harness delivery", () => {
     expect(core().harnessBindingsForSession("pi", "pi-current")).toEqual([current]);
   });
 
+  test("Thread deletion removes pi, Codex, and Claude harness state", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const bindings = ["pi", "codex", "claude-code"].map((harness) =>
+      instance.harnessBind({
+        threadId: thread.id,
+        harness,
+        harnessSessionId: `${harness}-session`,
+      }),
+    );
+
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const deliveryId = instance.deliveryPending(bindings[0]!.id)[0]!.delivery.id;
+
+    instance.sessionDelete(thread.id);
+
+    for (const [index, harness] of ["pi", "codex", "claude-code"].entries()) {
+      expect(instance.harnessBindingsForSession(harness, `${harness}-session`)).toEqual([]);
+      expect(() => instance.harnessGetBinding(bindings[index]!.id)).toThrow("no harness binding");
+    }
+    expect(() => instance.deliveryAcknowledge(deliveryId)).toThrow("no delivery");
+  });
+
+  test("startup removes harness state orphaned by an older deletion", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "codex",
+      harnessSessionId: "codex-orphan",
+    });
+
+    first.sessionSendMessage(thread.id, "approved", "Ready.");
+    const deliveryId = first.deliveryPending(binding.id)[0]!.delivery.id;
+
+    first.store.delete(thread.id);
+    const restarted = core();
+
+    expect(restarted.harnessBindingsForSession("codex", "codex-orphan")).toEqual([]);
+    expect(() => restarted.harnessGetBinding(binding.id)).toThrow("no harness binding");
+    expect(() => restarted.deliveryAcknowledge(deliveryId)).toThrow("no delivery");
+  });
+
   test("redelivers after reload until the harness acknowledges the Message", () => {
     const first = core();
     const thread = createPlan(first);

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

@@ -57,6 +57,34 @@ describe("HarnessStateStore", () => {
     expect(store.bind(input)).toEqual(store.bind(input));
   });
 
+  test("deletes every harness binding and delivery for a Thread", () => {
+    const store = new HarnessStateStore(home);
+    const bindings = ["pi", "codex", "claude-code"].map((harness) =>
+      store.bind({ threadId: "ses_1", harness, harnessSessionId: `${harness}_1` }),
+    );
+    const deliveries = bindings.map((binding, index) =>
+      store.enqueue({ bindingId: binding.id, messageId: `msg_${index}` }),
+    );
+
+    expect(store.deleteThreadState("ses_1")).toBeTrue();
+    expect(store.deleteThreadState("ses_1")).toBeFalse();
+    const reloaded = new HarnessStateStore(home);
+
+    for (const binding of bindings) expect(reloaded.binding(binding.id)).toBeNull();
+    for (const delivery of deliveries) expect(reloaded.delivery(delivery.id)).toBeNull();
+  });
+
+  test("deletes state for Threads missing at startup", () => {
+    const store = new HarnessStateStore(home);
+
+    store.bind({ threadId: "ses_kept", harness: "pi", harnessSessionId: "pi_1" });
+    store.bind({ threadId: "ses_orphan", harness: "codex", harnessSessionId: "codex_1" });
+
+    expect(store.deleteOrphanedThreadState(new Set(["ses_kept"]))).toEqual(["ses_orphan"]);
+    expect(store.bindingsForSession("pi", "pi_1")).toHaveLength(1);
+    expect(store.bindingsForSession("codex", "codex_1")).toEqual([]);
+  });
+
   test("does not discard pending deliveries when persisted state is corrupt", () => {
     writeFileSync(harnessStatePath(home), "{broken");
 

package/src/harness-state-store.ts

@@ -54,6 +54,38 @@ export class HarnessStateStore {
     );
   }
 
+  deleteThreadState(threadId: string): boolean {
+    const bindingIds = new Set(
+      [...this.bindings.values()]
+        .filter((binding) => binding.threadId === threadId)
+        .map((binding) => binding.id),
+    );
+
+    return this.deleteBindingsAndDeliveries(bindingIds);
+  }
+
+  deleteOrphanedThreadState(existingThreadIds: ReadonlySet<string>): string[] {
+    const orphanedBindings = [...this.bindings.values()].filter(
+      (binding) => !existingThreadIds.has(binding.threadId),
+    );
+    const orphanedThreadIds = [...new Set(orphanedBindings.map((binding) => binding.threadId))];
+
+    this.deleteBindingsAndDeliveries(new Set(orphanedBindings.map((binding) => binding.id)));
+
+    return orphanedThreadIds;
+  }
+
+  private deleteBindingsAndDeliveries(bindingIds: ReadonlySet<string>): boolean {
+    if (bindingIds.size === 0) return false;
+    for (const bindingId of bindingIds) this.bindings.delete(bindingId);
+    for (const delivery of this.deliveries.values()) {
+      if (bindingIds.has(delivery.bindingId)) this.deliveries.delete(delivery.id);
+    }
+    this.persist();
+
+    return true;
+  }
+
   consumeApprovedRetry(bindingId: string, messageId: string): boolean {
     const binding = this.bindings.get(bindingId);