@cueloop/daemon 0.1.0-alpha.102 → 0.1.0-alpha.103

package/src/single-instance.test.ts

@@ -213,6 +213,7 @@ describe("one daemon per home", () => {
       expect(existsSync(path!)).toBe(true);
     } finally {
       client.close();
+
       if (previousTimeout === undefined) delete process.env.CUELOOP_START_TIMEOUT_MS;
       else process.env.CUELOOP_START_TIMEOUT_MS = previousTimeout;
     }
@@ -242,7 +243,9 @@ describe("one daemon per home", () => {
       expect((await client.ping()).pid).toBe(process.pid);
     } finally {
       client.close();
+
       if (transient.listening) transient.close();
+
       if (previousTimeout === undefined) delete process.env.CUELOOP_START_TIMEOUT_MS;
       else process.env.CUELOOP_START_TIMEOUT_MS = previousTimeout;
     }

package/src/store.ts

@@ -85,8 +85,10 @@ export class ThreadStore implements ThreadRepository {
       const bucketPath = join(root, bucket);
 
       if (!statSync(bucketPath).isDirectory()) continue;
+
       for (const file of readdirSync(bucketPath)) {
         if (!file.endsWith(".jsonl")) continue;
+
         const filePath = join(bucketPath, file);
 
         try {
@@ -96,6 +98,7 @@ export class ThreadStore implements ThreadRepository {
           this.files.set(session.id, filePath);
           this.lineCounts.set(session.id, lines);
           report.recovered.push(session.id);
+
           // a torn trailing fragment would fuse with the next append and lose that update, so rewrite
           // the log to a single clean snapshot line now that the last valid record is in hand
           if (torn) this.writeWhole(session);
@@ -117,10 +120,12 @@ export class ThreadStore implements ThreadRepository {
     const legacyDir = sessionsDir(this.home);
 
     if (!existsSync(legacyDir)) return;
+
     const parked = migratedSessionsDir(this.home);
 
     for (const file of readdirSync(legacyDir)) {
       if (!file.endsWith(".json")) continue;
+
       const legacyPath = join(legacyDir, file);
       let session: Thread;
 
@@ -128,6 +133,7 @@ export class ThreadStore implements ThreadRepository {
         const parsed = validateThreadRecord(JSON.parse(readFileSync(legacyPath, "utf8")));
 
         if (!parsed.ok) throw new Error(`invalid record - ${parsed.error}`);
+
         session = withHistory(parsed.value);
       } catch (error) {
         report.skipped.push({
@@ -144,6 +150,7 @@ export class ThreadStore implements ThreadRepository {
       // after a rollback a newer JSONL can already hold this thread; never overwrite it with the
       // older legacy snapshot - the existing log stays authoritative and the threads scan recovers it
       if (!existsSync(targetPath)) this.writeWhole(session);
+
       // forget the in-memory tracking migration seeded: the threads scan is the one recovery path
       this.files.delete(session.id);
       this.lineCounts.delete(session.id);
@@ -192,6 +199,7 @@ export class ThreadStore implements ThreadRepository {
 
       return;
     }
+
     appendFileSync(filePath, JSON.stringify(session) + "\n");
     this.lineCounts.set(session.id, lines + 1);
     this.sessions.set(session.id, session);
@@ -199,9 +207,11 @@ export class ThreadStore implements ThreadRepository {
 
   delete(id: string): boolean {
     if (!this.sessions.delete(id)) return false;
+
     const filePath = this.files.get(id);
 
     if (filePath) rmSync(filePath, { force: true });
+
     this.files.delete(id);
     this.lineCounts.delete(id);
 
@@ -261,6 +271,7 @@ export class MemoryThreadStore implements ThreadRepository {
 
         return;
       }
+
       const session = withHistory(parsed.value);
 
       this.sessions.set(session.id, session);

package/src/thread-agent-validation.ts

@@ -79,6 +79,7 @@ const StoredAgentSchema = v.object({
         messageId: v.optional(v.string()),
         prompt: v.string(),
         harnessPrompt: v.optional(v.string()),
+        attemptId: v.optional(v.string()),
         quote: v.optional(v.string()),
         context: v.optional(v.string()),
         status: v.picklist(["queued", "running", "completed", "failed"]),
@@ -96,6 +97,25 @@ const StoredAgentSchema = v.object({
       }),
     ),
   ),
+  continuation: v.optional(v.string()),
+  handoff: v.optional(
+    v.intersect([
+      v.object({
+        target: v.string(),
+        requestedTarget: v.optional(v.string()),
+        operationId: v.string(),
+        prompt: v.optional(v.string()),
+        source: v.optional(
+          v.object({ id: v.string(), label: v.string(), sessionId: v.optional(v.string()) }),
+        ),
+      }),
+      v.variant("status", [
+        v.object({ status: v.literal("queued") }),
+        v.object({ status: v.literal("summarizing") }),
+        v.object({ status: v.literal("prepared"), text: v.string() }),
+      ]),
+    ]),
+  ),
   configOptions: v.optional(
     v.array(
       v.object({

package/src/thread-agent.test.ts

@@ -416,6 +416,7 @@ test("a shared plain input does not consume the owner's pending comments", () =>
   const thread = createTestThread(home);
   const adapter: AgentHarnessAdapter = {
     id: "pi",
+    recovery: "durable",
     label: "pi",
     connect: () => ({
       start: () => new Promise(() => {}),
@@ -474,12 +475,19 @@ test("Pi recovery keeps the frozen harness input and submission identity after i
   let resumed = false;
   const adapter: AgentHarnessAdapter = {
     id: "pi",
+    recovery: "durable",
     label: "pi",
     connect: ({ onEvent }) => ({
       start: async () => "durable-session",
       prompt: async (text, id) => {
         prompts.push({ text, id });
-        if (!resumed) return new Promise(() => {});
+
+        if (!resumed) {
+          onEvent({ kind: "message", id: "durable-answer", text: "Partial reply", replace: true });
+
+          return new Promise(() => {});
+        }
+
         onEvent({ kind: "message", id: "durable-answer", text: "Recovered answer", replace: true });
 
         return { outcome: "completed" as const };
@@ -515,6 +523,7 @@ test("Pi recovery keeps the frozen harness input and submission identity after i
       await Bun.sleep(1);
     expect(prompts).toHaveLength(2);
     expect(prompts[1]).toEqual(prompts[0]);
+    expect(manager.get(thread.id).messages.at(-1)?.complete).toBe(true);
     expect(manager.get(thread.id).messages.map((message) => message.text)).toEqual([
       "Recover",
       "Recovered answer",
@@ -545,6 +554,7 @@ test("explicit shared comments execute the frozen payload and retain the origina
     enabled: true,
     adapter: {
       id: "pi",
+      recovery: "durable",
       label: "pi",
       connect: () => ({
         start: async () => "session",
@@ -592,6 +602,7 @@ test("a failed connection finishes asynchronous close before the next queued tur
     onChange() {},
     adapter: {
       id: "pi",
+      recovery: "durable",
       label: "pi",
       connect: () => {
         const first = ++connects === 1;
@@ -650,6 +661,7 @@ test("shutdown joins a failed turn that is already retiring its durable writer",
     onChange() {},
     adapter: {
       id: "pi",
+      recovery: "durable",
       label: "pi",
       connect: () => ({
         start: async () => "session",
@@ -699,6 +711,7 @@ test("shutdown seals admission so a later configuration cannot open a new harnes
     onChange() {},
     adapter: {
       id: "pi",
+      recovery: "durable",
       label: "pi",
       connect: () => {
         connects++;