@cueloop/daemon 0.1.0-alpha.100 → 0.1.0-alpha.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.100",
+  "version": "0.1.0-alpha.101",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -37,14 +37,15 @@
     "./curate": "./src/curate.ts",
     "./sdk": "./src/daemon-sdk.ts",
     "./sdk-effect": "./src/daemon-sdk-effect.ts",
-    "./thread-subscription": "./src/thread-subscription.ts"
+    "./thread-subscription": "./src/thread-subscription.ts",
+    "./shared-agent-protocol": "./src/shared-agent-protocol.ts"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/extension-api": "0.1.0-alpha.100",
-    "@cueloop/schema": "0.1.0-alpha.100",
+    "@cueloop/extension-api": "0.1.0-alpha.101",
+    "@cueloop/schema": "0.1.0-alpha.101",
     "@pierre/diffs": "^1.5.1",
     "effect": "^4.0.0",
     "smol-toml": "^1.9.0",

package/src/operation-receipts.ts

@@ -87,5 +87,12 @@ export function findPromptOperationReceipt(
 }
 
 function promptOperationFingerprint(input: AgentPromptRequest): string {
-  return operationFingerprint([input.text, input.context ?? null, input.retry ?? null]);
+  return operationFingerprint([
+    input.text,
+    input.context ?? null,
+    input.retry ?? null,
+    input.commentId ?? null,
+    input.inputOnly ? "input" : null,
+    input.discussion ?? null,
+  ]);
 }

package/src/server.test.ts

@@ -526,3 +526,49 @@ describe("large payloads survive socket backpressure", () => {
     expect(listed.some((session) => session.id === created.id)).toBe(true);
   }, 15_000);
 });
+
+test("explicit daemon shutdown waits for the harness to release durable storage before exit", async () => {
+  client.close();
+  server.stop();
+  const closeStarted = Promise.withResolvers<void>();
+  const release = Promise.withResolvers<void>();
+  const exited = Promise.withResolvers<void>();
+  let didExit = false;
+
+  server = new DaemonServer({
+    home,
+    idleExitMs: 0,
+    onIdleExit: () => {
+      didExit = true;
+      exited.resolve();
+    },
+    threadAgent: {
+      enabled: true,
+      adapter: {
+        id: "pi",
+        label: "pi",
+        connect: () => ({
+          start: async () => "session",
+          prompt: async () => ({ outcome: "completed" }),
+          cancel() {},
+          permission() {},
+          close: async () => {
+            closeStarted.resolve();
+            await release.promise;
+          },
+        }),
+      },
+    },
+  });
+  server.start();
+  client = await DaemonClient.connect({ home });
+  const thread = await client.sessionCreate(WS, PLAN);
+
+  await client.agentPrompt({ id: thread.id, text: "Persist this" });
+  await client.shutdown();
+  await closeStarted.promise;
+  expect(didExit).toBe(false);
+  release.resolve();
+  await exited.promise;
+  expect(didExit).toBe(true);
+});

package/src/server.ts

@@ -45,8 +45,9 @@ interface Connection {
 type MethodHandler = (connection: Connection, request: Request) => Response["result"];
 
 export interface DaemonOptions {
-  threadAgent?: Pick<ThreadAgentOptions, "enabled" | "enabledForThread" | "adapter">;
+  threadAgent?: Pick<ThreadAgentOptions, "enabled" | "enabledForThread" | "adapter" | "adapters">;
   home?: string;
+  onEvent?: (event: import("./client").EventFrame) => void;
   idleExitMs?: number;
   onIdleExit?: () => void;
   version?: string;
@@ -73,8 +74,10 @@ export class DaemonServer {
   private readonly idleExitMs: number;
   private readonly onIdleExit: () => void;
   private readonly version: string;
+  private readonly onEvent?: (event: import("./client").EventFrame) => void;
 
   constructor(options: DaemonOptions = {}) {
+    this.onEvent = options.onEvent;
     this.home = options.home ?? cueloopHome();
     this.idleExitMs = options.idleExitMs ?? 15 * 60 * 1000;
     this.onIdleExit = options.onIdleExit ?? (() => process.exit(0));
@@ -86,6 +89,7 @@ export class DaemonServer {
       enabled: options.threadAgent?.enabled ?? false,
       enabledForThread: options.threadAgent?.enabledForThread,
       adapter: options.threadAgent?.adapter,
+      adapters: options.threadAgent?.adapters,
       getThread: (id) => this.core.sessionGet(id),
       tools: (thread): AgentHarnessTools => ({
         definitions: [
@@ -131,6 +135,7 @@ export class DaemonServer {
         call: async (name, input) => this.callAgentTool(thread.id, name, input),
       }),
       onChange: (id) => {
+        this.onEvent?.({ event: "agent.updated", sessionId: id });
         for (const connection of this.connections) {
           if (connection.subscribed && connection.role === "owner")
             connection.write(JSON.stringify({ event: "agent.updated", sessionId: id }) + "\n");
@@ -286,8 +291,28 @@ export class DaemonServer {
     return path;
   }
 
+  resumeAgents(): void {
+    for (const thread of this.core.sessionList({ status: "pending" })) {
+      if (!this.threadAgent.isEnabled(thread.id)) continue;
+      const state = this.threadAgent.get(thread.id);
+
+      if (
+        state.harness?.id === "pi" &&
+        state.submissions?.some((submission) => submission.status === "queued")
+      )
+        void this.threadAgent
+          .configure({ id: thread.id })
+          .catch((error) => console.error("[agent recovery]", error));
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    await this.threadAgent.dispose();
+    this.stop();
+  }
+
   stop(): void {
-    this.threadAgent.dispose();
+    void this.threadAgent.dispose().catch((error) => console.error("[agent shutdown]", error));
     this.core.dispose();
     if (this.lockFd === null) return;
     this.server?.stop(true);
@@ -300,6 +325,7 @@ export class DaemonServer {
   }
 
   private broadcast(event: DaemonEvent): void {
+    this.onEvent?.(event);
     const frame = JSON.stringify(event) + "\n";
 
     for (const connection of this.connections) if (connection.subscribed) connection.write(frame);
@@ -473,8 +499,9 @@ export class DaemonServer {
     },
     "daemon.shutdown": () => {
       setTimeout(() => {
-        this.stop();
-        this.onIdleExit();
+        void this.shutdown()
+          .then(() => this.onIdleExit())
+          .catch((error) => console.error("[agent shutdown]", error));
       }, 10);
 
       return {};
@@ -632,13 +659,16 @@ export class DaemonServer {
     "session.setShares": (_connection, request) => {
       const params = parseParams("session.setShares", request.params);
 
+      if (params.shares.some((link) => link.agentEnabled))
+        this.threadAgent.assertEnabled(params.id);
+
       return this.core.sessionSetShares(params.id, params.shares);
     },
-    "session.delete": (_connection, request) => {
+    "session.delete": async (_connection, request) => {
       const { id } = parseParams("session.delete", request.params);
 
+      await this.threadAgent.remove(id);
       this.core.sessionDelete(id);
-      this.threadAgent.remove(id);
 
       return {};
     },

package/src/shared-agent-protocol.ts

@@ -0,0 +1,30 @@
+import * as v from "valibot";
+import { ThreadRecordSchema, Params } from "./validate";
+import { AgentCommentSchema, ThreadAgentSchema } from "./thread-agent-validation";
+
+/** Both SSH endpoints validate relay frames before using owner or collaborator data. */
+export const SharedAgentRequestSchema = v.object({
+  author: v.string(),
+  params: v.object({
+    ...Params["agent.prompt"].entries,
+    operationId: v.pipe(v.string(), v.minLength(1), v.maxLength(128)),
+  }),
+  comment: v.optional(AgentCommentSchema),
+});
+
+/** A relay cannot carry executable configuration, credentials, or arbitrary daemon methods. */
+export const SharedAgentFrameSchema = v.variant("type", [
+  v.object({ type: v.literal("hello"), shareId: v.string() }),
+  v.object({
+    type: v.literal("requests"),
+    thread: ThreadRecordSchema,
+    requests: v.array(SharedAgentRequestSchema),
+  }),
+  v.object({
+    type: v.literal("state"),
+    state: ThreadAgentSchema,
+    accepted: v.optional(v.array(v.string())),
+  }),
+]);
+
+export { ThreadAgentSchema, AgentCommentSchema } from "./thread-agent-validation";

package/src/thread-agent-validation.ts

@@ -32,6 +32,7 @@ const StoredAgentSchema = v.object({
   phase: v.variant("kind", [
     v.object({ kind: v.literal("idle") }),
     v.object({ kind: v.literal("running") }),
+    v.object({ kind: v.literal("offline") }),
     v.object({ kind: v.literal("failed"), error: v.string() }),
     v.object({
       kind: v.literal("permission"),
@@ -77,6 +78,7 @@ const StoredAgentSchema = v.object({
         commentId: v.optional(v.string()),
         messageId: v.optional(v.string()),
         prompt: v.string(),
+        harnessPrompt: v.optional(v.string()),
         quote: v.optional(v.string()),
         context: v.optional(v.string()),
         status: v.picklist(["queued", "running", "completed", "failed"]),

package/src/thread-agent.test.ts

@@ -410,3 +410,310 @@ test("retrying accepted work after a failed running-state save starts the harnes
     rmSync(home, { recursive: true, force: true });
   }
 });
+
+test("a shared plain input does not consume the owner's pending comments", () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-input-only-"));
+  const thread = createTestThread(home);
+  const adapter: AgentHarnessAdapter = {
+    id: "pi",
+    label: "pi",
+    connect: () => ({
+      start: () => new Promise(() => {}),
+      prompt: () => new Promise(() => {}),
+      cancel() {},
+      permission() {},
+      close() {},
+    }),
+  };
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter,
+    getThread: () => thread,
+    onChange() {},
+  });
+
+  thread.annotations = [
+    {
+      id: "owner-note",
+      author: "owner",
+      kind: "comment",
+      body: "Private draft",
+      anchor: { quote: "Review", prefix: "", suffix: " the retry" },
+      createdAt: "now",
+    },
+  ];
+  try {
+    const state = manager.prompt({
+      id: thread.id,
+      text: "Shared question",
+      operationId: "shared-input",
+      inputOnly: true,
+    });
+
+    expect(state.messages.map((entry) => entry.text)).toEqual(["Shared question"]);
+    expect(manager.isReadOnly(thread.id, "owner-note")).toBe(false);
+    expect(
+      manager.prompt({
+        id: thread.id,
+        text: "Shared question",
+        operationId: "shared-input",
+        inputOnly: true,
+      }).messages,
+    ).toHaveLength(1);
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("Pi recovery keeps the frozen harness input and submission identity after interruption", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-pi-recovery-"));
+  const thread = createTestThread(home);
+  const prompts: Array<{ text: string; id?: string }> = [];
+  let resumed = false;
+  const adapter: AgentHarnessAdapter = {
+    id: "pi",
+    label: "pi",
+    connect: ({ onEvent }) => ({
+      start: async () => "durable-session",
+      prompt: async (text, id) => {
+        prompts.push({ text, id });
+        if (!resumed) return new Promise(() => {});
+        onEvent({ kind: "message", id: "durable-answer", text: "Recovered answer", replace: true });
+
+        return { outcome: "completed" as const };
+      },
+      cancel() {},
+      permission() {},
+      close() {},
+    }),
+  };
+  const options = { home, enabled: true, adapter, getThread: () => thread, onChange() {} };
+  let manager = new ThreadAgentManager(options);
+
+  try {
+    manager.prompt({
+      id: thread.id,
+      text: "Recover",
+      operationId: "recover-input",
+      inputOnly: true,
+    });
+    for (let turn = 0; !prompts.length && turn < 100; turn++) await Bun.sleep(1);
+    await manager.dispose();
+    thread.artifact.content = "Changed artifact after admission";
+    resumed = true;
+    manager = new ThreadAgentManager(options);
+    expect(manager.get(thread.id).submissions?.[0]?.status).toBe("queued");
+    manager.prompt({
+      id: thread.id,
+      text: "Recover",
+      operationId: "recover-input",
+      inputOnly: true,
+    });
+    for (let turn = 0; manager.get(thread.id).phase.kind !== "idle" && turn < 100; turn++)
+      await Bun.sleep(1);
+    expect(prompts).toHaveLength(2);
+    expect(prompts[1]).toEqual(prompts[0]);
+    expect(manager.get(thread.id).messages.map((message) => message.text)).toEqual([
+      "Recover",
+      "Recovered answer",
+    ]);
+  } finally {
+    await manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("explicit shared comments execute the frozen payload and retain the original discussion", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-shared-frozen-"));
+  const thread = createTestThread(home);
+  const original = {
+    id: "root",
+    kind: "comment" as const,
+    body: "Original discussion",
+    anchor: { quote: "retry", prefix: "Review the ", suffix: "" },
+    createdAt: "now",
+  };
+
+  thread.annotations = [
+    original,
+    { ...original, id: "reply", replyTo: "root", body: "Later edited value" },
+  ];
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter: {
+      id: "pi",
+      label: "pi",
+      connect: () => ({
+        start: async () => "session",
+        prompt: async () => ({ outcome: "completed" }),
+        cancel() {},
+        close() {},
+        permission() {},
+      }),
+    },
+    getThread: () => thread,
+    onChange() {},
+  });
+
+  try {
+    const state = manager.prompt({
+      id: thread.id,
+      commentId: "reply",
+      operationId: "shared-frozen",
+      text: "Accepted reply",
+      context: "retry",
+      discussion: JSON.stringify({
+        discussion: [{ body: "Original discussion" }, { body: "Accepted reply" }],
+      }),
+    });
+
+    expect(state.submissions?.[0]?.prompt).toBe("Accepted reply");
+    expect(state.submissions?.[0]?.context).toContain("Original discussion");
+    expect(state.submissions?.[0]?.context).not.toContain("Later edited value");
+  } finally {
+    await manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("a failed connection finishes asynchronous close before the next queued turn opens storage", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-close-"));
+  const thread = createTestThread(home);
+  const closeStarted = Promise.withResolvers<void>();
+  const release = Promise.withResolvers<void>();
+  let connects = 0;
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    getThread: () => thread,
+    onChange() {},
+    adapter: {
+      id: "pi",
+      label: "pi",
+      connect: () => {
+        const first = ++connects === 1;
+
+        return {
+          start: async () => "session",
+          prompt: async () => {
+            if (first) throw new Error("Connection failed");
+
+            return { outcome: "completed" };
+          },
+          cancel() {},
+          permission() {},
+          close: async () => {
+            if (first) {
+              closeStarted.resolve();
+              await release.promise;
+            }
+          },
+        };
+      },
+    },
+  });
+
+  try {
+    manager.prompt({ id: thread.id, text: "First" });
+    manager.prompt({ id: thread.id, text: "Second" });
+    await closeStarted.promise;
+    expect(connects).toBe(1);
+    release.resolve();
+    for (
+      let attempt = 0;
+      manager.get(thread.id).submissions?.[1]?.status !== "completed" && attempt < 100;
+      attempt++
+    )
+      await Bun.sleep(1);
+    expect(connects).toBe(2);
+    expect(manager.get(thread.id).submissions?.[1]?.status).toBe("completed");
+  } finally {
+    release.resolve();
+    await manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("shutdown joins a failed turn that is already retiring its durable writer", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-retiring-"));
+  const thread = createTestThread(home);
+  const closeStarted = Promise.withResolvers<void>();
+  const release = Promise.withResolvers<void>();
+  let closed = false;
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    getThread: () => thread,
+    onChange() {},
+    adapter: {
+      id: "pi",
+      label: "pi",
+      connect: () => ({
+        start: async () => "session",
+        prompt: async () => {
+          throw new Error("Failed turn");
+        },
+        cancel() {},
+        permission() {},
+        close: async () => {
+          closeStarted.resolve();
+          await release.promise;
+          closed = true;
+        },
+      }),
+    },
+  });
+
+  try {
+    manager.prompt({ id: thread.id, text: "First" });
+    await closeStarted.promise;
+    const shutdown = manager.dispose();
+    let finished = false;
+
+    void shutdown.then(() => {
+      finished = true;
+    });
+    await Promise.resolve();
+    expect(finished).toBe(false);
+    release.resolve();
+    await shutdown;
+    expect(closed).toBe(true);
+  } finally {
+    release.resolve();
+    await manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("shutdown seals admission so a later configuration cannot open a new harness", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-sealed-"));
+  const thread = createTestThread(home);
+  let connects = 0;
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    getThread: () => thread,
+    onChange() {},
+    adapter: {
+      id: "pi",
+      label: "pi",
+      connect: () => {
+        connects++;
+
+        throw new Error("Must not connect after shutdown");
+      },
+    },
+  });
+
+  try {
+    await manager.dispose();
+    await expect(manager.configure({ id: thread.id })).rejects.toThrow("shutting down");
+    expect(() => manager.prompt({ id: thread.id, text: "Late input" })).toThrow("shutting down");
+    expect(connects).toBe(0);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/thread-agent.ts

@@ -35,6 +35,7 @@ export interface ThreadAgentOptions {
   enabled: boolean;
   enabledForThread?: (thread: Thread) => boolean;
   adapter?: AgentHarnessAdapter;
+  adapters?: Record<string, AgentHarnessAdapter>;
   getThread: (id: string) => Thread;
   onChange: (id: string) => void;
   tools?: (thread: Thread) => AgentHarnessTools;
@@ -49,10 +50,13 @@ interface ActiveAgent {
 
 /** Own harness processes and durable agent transcripts without mutating reviewed artifacts. */
 export class ThreadAgentManager {
+  private readonly deleting = new Set<string>();
+  private readonly retiring = new Map<string, Promise<void>>();
   private states = new Map<string, ThreadAgentState>();
   private active = new Map<string, ActiveAgent>();
   private readonly directory: string;
   private disposed = false;
+  private closing?: Promise<void>;
   private initializing = new Map<string, Promise<ActiveAgent>>();
 
   constructor(private readonly options: ThreadAgentOptions) {
@@ -68,6 +72,7 @@ export class ThreadAgentManager {
 
   /** Refuse agent API calls while its experimental flag is disabled. */
   assertEnabled(id: string): void {
+    if (this.disposed) throw new Error("Thread agent is shutting down");
     if (!this.isEnabled(id))
       throw new Error(
         "Thread agent is disabled; enable [experimental] thread_agent in config.toml",
@@ -76,7 +81,7 @@ export class ThreadAgentManager {
 
   /** Read a transcript without starting an agent or contacting a model. */
   get(id: string): ThreadAgentState {
-    this.options.getThread(id);
+    this.assertReadable(id);
     const cached = this.states.get(id);
 
     if (cached) return structuredClone(cached);
@@ -100,13 +105,16 @@ export class ThreadAgentManager {
       state.phase.kind === "permission" ||
       state.submissions?.some((entry) => entry.status === "queued" || entry.status === "running")
     ) {
-      state.phase = {
-        kind: "failed",
-        error: "Agent was interrupted by a daemon restart. Send a message to resume.",
-      };
+      state.phase =
+        state.harness?.id === "pi"
+          ? { kind: "idle" }
+          : {
+              kind: "failed",
+              error: "Agent was interrupted by a daemon restart. Send a message to resume.",
+            };
       for (const submission of state.submissions ?? []) {
         if (submission.status === "running" || submission.status === "queued")
-          submission.status = "failed";
+          submission.status = state.harness?.id === "pi" ? "queued" : "failed";
       }
       for (const tool of state.tools) {
         if (tool.status === "pending" || tool.status === "in_progress") tool.status = "cancelled";
@@ -132,7 +140,7 @@ export class ThreadAgentManager {
     }
     if (!this.options.adapter) throw new Error("Thread agent harness is not configured");
     if (thread.status !== "pending") throw new Error("Thread agent review is already resolved");
-    assertHarnessIdentity(state, this.options.adapter);
+    assertHarnessIdentity(state, this.adapter(state));
     const before = structuredClone(state);
 
     try {
@@ -140,46 +148,12 @@ export class ThreadAgentManager {
       state.submissions ??= [];
       const submissions = state.submissions;
       const revision = thread.revisions.at(-1)?.revision ?? 1;
-      const enqueue = (input: Omit<AgentSubmission, "id" | "status">): void => {
-        if (
-          state.messages.length +
-            submissions.filter((entry) => entry.status === "queued" || entry.status === "running")
-              .length +
-            2 >
-          128
-        )
-          throw new Error("Thread agent prototype reached its 128-message limit");
-        if (
-          Buffer.byteLength(input.prompt) > 320_000 ||
-          Buffer.byteLength(input.quote ?? "") > 320_000
-        )
-          throw new Error("Thread agent input exceeds 320 KiB");
-        const used = state.messages.reduce(
-          (total, message) => total + Buffer.byteLength(message.text),
-          0,
-        );
-
-        if (used + Buffer.byteLength(input.prompt) > 2 * 1024 * 1024)
-          throw new Error("Thread agent input exceeds transcript limit");
-        const submission: AgentSubmission = {
-          ...input,
-          id: randomUUID(),
-          status: stepAgentSubmission("draft", "submit", true),
-        };
-
-        submission.commentId ??= submission.id;
-        submissions.push(submission);
-        state.messages.push({
-          id: submission.id,
-          submissionId: submission.id,
-          role: "user",
-          text: submission.prompt,
-          complete: true,
-          revision,
-        });
-      };
+      const enqueue = (input: Omit<AgentSubmission, "id" | "status">): void =>
+        this.enqueue(state, revision, input, promptMirrorIdentity(params));
 
-      if (params.retry) {
+      if (params.commentId) {
+        this.enqueueComment(state, thread, params.commentId, enqueue, params);
+      } else if (params.retry) {
         const submission = submissions.find((entry) => entry.id === params.retry);
 
         if (!submission || submission.status !== "failed")
@@ -189,41 +163,10 @@ export class ThreadAgentManager {
       } else {
         const accepted = new Set(submissions.map((entry) => entry.commentId));
 
-        for (const annotation of thread.annotations) {
-          if (!isPendingAgentInput(annotation, accepted)) continue;
-          const root =
-            thread.annotations.find(
-              (entry) => entry.id === (annotation.replyTo ?? annotation.id),
-            ) ?? annotation;
-          const discussion = thread.annotations.filter(
-            (entry) => entry.id === root.id || entry.replyTo === root.id,
-          );
-
-          enqueue({ commentId: annotation.id, prompt: annotation.body, quote: root.anchor.quote });
-          // The discussion snapshot is passed as context, while the mirror shows only the new comment.
-          const submission = submissions.at(-1)!;
-
-          submission.context = JSON.stringify({
-            target: root.target,
-            discussion: discussion.map((entry) => ({ id: entry.id, body: entry.body })),
-          });
-        }
-        for (const comment of state.comments.filter((entry) => !entry.sent)) {
-          enqueue({
-            commentId: comment.id,
-            prompt: comment.body,
-            quote: comment.anchor.quote,
-            messageId: comment.messageId,
-          });
-          const root = agentCommentRoot(state, comment.replyTo ?? comment.id) ?? comment;
-
-          submissions.at(-1)!.context = JSON.stringify({
-            discussion: [root, ...state.comments.filter((entry) => entry.replyTo === root.id)].map(
-              (entry) => ({ id: entry.id, body: entry.body }),
-            ),
-          });
-          comment.sent = true;
-        }
+        for (const annotation of pendingAgentAnnotations(thread, accepted, params.inputOnly))
+          this.enqueueComment(state, thread, annotation.id, enqueue);
+        for (const comment of state.comments.filter((entry) => !params.inputOnly && !entry.sent))
+          this.enqueueComment(state, thread, comment.id, enqueue);
         if (params.text.trim()) enqueue({ prompt: params.text.trim(), quote: params.context });
       }
       recordPromptOperation(state, before, params);
@@ -267,6 +210,7 @@ export class ThreadAgentManager {
 
       if (current.phase.kind !== "running" && current.phase.kind !== "permission")
         active.turn = stepAgentTurn(active.turn, "finished");
+      this.drain(state);
 
       return structuredClone(state);
     }
@@ -278,12 +222,79 @@ export class ThreadAgentManager {
     return structuredClone(state);
   }
 
+  private enqueueComment(
+    state: ThreadAgentState,
+    thread: Thread,
+    commentId: string,
+    enqueue: (input: Omit<AgentSubmission, "id" | "status">) => void,
+    frozen?: AgentPromptRequest,
+  ): void {
+    const annotation = thread.annotations.find((entry) => entry.id === commentId);
+    const comment = state.comments.find((entry) => entry.id === commentId);
+    const input = annotation ?? comment;
+
+    if (!input || state.submissions?.some((submission) => submission.commentId === commentId))
+      throw new Error("Shared agent comment is unavailable or already sent");
+    enqueue({
+      commentId,
+      prompt: frozen?.text ?? input.body,
+      quote: frozen?.context ?? input.anchor.quote,
+      messageId: comment?.messageId,
+      context: frozen?.discussion ?? commentDiscussion(state, thread, commentId),
+    });
+    if (comment) comment.sent = true;
+  }
+
+  private enqueue(
+    state: ThreadAgentState,
+    revision: number,
+    input: Omit<AgentSubmission, "id" | "status">,
+    operationId?: string,
+  ): void {
+    const submissions = state.submissions!;
+
+    if (
+      state.messages.length +
+        submissions.filter((entry) => entry.status === "queued" || entry.status === "running")
+          .length +
+        2 >
+      128
+    )
+      throw new Error("Thread agent prototype reached its 128-message limit");
+    if (Buffer.byteLength(input.prompt) > 320_000 || Buffer.byteLength(input.quote ?? "") > 320_000)
+      throw new Error("Thread agent input exceeds 320 KiB");
+    const used = state.messages.reduce(
+      (total, message) => total + Buffer.byteLength(message.text),
+      0,
+    );
+
+    if (used + Buffer.byteLength(input.prompt) > 2 * 1024 * 1024)
+      throw new Error("Thread agent input exceeds transcript limit");
+    const submission: AgentSubmission = {
+      ...input,
+      id: operationId ?? randomUUID(),
+      status: stepAgentSubmission("draft", "submit", true),
+    };
+
+    submission.commentId ??= submission.id;
+    submissions.push(submission);
+    state.messages.push({
+      id: submission.id,
+      submissionId: submission.id,
+      role: "user",
+      text: submission.prompt,
+      complete: true,
+      revision,
+    });
+  }
+
   private drain(state: ThreadAgentState): void {
     if (
       this.states.get(state.threadId) !== state ||
       state.phase.kind === "running" ||
       state.phase.kind === "permission" ||
-      this.disposed
+      this.disposed ||
+      this.retiring.has(state.threadId)
     )
       return;
     const submission = state.submissions?.find((entry) => entry.status === "queued");
@@ -295,21 +306,28 @@ export class ThreadAgentManager {
     state.phase = { kind: "running" };
     const thread = this.options.getThread(state.threadId);
     const revision = thread.revisions.at(-1)?.revision ?? 1;
-    const prompt = `You are assisting cueloop Thread ${thread.id}. Answer this input individually. Use cueloop tools when the user asks to reply to a comment or return feedback to the main session. A reply to a Changes comment must use its original annotation ID.
+    const prompt =
+      submission.harnessPrompt ??
+      `You are assisting cueloop Thread ${thread.id}. Answer this input individually. Use cueloop tools when the user asks to reply to a comment or return feedback to the main session. A reply to a Changes comment must use its original annotation ID.
 Reviewed artifact:
 ${thread.artifact.content.slice(0, 32768)}
 Conversation:
-${state.messages
-  .filter((entry) => entry.submissionId !== submission.id)
-  .map((entry) => `${entry.role}: ${entry.text}`)
-  .join("\n")
-  .slice(-65536)}
+${
+  this.adapter(state).id === "pi"
+    ? "Continued in the durable conversation."
+    : state.messages
+        .filter((entry) => entry.submissionId !== submission.id)
+        .map((entry) => `${entry.role}: ${entry.text}`)
+        .join("\n")
+        .slice(-65536)
+}
 Comment ID: ${submission.commentId ?? "none"}
 Quote: ${submission.quote ?? ""}
 Discussion context: ${submission.context ?? submission.messageId ?? ""}
 Input: ${submission.prompt}`;
 
     try {
+      submission.harnessPrompt = prompt;
       this.save(state);
     } catch (error) {
       // Acceptance is already durable; a retry can resume the queue before any harness request.
@@ -423,22 +441,53 @@ Input: ${submission.prompt}`;
   }
 
   /** Daemon shutdown owns process cleanup; closing a client does not stop a turn. */
-  dispose(): void {
+  dispose(): Promise<void> {
     this.disposed = true;
-    for (const active of this.active.values()) active.connection.close();
-    this.active.clear();
+    this.closing ??= Promise.all(
+      [...this.active.values()]
+        .map((active) => active.connection.close())
+        .concat([...this.retiring.values()]),
+    ).then(() => {
+      this.active.clear();
+    });
+
+    return this.closing;
   }
 
   /** Deleting a Thread also stops its process and removes its private transcript. */
-  remove(id: string): void {
-    const active = this.active.get(id);
+  async remove(id: string): Promise<void> {
+    const state = this.mutable(id);
 
-    this.active.delete(id);
+    this.deleting.add(id);
     this.states.delete(id);
-    active?.connection.close();
-    rmSync(this.path(id), { force: true });
-    rmSync(this.path(id) + ".tmp", { force: true });
-    rmSync(join(this.directory, `${encodeURIComponent(id)}.diagnostics.ndjson`), { force: true });
+    try {
+      await this.retiring.get(id);
+      const active = this.active.get(id);
+
+      this.active.delete(id);
+      active?.connection.cancel();
+      await active?.connection.close();
+      if (state.harness?.sessionId) await this.adapter(state).remove?.(state.harness.sessionId);
+      rmSync(this.path(id), { force: true });
+      rmSync(this.path(id) + ".tmp", { force: true });
+      rmSync(join(this.directory, `${encodeURIComponent(id)}.diagnostics.ndjson`), { force: true });
+    } finally {
+      this.deleting.delete(id);
+    }
+  }
+
+  private adapter(state: ThreadAgentState): AgentHarnessAdapter {
+    const adapter =
+      (state.harness && this.options.adapters?.[state.harness.id]) ?? this.options.adapter;
+
+    if (!adapter) throw new Error("Thread agent harness is not configured");
+
+    return adapter;
+  }
+
+  private assertReadable(id: string): void {
+    if (this.deleting.has(id)) throw new Error("Thread agent is being deleted");
+    this.options.getThread(id);
   }
 
   private mutable(id: string): ThreadAgentState {
@@ -478,6 +527,7 @@ Input: ${submission.prompt}`;
 
     try {
       active = await this.connect(state, thread, turnId, revision);
+      if (this.states.get(state.threadId) !== state) return;
       active.turnId = turnId;
       active.revision = revision;
       // Cancellation during initialization must not submit a new model request.
@@ -489,8 +539,9 @@ Input: ${submission.prompt}`;
 
         return;
       }
-      const result = await active.connection.prompt(prompt);
+      const result = await active.connection.prompt(prompt, turnId);
 
+      if (this.states.get(state.threadId) !== state) return;
       finalizeAgentMessages(state, messageStart, result.outcome);
       if (submission && result.outcome === "cancelled") submission.cancelled = true;
       if (submission)
@@ -513,21 +564,41 @@ Input: ${submission.prompt}`;
         kind: "failed",
         error: error instanceof Error ? error.message : "Thread agent request failed",
       };
-      this.active.delete(state.threadId);
-      active?.connection.close();
-      if (!this.disposed) {
+      await this.retire(state.threadId, active);
+      if (!this.disposed && this.states.get(state.threadId) === state) {
         this.save(state);
         this.drain(state);
       }
     }
   }
 
+  private retire(id: string, active = this.active.get(id)): Promise<void> {
+    const existing = this.retiring.get(id);
+
+    if (existing) return existing;
+    this.active.delete(id);
+    const closing = Promise.resolve()
+      .then(() => active?.connection.close())
+      .catch((error) => console.error("[agent cleanup]", error))
+      .finally(() => {
+        this.retiring.delete(id);
+      });
+
+    this.retiring.set(id, closing);
+
+    return closing;
+  }
+
   private async connect(
     state: ThreadAgentState,
     thread: Thread,
     turnId: string,
     revision: number,
   ): Promise<ActiveAgent> {
+    const retiring = this.retiring.get(state.threadId);
+
+    if (retiring) await retiring;
+    if (this.disposed) throw new Error("Thread agent is shutting down");
     const pending = this.initializing.get(state.threadId);
 
     if (pending) return pending;
@@ -550,7 +621,8 @@ Input: ${submission.prompt}`;
     let active = this.active.get(state.threadId);
 
     if (!active) {
-      const connection = this.options.adapter!.connect({
+      const adapter = this.adapter(state);
+      const connection = adapter.connect({
         cwd: thread.artifact.meta.cwd ?? thread.workspace.repoRoot,
         sessionId: state.harness?.sessionId,
         tools: this.options.tools?.(thread),
@@ -569,9 +641,10 @@ Input: ${submission.prompt}`;
       this.active.set(state.threadId, active);
       const sessionId = await connection.start();
 
+      if (this.states.get(state.threadId) !== state) throw new Error("Thread agent was removed");
       state.harness = {
-        id: this.options.adapter!.id,
-        label: this.options.adapter!.label,
+        id: adapter.id,
+        label: adapter.label,
         sessionId,
       };
       active.turn = stepAgentTurn(active.turn, "ready");
@@ -646,7 +719,17 @@ Input: ${submission.prompt}`;
         Math.min(320_000 - Buffer.byteLength(message.text), 2 * 1024 * 1024 - used),
       );
 
-      message.text += Buffer.from(update.text).subarray(0, budget).toString("utf8");
+      message.text = update.replace
+        ? Buffer.from(update.text)
+            .subarray(
+              0,
+              Math.max(
+                0,
+                Math.min(320_000, 2 * 1024 * 1024 - used + Buffer.byteLength(message.text)),
+              ),
+            )
+            .toString("utf8")
+        : message.text + Buffer.from(update.text).subarray(0, budget).toString("utf8");
     } else {
       let tool = state.tools.find((tool) => tool.id === update.id && tool.turnId === active.turnId);
 
@@ -711,3 +794,42 @@ function assertHarnessIdentity(state: ThreadAgentState, adapter: AgentHarnessAda
   if (state.harness && state.harness.id !== adapter.id)
     throw new Error("Thread agent belongs to a different harness; create a new Thread");
 }
+
+function promptMirrorIdentity(params: AgentPromptRequest): string | undefined {
+  return params.inputOnly ? params.operationId : undefined;
+}
+
+function pendingAgentAnnotations(
+  thread: Thread,
+  accepted: Set<string | undefined>,
+  inputOnly?: boolean,
+) {
+  return inputOnly
+    ? []
+    : thread.annotations.filter((annotation) => isPendingAgentInput(annotation, accepted));
+}
+
+function commentDiscussion(state: ThreadAgentState, thread: Thread, commentId: string): string {
+  const annotation = thread.annotations.find((entry) => entry.id === commentId);
+
+  if (annotation) {
+    const root =
+      thread.annotations.find((entry) => entry.id === (annotation.replyTo ?? annotation.id)) ??
+      annotation;
+
+    return JSON.stringify({
+      target: root.target,
+      discussion: thread.annotations
+        .filter((entry) => entry.id === root.id || entry.replyTo === root.id)
+        .map((entry) => ({ id: entry.id, body: entry.body })),
+    });
+  }
+  const comment = agentCommentRoot(state, commentId)!;
+  const root = agentCommentRoot(state, comment.replyTo ?? comment.id) ?? comment;
+
+  return JSON.stringify({
+    discussion: [root, ...state.comments.filter((entry) => entry.replyTo === root.id)].map(
+      (entry) => ({ id: entry.id, body: entry.body }),
+    ),
+  });
+}

package/src/validate.ts

@@ -188,6 +188,7 @@ export const ShareLinkSchema = v.object({
   name: v.optional(v.string()),
   requireAuth: v.boolean(),
   allowlist: v.array(NonEmpty),
+  agentEnabled: v.optional(v.boolean()),
   owner: v.optional(v.string()),
   shareBranch: v.optional(v.string()),
 } satisfies EntriesOf<ShareLink>);
@@ -222,6 +223,9 @@ export const Params = {
     text: v.pipe(v.string(), v.maxLength(65_536)),
     context: v.optional(v.pipe(v.string(), v.maxLength(32_768))),
     retry: v.optional(NonEmpty),
+    commentId: v.optional(NonEmpty),
+    inputOnly: v.optional(v.boolean()),
+    discussion: v.optional(v.pipe(v.string(), v.maxLength(320_000))),
     operationId: v.optional(v.pipe(NonEmpty, v.maxLength(128))),
   }),
   "agent.reply": v.object({