@cueloop/daemon 0.1.0-alpha.98 → 0.1.0-alpha.99

package/src/sdk-identities.ts

@@ -0,0 +1,35 @@
+import * as v from "valibot";
+
+const ThreadIdSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(128), v.brand("SdkThreadId"));
+const OperationIdSchema = v.pipe(
+  v.string(),
+  v.minLength(1),
+  v.maxLength(128),
+  v.brand("SdkOperationId"),
+);
+const SubmissionIdSchema = v.pipe(
+  v.string(),
+  v.minLength(1),
+  v.maxLength(128),
+  v.brand("SdkSubmissionId"),
+);
+
+/** Thread, operation and submission IDs share a wire representation, not a domain type. */
+export type SdkThreadId = v.InferOutput<typeof ThreadIdSchema>;
+/** Operation IDs are caller-owned and persist across explicit retries. */
+export type SdkOperationId = v.InferOutput<typeof OperationIdSchema>;
+/** Submission IDs are minted by the daemon after accepting agent input. */
+export type SdkSubmissionId = v.InferOutput<typeof SubmissionIdSchema>;
+
+/** External Thread identities must be nonempty and at most 128 characters. */
+export function createSdkThreadId(value: string): SdkThreadId {
+  return v.parse(ThreadIdSchema, value);
+}
+/** Caller operation identities are stable across retries and at most 128 characters. */
+export function createSdkOperationId(value: string): SdkOperationId {
+  return v.parse(OperationIdSchema, value);
+}
+/** Submission identities are daemon-minted; parsing grants no capability. */
+export function createSdkSubmissionId(value: string): SdkSubmissionId {
+  return v.parse(SubmissionIdSchema, value);
+}

package/src/server.ts

@@ -353,6 +353,7 @@ export class DaemonServer {
   private async callAgentTool(threadId: string, name: string, input: string): Promise<string> {
     const args = parseAgentToolInput(name, input);
     const origin = this.core.sessionGet(threadId);
+
     assertAgentToolScope(origin, args);
     if (args.kind === "api" && args.method === "session.list") {
       const { filter } = parseParams("session.list", args.params);
@@ -362,8 +363,8 @@ export class DaemonServer {
     if (args.kind === "reply") {
       const thread = origin;
       const comment = thread.annotations.find((entry) => entry.id === args.commentId);
-      if (!comment)
-        return JSON.stringify(this.threadAgent.reply(args.id, args.commentId, args.body));
+
+      if (!comment) return JSON.stringify(this.replyAgentComment(args));
       const root =
         thread.annotations.find((entry) => entry.id === (comment.replyTo ?? comment.id)) ?? comment;
 
@@ -384,6 +385,7 @@ export class DaemonServer {
       );
     }
     const method = args.method;
+
     if (!isKnownMethod(method)) throw new Error("Thread agent tool API method is unavailable");
 
     return JSON.stringify(
@@ -394,35 +396,62 @@ export class DaemonServer {
     );
   }
 
+  private replyAgentComment(params: {
+    id: string;
+    commentId: string;
+    body: string;
+  }): ReturnType<ThreadAgentManager["reply"]> {
+    this.threadAgent.assertEnabled(params.id);
+
+    return this.threadAgent.reply(params.id, params.commentId, params.body);
+  }
+
   private readonly handlers: Record<MethodName, MethodHandler> = {
     "agent.configure": (_connection, request) => {
       const params = parseParams("agent.configure", request.params);
+
       this.threadAgent.assertEnabled(params.id);
+
       return this.threadAgent.configure(params);
     },
     "agent.get": (_connection, request) => {
       const { id } = parseParams("agent.get", request.params);
+
       this.threadAgent.assertEnabled(id);
+
       return this.threadAgent.get(id);
     },
     "agent.prompt": (_connection, request) => {
       const params = parseParams("agent.prompt", request.params);
+
       this.threadAgent.assertEnabled(params.id);
+
       return this.threadAgent.prompt(params);
     },
     "agent.cancel": (_connection, request) => {
       const { id } = parseParams("agent.cancel", request.params);
+
       this.threadAgent.assertEnabled(id);
+
       return this.threadAgent.cancel(id);
     },
+    "agent.reply": (_connection, request) => {
+      const params = parseParams("agent.reply", request.params);
+
+      return this.replyAgentComment(params);
+    },
     "agent.comment": (_connection, request) => {
       const params = parseParams("agent.comment", request.params);
+
       this.threadAgent.assertEnabled(params.id);
+
       return this.threadAgent.comment(params);
     },
     "agent.permission": (_connection, request) => {
       const params = parseParams("agent.permission", request.params);
+
       this.threadAgent.assertEnabled(params.id);
+
       return this.threadAgent.permission(params);
     },
     "daemon.ping": () => ({ pid: process.pid, version: this.version }),
@@ -645,6 +674,7 @@ export class DaemonServer {
         params.outcome,
         params.summary,
         params.actionBodies,
+        params.operationId,
       );
     },
     "harness.bind": (_connection, request) => {

package/src/share-blob.ts

@@ -25,7 +25,9 @@ export const DEFAULT_SHARE_PORT = 22;
 
 /** Serialise + compress a session for upload. */
 export function packSessionBlob(session: Thread): Buffer {
-  return gzipSync(Buffer.from(JSON.stringify(session), "utf8"));
+  const { messageOperations: _privateReceipts, ...shared } = session;
+
+  return gzipSync(Buffer.from(JSON.stringify(shared), "utf8"));
 }
 
 /** Decompress + validate an uploaded blob, or throw a precise reason. */

package/src/store.jsonl.test.ts

@@ -28,6 +28,7 @@ describe("JSONL thread store", () => {
   test("a thread is written under a per-project bucket keyed by root commit", () => {
     const home = tmpHome();
     const store = new ThreadStore(home);
+
     store.recover();
     store.upsert(
       createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z", {
@@ -36,6 +37,7 @@ describe("JSONL thread store", () => {
     );
 
     const bucket = threadBucket("abcdef0123456789", home);
+
     expect(readdirSync(bucket)).toContain("ses_a.jsonl");
   });
 
@@ -52,6 +54,7 @@ describe("JSONL thread store", () => {
   test("a repo-less thread lands in the standalone bucket", () => {
     const home = tmpHome();
     const store = new ThreadStore(home);
+
     store.recover();
     store.upsert(createTestThreadRecord("ses_s", "2026-09-01T00:00:00.000Z"));
 
@@ -60,8 +63,10 @@ describe("JSONL thread store", () => {
 
   test("boot migrates the old whole-record file and parks the original", () => {
     const home = tmpHome();
+
     mkdirSync(sessionsDir(home), { recursive: true });
     const legacy = createTestThreadRecord("ses_old", "2026-09-01T00:00:00.000Z");
+
     writeFileSync(join(sessionsDir(home), "ses_old.json"), JSON.stringify(legacy));
 
     const store = new ThreadStore(home);
@@ -80,6 +85,7 @@ describe("JSONL thread store", () => {
     const home = tmpHome();
     // a newer JSONL already holds this thread (e.g. written after a rollback)
     const store = new ThreadStore(home);
+
     store.recover();
     store.upsert(
       createTestThreadRecord("ses_x", "2026-09-01T00:00:00.000Z", {
@@ -99,6 +105,7 @@ describe("JSONL thread store", () => {
     );
 
     const reopened = new ThreadStore(home);
+
     reopened.recover();
     // the newer JSONL wins; the legacy snapshot is parked, not applied
     expect(reopened.get("ses_x")?.workspace.branch).toBe("newer");
@@ -108,6 +115,7 @@ describe("JSONL thread store", () => {
   test("a long log compacts to a single line, and the record survives it", () => {
     const home = tmpHome();
     const store = new ThreadStore(home);
+
     store.recover();
     // more upserts than the compaction threshold
     for (let iteration = 0; iteration < 60; iteration++) {
@@ -123,9 +131,11 @@ describe("JSONL thread store", () => {
     const lines = readFileSync(file, "utf8")
       .split("\n")
       .filter((l) => l.trim());
+
     expect(lines.length).toBeLessThan(60);
     // the latest snapshot survives the compaction and a restart
     const reopened = new ThreadStore(home);
+
     reopened.recover();
     expect(reopened.get("ses_a")?.workspace.branch).toBe("b59");
   });
@@ -133,15 +143,18 @@ describe("JSONL thread store", () => {
   test("a crash's torn trailing line is skipped; the last valid snapshot wins", () => {
     const home = tmpHome();
     const store = new ThreadStore(home);
+
     store.recover();
     store.upsert(createTestThreadRecord("ses_a", "2026-09-01T00:00:00.000Z"));
 
     // simulate a crash mid-append: a half-written line at the end
     const file = join(threadBucket(undefined, home), "ses_a.jsonl");
+
     appendFileSync(file, '{"id":"ses_a","half');
 
     const reopened = new ThreadStore(home);
     const report = reopened.recover();
+
     expect(report.recovered).toEqual(["ses_a"]);
     expect(reopened.get("ses_a")?.id).toBe("ses_a");
 
@@ -153,6 +166,7 @@ describe("JSONL thread store", () => {
       }),
     );
     const restarted = new ThreadStore(home);
+
     restarted.recover();
     expect(restarted.get("ses_a")?.workspace.branch).toBe("after-tear");
   });

package/src/store.ts

@@ -94,6 +94,7 @@ export class ThreadStore implements ThreadRepository {
       for (const file of readdirSync(bucketPath)) {
         if (!file.endsWith(".jsonl")) continue;
         const filePath = join(bucketPath, file);
+
         try {
           const { session, lines, torn } = readThread(filePath);
 
@@ -181,19 +182,25 @@ export class ThreadStore implements ThreadRepository {
   }
 
   upsert(session: Thread): void {
-    this.sessions.set(session.id, session);
     const filePath = this.files.get(session.id);
     const lines = this.lineCounts.get(session.id) ?? 0;
 
     // the first write, an over-long log, and a resolved (now immutable) thread all compact to one
     // line; every other mutation is a cheap append that a torn tail on crash simply drops on read
-    if (filePath === undefined || lines >= COMPACT_THRESHOLD || session.status === "resolved") {
+    if (
+      filePath === undefined ||
+      lines >= COMPACT_THRESHOLD ||
+      session.status === "resolved" ||
+      session.messageOperations?.length
+    ) {
       this.writeWhole(session);
+      this.sessions.set(session.id, session);
 
       return;
     }
     appendFileSync(filePath, JSON.stringify(session) + "\n");
     this.lineCounts.set(session.id, lines + 1);
+    this.sessions.set(session.id, session);
   }
 
   delete(id: string): boolean {
@@ -290,9 +297,11 @@ export class MemoryThreadStore implements ThreadRepository {
 export type SessionRepository = ThreadRepository;
 /** @deprecated use ThreadStore */
 export const SessionStore = ThreadStore;
+
 /** @deprecated use ThreadStore */
 export type SessionStore = ThreadStore;
 /** @deprecated use MemoryThreadStore */
 export const MemorySessionStore = MemoryThreadStore;
+
 /** @deprecated use MemoryThreadStore */
 export type MemorySessionStore = MemoryThreadStore;

package/src/thread-agent-validation.ts

@@ -80,6 +80,17 @@ const StoredAgentSchema = v.object({
         quote: v.optional(v.string()),
         context: v.optional(v.string()),
         status: v.picklist(["queued", "running", "completed", "failed"]),
+        cancelled: v.optional(v.boolean()),
+      }),
+    ),
+  ),
+  promptOperations: v.optional(
+    v.array(
+      v.object({
+        operationId: v.string(),
+        fingerprint: v.string(),
+        result: v.array(v.string()),
+        outcome: v.optional(v.picklist(["completed", "failed", "cancelled"])),
       }),
     ),
   ),

package/src/thread-agent.test.ts

@@ -72,10 +72,13 @@ test("a non-ACP harness streams and resumes through the same Thread manager", as
     });
     expect(manager.get(thread.id).messages[1]?.text).toBe("Native answer");
     const promptDiscussion = { id: manager.get(thread.id).submissions![0]!.id };
+
     expect(manager.isReadOnly(thread.id, promptDiscussion.id)).toBe(true);
     const promptReply = manager.reply(thread.id, promptDiscussion.id, "The prompt is clear");
+
     expect(promptReply.comments.at(-1)?.replyTo).toBe(promptDiscussion.id);
     const answer = manager.get(thread.id).messages[1]!;
+
     manager.comment({
       id: thread.id,
       comment: {
@@ -87,6 +90,7 @@ test("a non-ACP harness streams and resumes through the same Thread manager", as
       },
     });
     const replied = manager.reply(thread.id, "answer-question", "This is the explanation");
+
     expect(replied.comments.at(-1)).toMatchObject({
       replyTo: "answer-question",
       messageId: answer.id,
@@ -305,3 +309,104 @@ test("rejected first batches leave originals editable and create no queued turn"
     rmSync(home, { recursive: true, force: true });
   }
 });
+
+test("prompt operation receipts survive restart without requeueing accepted inputs", () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-receipt-"));
+  const thread = createTestThread(home);
+  const adapter: AgentHarnessAdapter = {
+    id: "receipt-test",
+    label: "Receipt test",
+    connect: () => ({
+      start: async () => "session",
+      prompt: () => new Promise(() => {}),
+      cancel() {},
+      permission() {},
+      close() {},
+    }),
+  };
+  const options = { home, enabled: true, adapter, getThread: () => thread, onChange() {} };
+  let manager = new ThreadAgentManager(options);
+
+  try {
+    const input = { id: thread.id, text: "Once", operationId: "once" };
+    const accepted = manager.prompt(input);
+
+    manager.dispose();
+    manager = new ThreadAgentManager(options);
+    const replay = manager.prompt(input);
+
+    expect(replay.promptOperations?.[0]?.result).toEqual(accepted.promptOperations?.[0]?.result);
+    expect(replay.submissions).toHaveLength(1);
+    expect(replay.promptOperations?.[0]?.outcome).toBe("failed");
+    expect(() => manager.prompt({ ...input, text: "Different" })).toThrow(
+      "Operation payload conflict",
+    );
+    manager.prompt({
+      id: thread.id,
+      text: "",
+      retry: replay.submissions![0]!.id,
+      operationId: "retry",
+    });
+    expect(manager.get(thread.id).promptOperations?.[0]?.outcome).toBe("failed");
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("retrying accepted work after a failed running-state save starts the harness once", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-start-save-"));
+  const thread = createTestThread(home);
+  const blockedPath = join(home, "thread-agents", `${thread.id}.json.tmp`);
+  let saves = 0;
+  let prompts = 0;
+  const started = Promise.withResolvers<void>();
+  const adapter: AgentHarnessAdapter = {
+    id: "start-save-test",
+    label: "Start save test",
+    connect: () => ({
+      start: async () => "session",
+      prompt: () => {
+        prompts++;
+        started.resolve();
+
+        return new Promise(() => {});
+      },
+      cancel() {},
+      permission() {},
+      close() {},
+    }),
+  };
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter,
+    getThread: () => thread,
+    onChange() {
+      if (++saves === 1) mkdirSync(blockedPath);
+    },
+  });
+
+  try {
+    const input = { id: thread.id, text: "Start once", operationId: "start-once" };
+
+    expect(() => manager.prompt(input)).toThrow();
+    expect(manager.get(thread.id).phase.kind).toBe("idle");
+    expect(manager.get(thread.id).submissions?.[0]?.status).toBe("queued");
+    expect(prompts).toBe(0);
+    const acceptedIds = manager.get(thread.id).promptOperations?.[0]?.result;
+
+    rmSync(blockedPath, { recursive: true });
+    const replay = manager.prompt(input);
+
+    expect(replay.promptOperations?.[0]?.result).toEqual(acceptedIds);
+    expect(replay.submissions).toHaveLength(1);
+    await started.promise;
+    expect(prompts).toBe(1);
+    manager.prompt(input);
+    expect(prompts).toBe(1);
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/thread-agent.ts

@@ -9,6 +9,7 @@ import {
   stepAgentSubmission,
   isAgentNote,
   type AgentSubmission,
+  type AgentPromptRequest,
   type AgentHarnessTools,
   resolveAnchor,
   type AgentComment,
@@ -19,6 +20,11 @@ import {
   type AgentHarnessEvent,
   type AgentHarnessResult,
 } from "@cueloop/schema";
+import {
+  findPromptOperationReceipt,
+  recordPromptOperation,
+  settlePromptOperations,
+} from "./operation-receipts";
 import { writeHarnessDiagnostic } from "./harness-diagnostics";
 import { stepAgentTurn, agentTurnCancelled, type AgentTurn } from "./agent-turn";
 import { ThreadAgentSchema } from "./thread-agent-validation";
@@ -90,7 +96,11 @@ export class ThreadAgentManager {
         };
 
     if (state.threadId !== id) throw new Error("Thread agent record has the wrong thread identity");
-    if (state.phase.kind === "running" || state.phase.kind === "permission") {
+    if (
+      state.phase.kind === "running" ||
+      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.",
@@ -103,21 +113,29 @@ export class ThreadAgentManager {
         if (tool.status === "pending" || tool.status === "in_progress") tool.status = "cancelled";
       }
     }
+    settlePromptOperations(state);
     this.states.set(id, state);
 
     return structuredClone(state);
   }
 
   /** Freeze each pending comment once and queue an individual answer at the Thread tail. */
-  prompt(params: { id: string; text: string; context?: string; retry?: string }): ThreadAgentState {
+  prompt(params: AgentPromptRequest): ThreadAgentState {
     this.assertEnabled(params.id);
-    if (!this.options.adapter) throw new Error("Thread agent harness is not configured");
     const state = this.mutable(params.id);
     const thread = this.options.getThread(params.id);
+    const receipt = findPromptOperationReceipt(state, params);
+
+    if (receipt) {
+      this.drain(state);
 
+      return structuredClone(state);
+    }
+    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);
     const before = structuredClone(state);
+
     try {
       state.harness ??= { id: this.options.adapter.id, label: this.options.adapter.label };
       state.submissions ??= [];
@@ -141,6 +159,7 @@ export class ThreadAgentManager {
           (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 = {
@@ -166,9 +185,11 @@ export class ThreadAgentManager {
 
         if (!submission || submission.status !== "failed")
           throw new Error("Thread agent retry requires a failed submission");
+        delete submission.cancelled;
         submission.status = stepAgentSubmission(submission.status, "retry", true);
       } else {
         const accepted = new Set(submissions.map((entry) => entry.commentId));
+
         for (const annotation of thread.annotations) {
           if (!isPendingAgentInput(annotation, accepted)) continue;
           const root =
@@ -182,6 +203,7 @@ export class ThreadAgentManager {
           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 })),
@@ -195,6 +217,7 @@ export class ThreadAgentManager {
             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 }),
@@ -204,6 +227,7 @@ export class ThreadAgentManager {
         }
         if (params.text.trim()) enqueue({ prompt: params.text.trim(), quote: params.context });
       }
+      recordPromptOperation(state, before, params);
       this.save(state);
     } catch (error) {
       restoreAgentState(state, before);
@@ -231,14 +255,20 @@ export class ThreadAgentManager {
     if (!this.options.adapter) throw new Error("Thread agent harness is not configured");
     const state = this.mutable(params.id);
 
-    if (state.phase.kind === "running" || state.phase.kind === "permission")
+    if (state.phase.kind === "running" || state.phase.kind === "permission") {
+      // Discovery can read existing choices without reconfiguring an active turn.
+      if (params.configId === undefined || params.value === undefined)
+        return structuredClone(state);
       throw new Error("Thread agent configuration waits for the current turn");
+    }
     const active = await this.connect(state, this.options.getThread(params.id), "", 1);
 
     if (params.configId === undefined || params.value === undefined) {
       const current = this.get(params.id);
+
       if (current.phase.kind !== "running" && current.phase.kind !== "permission")
         active.turn = stepAgentTurn(active.turn, "finished");
+
       return structuredClone(state);
     }
     if (!active.connection.configure)
@@ -260,6 +290,8 @@ export class ThreadAgentManager {
     const submission = state.submissions?.find((entry) => entry.status === "queued");
 
     if (!submission) return;
+    const before = structuredClone(state);
+
     submission.status = stepAgentSubmission(submission.status, "start", true);
     state.phase = { kind: "running" };
     const thread = this.options.getThread(state.threadId);
@@ -278,7 +310,13 @@ Quote: ${submission.quote ?? ""}
 Discussion context: ${submission.context ?? submission.messageId ?? ""}
 Input: ${submission.prompt}`;
 
-    this.save(state);
+    try {
+      this.save(state);
+    } catch (error) {
+      // Acceptance is already durable; a retry can resume the queue before any harness request.
+      restoreAgentState(state, before);
+      throw error;
+    }
     void this.run(state, thread, submission.id, revision, prompt, [], submission);
   }
 
@@ -324,8 +362,10 @@ Input: ${submission.prompt}`;
   reply(id: string, commentId: string, body: string): ThreadAgentState {
     const state = this.mutable(id);
     const comment = agentCommentRoot(state, commentId);
+
     if (!comment) throw new Error("Thread agent reply comment does not exist");
     const root = agentCommentRoot(state, comment.replyTo ?? comment.id) ?? comment;
+
     if (state.comments.length >= 128)
       throw new Error("Thread agent prototype reached its comment limit");
     state.comments.push({
@@ -348,6 +388,9 @@ Input: ${submission.prompt}`;
 
     if (active && (state.phase.kind === "running" || state.phase.kind === "permission")) {
       active.turn = stepAgentTurn(active.turn, "stop");
+      const submission = state.submissions?.find((entry) => entry.status === "running");
+
+      if (submission) submission.cancelled = true;
       for (const tool of state.tools) {
         if (tool.status === "pending" || tool.status === "in_progress") tool.status = "cancelled";
       }
@@ -410,6 +453,7 @@ Input: ${submission.prompt}`;
   }
 
   private save(state: ThreadAgentState): void {
+    settlePromptOperations(state);
     if (this.states.get(state.threadId) !== state) return;
     const data = JSON.stringify(state);
 
@@ -449,6 +493,7 @@ Input: ${submission.prompt}`;
       const result = await active.connection.prompt(prompt);
 
       finalizeAgentMessages(state, messageStart, result.outcome);
+      if (submission && result.outcome === "cancelled") submission.cancelled = true;
       if (submission)
         submission.status = stepAgentSubmission(
           submission.status,
@@ -485,6 +530,7 @@ Input: ${submission.prompt}`;
     revision: number,
   ): Promise<ActiveAgent> {
     const pending = this.initializing.get(state.threadId);
+
     if (pending) return pending;
     const promise = this.startConnection(state, thread, turnId, revision);
 
@@ -551,6 +597,7 @@ Input: ${submission.prompt}`;
     if (event.kind === "config") {
       state.configOptions = event.options;
       this.save(state);
+
       return;
     }
     const active = this.active.get(state.threadId);
@@ -656,6 +703,7 @@ function isPendingAgentInput(
 
 function restoreAgentState(state: ThreadAgentState, before: ThreadAgentState): void {
   if (before.submissions === undefined) delete state.submissions;
+  if (before.promptOperations === undefined) delete state.promptOperations;
   if (before.harness === undefined) delete state.harness;
   Object.assign(state, before);
 }

package/src/thread-review.ts

@@ -74,6 +74,7 @@ export async function resolveWorkspace(cwd = process.cwd()): Promise<WorkspaceKe
   const remote = nativeJjRoot ? null : gitRemote;
 
   const workspace: WorkspaceKey = { repoRoot, branch };
+
   // a repo with no commits (or a shallow clone) has no reliable root, so the thread stays standalone
   if (rootCommit) workspace.rootCommit = rootCommit;
   if (remote) workspace.remote = remote;