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

package/src/{review.ts → thread-review.ts}

@@ -1,8 +1,8 @@
 /**
- * The shared review core: one open/wait/verdict path for every consumer -
+ * The shared Thread review core: one open/wait/message path for every consumer -
  * CLI commands and agent adapters. openReview resolves the workspace, shapes
- * the artifact, and opens-or-revises by agentSessionId; awaitVerdict maps the
- * wait contract onto the agent contract through verdictResponse. An
+ * the artifact, and opens-or-revises by agentSessionId; awaitMessage maps the
+ * wait contract onto the agent contract through messageResponse. An
  * adapter keeps only two bespoke parts: parsing its host's event shape and
  * serializing the decision in its host's contract.
  */
@@ -10,18 +10,20 @@
 import {
   isMarkdownArtifact,
   newAnnotationId,
+  type Annotation,
+  type Artifact,
   type ArtifactType,
   type DiffFileContents,
   type Thread,
   type WorkspaceKey,
+  type WorkflowKind,
 } from "@cueloop/schema";
-import { verdictResponse } from "./api";
-import type { DaemonClient } from "./client";
+import { messageResponse } from "./api";
 import { ABORTED, pollUntilResolved, raceAbort } from "./interruptible-wait";
 
-// Adapters and CLI primitives reach the verdict mapping through this module too,
+// Adapters and CLI primitives reach the message mapping through this module too,
 // so a session obtained outside a ReviewHandle maps the same way.
-export { verdictResponse };
+export { messageResponse };
 
 async function git(args: string[], cwd: string): Promise<string | null> {
   try {
@@ -73,6 +75,8 @@ function firstHeading(markdown: string): string | undefined {
 
 export interface OpenReviewOptions {
   type: ArtifactType;
+  /** Workflow identity keeps plan/refine and diff/review Threads separate. */
+  workflow?: WorkflowKind;
   content: string;
   /** Workspace resolution root and meta.cwd; defaults to process.cwd(). */
   cwd?: string;
@@ -107,9 +111,28 @@ export interface ReviewNote {
   body: string;
 }
 
+/** The transport-neutral daemon operations used by the shared review lifecycle. */
+export interface ThreadSessionClient {
+  sessionList(filter?: { status?: "pending" | "resolved" }): Promise<Thread[]>;
+  sessionCreate(workspace: WorkspaceKey, artifact: Artifact): Promise<Thread>;
+  sessionSubmitRevision(
+    id: string,
+    content: string,
+    addressedAnnotationIds?: string[],
+    files?: DiffFileContents[],
+  ): Promise<Thread>;
+  sessionAnnotate(
+    id: string,
+    annotation: Omit<Annotation, "createdAt">,
+    authorName?: string,
+  ): Promise<Thread>;
+  sessionGet(id: string): Promise<Thread>;
+  sessionWait(id: string, timeoutMs: number): Promise<Thread | null>;
+}
+
 /** Anchor a note at its file: quote = the path, no context selectors. */
 async function attachNotes(
-  client: DaemonClient,
+  client: ThreadSessionClient,
   sessionId: string,
   notes: ReviewNote[],
 ): Promise<void> {
@@ -123,7 +146,7 @@ async function attachNotes(
   }
 }
 
-export interface AwaitVerdictOptions {
+export interface AwaitMessageOptions {
   /** Total wait budget; Infinity keeps polling until resolved or aborted. */
   timeoutMs: number;
   /** Chunk length for the poll loop; between chunks the session is re-read for progress. */
@@ -134,15 +157,15 @@ export interface AwaitVerdictOptions {
 }
 
 /** A resolved review mapped onto the agent contract, plus the full session. */
-export interface VerdictOutcome {
+export interface MessageResult {
   allow: boolean;
-  feedback: string;
+  message: import("@cueloop/schema").Message;
   session: Thread;
 }
 
 export class ReviewHandle {
   constructor(
-    private readonly client: DaemonClient,
+    private readonly client: Pick<ThreadSessionClient, "sessionWait" | "sessionGet">,
     readonly session: Thread,
   ) {}
 
@@ -151,12 +174,12 @@ export class ReviewHandle {
   }
 
   /**
-   * Block on the verdict. "pending" means the budget ran out or the signal
-   * aborted - the session stays open and the verdict is collectable later
-   * (verdicts outlive waits). With only timeoutMs this is one long-poll;
+   * Block on the message. "pending" means the budget ran out or the signal
+   * aborted - the session stays open and the message is collectable later
+   * (messages outlive waits). With only timeoutMs this is one long-poll;
    * pollMs/onProgress/signal switch to the chunked loop.
    */
-  async awaitVerdict(options: AwaitVerdictOptions): Promise<VerdictOutcome | "pending"> {
+  async awaitMessage(options: AwaitMessageOptions): Promise<MessageResult | "pending"> {
     const { timeoutMs, pollMs, onProgress, signal } = options;
 
     if (pollMs === undefined && onProgress === undefined && signal === undefined) {
@@ -174,18 +197,20 @@ export class ReviewHandle {
       const resolved = await raceAbort(this.client.sessionWait(this.session.id, budget), signal);
 
       if (resolved === ABORTED) return "pending";
+
       if (resolved !== null) return outcome(resolved);
       // Still pending after this chunk: re-read to surface reviewer progress.
       const current = await raceAbort(this.client.sessionGet(this.session.id), signal);
 
       if (current === ABORTED) return "pending";
+
       onProgress?.(current);
     }
   }
 }
 
-function outcome(session: Thread): VerdictOutcome {
-  return { ...verdictResponse(session), session };
+function outcome(session: Thread): MessageResult {
+  return { ...messageResponse(session), session };
 }
 
 export interface AwaitResolveOptions {
@@ -196,21 +221,21 @@ export interface AwaitResolveOptions {
 }
 
 /**
- * Park until a thread resolves, then return the verdict outcome; null
- * when the signal aborts first. Where ReviewHandle.awaitVerdict needs the handle
+ * Park until a thread resolves, then return the message outcome; null
+ * when the signal aborts first. Where ReviewHandle.awaitMessage needs the handle
  * that opened the review, this needs only a session id - so a background waiter
  * that woke on a session it did not open (a detached Claude Code / Codex waiter,
- * or pi's session_start listener) can collect the same verdict. This is the
+ * or pi's session_start listener) can collect the same message. This is the
  * wake seam every non-blocking adapter builds on. Loops the daemon long-poll, so
- * a verdict that lands between chunks is never missed and a session already
+ * a message that lands between chunks is never missed and a session already
  * resolved returns on the first chunk. The held connection also keeps the daemon
  * off its idle-exit path for the whole wait.
  */
 export async function awaitResolve(
-  client: DaemonClient,
+  client: Pick<ThreadSessionClient, "sessionWait">,
   sessionId: string,
   options: AwaitResolveOptions = {},
-): Promise<VerdictOutcome | null> {
+): Promise<MessageResult | null> {
   const chunkMs = options.pollMs ?? 30_000;
   const resolved = await pollUntilResolved(
     () => client.sessionWait(sessionId, chunkMs),
@@ -220,40 +245,63 @@ export async function awaitResolve(
   return resolved === null ? null : outcome(resolved);
 }
 
+/** Find the Thread already submitted by this agent in the same workspace and primitive. */
+export async function findExistingReview(
+  client: ThreadSessionClient,
+  options: OpenReviewOptions,
+): Promise<Thread | undefined> {
+  const cwd = options.cwd ?? process.cwd();
+  const workspace = options.workspace ?? (await resolveWorkspace(cwd));
+
+  if (options.agentSessionId === undefined) return undefined;
+
+  return (await client.sessionList()).find(
+    (candidate) =>
+      candidate.artifact.meta.agentSessionId === options.agentSessionId &&
+      candidate.artifact.meta.agent === options.agent &&
+      candidate.artifact.type === options.type &&
+      (candidate.artifact.meta.workflow ??
+        (candidate.artifact.meta.pr ? "review" : candidate.artifact.type)) ===
+        (options.workflow ?? (options.pr ? "review" : options.type)) &&
+      candidate.artifact.meta.pr === options.pr &&
+      candidate.workspace.repoRoot === workspace.repoRoot &&
+      candidate.workspace.branch === workspace.branch,
+  );
+}
+
 /** Open a thread (or revise the agent session's existing one) and hand back the wait surface. */
 export async function openReview(
-  client: DaemonClient,
+  client: ThreadSessionClient,
   options: OpenReviewOptions,
 ): Promise<ReviewHandle> {
   const cwd = options.cwd ?? process.cwd();
   const workspace = options.workspace ?? (await resolveWorkspace(cwd));
-
-  // Resubmits from the same agent session become revisions, not new sessions -
-  // but only within the same primitive: a different artifact type is a new
-  // review, never a silent type mismatch on the old session.
-  if (options.agentSessionId !== undefined) {
-    const existing = (await client.sessionList()).find(
-      (candidate) =>
-        candidate.artifact.meta.agentSessionId === options.agentSessionId &&
-        candidate.artifact.type === options.type,
+  const existing = await findExistingReview(client, options);
+
+  if (existing !== undefined) {
+    // PR diffs have no full file contents. An absent local-diff capture clears
+    // old curatable files, while a PR revision must keep curation disabled.
+    const revisionFiles = options.type !== "diff" || options.pr ? undefined : (options.files ?? []);
+    let revised = await client.sessionSubmitRevision(
+      existing.id,
+      options.content,
+      [],
+      revisionFiles,
     );
 
-    if (existing !== undefined) {
-      let revised = await client.sessionSubmitRevision(existing.id, options.content);
-
-      if (options.notes?.length) {
-        await attachNotes(client, revised.id, options.notes);
-        revised = await client.sessionGet(revised.id);
-      }
-
-      return new ReviewHandle(client, revised);
+    if (options.notes?.length) {
+      await attachNotes(client, revised.id, options.notes);
+      revised = await client.sessionGet(revised.id);
     }
+
+    return new ReviewHandle(client, revised);
   }
   let session = await client.sessionCreate(workspace, {
     type: options.type,
     content: options.content,
     files: options.files,
     meta: {
+      workflow: options.workflow,
       agent: options.agent,
       agentSessionId: options.agentSessionId,
       planPath: options.planPath,

package/src/validate.test.ts

@@ -13,7 +13,7 @@ import {
   IdentitySchema,
   RevisionSchema,
   ThreadRecordSchema,
-  VerdictSchema,
+  MessageSchema,
   WorkspaceSchema,
   isKnownMethod,
   parseParams,
@@ -29,7 +29,7 @@ import {
   type Identity,
   type Thread,
   type Revision,
-  type Verdict,
+  type Message,
   type WorkspaceKey,
 } from "@cueloop/schema";
 
@@ -97,10 +97,10 @@ describe("parseParams", () => {
     ).toThrow();
   });
 
-  test("verdict kinds are closed", () => {
-    expect(parseParams("session.resolve", { id: "s", verdictKind: "approve" }).summary).toBe("");
-    expect(() => parseParams("session.resolve", { id: "s", verdictKind: "lgtm" })).toThrow(
-      /verdictKind/,
+  test("message kinds are closed", () => {
+    expect(parseParams("session.sendMessage", { id: "s", outcome: "approved" }).summary).toBe("");
+    expect(() => parseParams("session.sendMessage", { id: "s", outcome: "lgtm" })).toThrow(
+      /outcome/,
     );
   });
 
@@ -141,7 +141,7 @@ describe("validateThreadRecord", () => {
     artifact: { type: "plan", content: "# P", meta: {} },
     revisions: [{ revision: 1, content: "# P", submittedAt: "now" }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "now",
   };
@@ -179,6 +179,7 @@ describe("wire pins", () => {
   const entryKeys = (schema: { entries: object }) => Object.keys(schema.entries).sort();
 
   const fullMeta: Required<ArtifactMeta> = {
+    workflow: "plan",
     cwd: "/repo",
     agent: "claude-code",
     agentSessionId: "sess-1",
@@ -218,11 +219,12 @@ describe("wire pins", () => {
     meta: fullMeta,
     files: [{ path: "src/a.ts", oldContents: "old\n", newContents: "new\n", status: "modified" }],
   };
-  const fullVerdict: Required<Verdict> = {
-    kind: "approve",
+  const fullMessage: Required<Message> = {
+    id: "msg_1",
+    outcome: "approved",
     summary: "",
-    feedback: "",
-    resolvedAt: "now",
+    body: "",
+    sentAt: "now",
   };
   const fullRevision: Required<Revision> = { revision: 1, content: "# P", submittedAt: "now" };
   const fullWorkspace: Required<WorkspaceKey> = {
@@ -256,7 +258,7 @@ describe("wire pins", () => {
         },
         { id: "e2", parentId: "e1", type: "comment", annotationId: "a1", createdAt: "now" },
         { id: "e3", parentId: "e2", type: "comment-removed", annotationId: "a1", createdAt: "now" },
-        { id: "e4", parentId: "e3", type: "verdict", verdict: fullVerdict, createdAt: "now" },
+        { id: "e4", parentId: "e3", type: "message", message: fullMessage, createdAt: "now" },
         {
           id: "e5",
           parentId: "e4",
@@ -276,7 +278,7 @@ describe("wire pins", () => {
     shareBranch: "main",
     workingCopy: "# P edited",
     viewedPaths: ["src/a.ts"],
-    verdict: fullVerdict,
+    message: fullMessage,
     status: "pending",
     createdAt: "now",
     shares: [
@@ -328,7 +330,7 @@ describe("wire pins", () => {
 
     expect(entryKeys(AnnotationSchema)).toEqual(keys(wireAnnotation));
     expect(entryKeys(RevisionSchema)).toEqual(keys(fullRevision));
-    expect(entryKeys(VerdictSchema)).toEqual(keys(fullVerdict));
+    expect(entryKeys(MessageSchema)).toEqual(keys(fullMessage));
     expect(entryKeys(IdentitySchema)).toEqual(keys(fullIdentity));
     expect(entryKeys(ThreadRecordSchema)).toEqual(keys(fullSession));
     // persisted annotations carry the stamped createdAt

package/src/validate.ts

@@ -12,6 +12,7 @@
 import * as v from "valibot";
 import {
   ARTIFACT_TYPES,
+  WORKFLOW_KINDS,
   SCHEMA_VERSION,
   type Anchor,
   type Annotation,
@@ -22,12 +23,15 @@ import {
   type Identity,
   type Thread,
   type HunkRejection,
+  type HarnessBinding,
+  type Delivery,
+  type PendingDelivery,
   type Revision,
   type SessionHistory,
   type ShareAccess,
   type ShareLink,
   validateHistory,
-  type Verdict,
+  type Message,
   type WorkspaceKey,
 } from "@cueloop/schema";
 import { DaemonError } from "./errors";
@@ -52,6 +56,7 @@ export const WorkspaceSchema = v.object({
 } satisfies EntriesOf<WorkspaceKey>);
 
 export const ArtifactMetaSchema = v.object({
+  workflow: v.optional(v.picklist(WORKFLOW_KINDS)),
   cwd: v.optional(v.string()),
   agent: v.optional(v.string()),
   agentSessionId: v.optional(v.string()),
@@ -141,6 +146,24 @@ export const ShareLinkSchema = v.object({
   shareBranch: v.optional(v.string()),
 } satisfies EntriesOf<ShareLink>);
 
+export const HarnessBindingSchema = v.object({
+  id: NonEmpty,
+  threadId: NonEmpty,
+  harness: NonEmpty,
+  harnessSessionId: NonEmpty,
+  createdAt: NonEmpty,
+  approvedRetryMessageId: v.optional(NonEmpty),
+} satisfies EntriesOf<HarnessBinding>);
+
+export const DeliverySchema = v.object({
+  id: NonEmpty,
+  messageId: NonEmpty,
+  bindingId: NonEmpty,
+  status: v.picklist(["pending", "acknowledged"]),
+  createdAt: NonEmpty,
+  acknowledgedAt: v.optional(NonEmpty),
+} satisfies EntriesOf<Delivery>);
+
 export const Params = {
   "session.create": v.object({ workspace: WorkspaceSchema, artifact: ArtifactSchema }),
   "session.get": v.object({ id: SessionId }),
@@ -227,15 +250,29 @@ export const Params = {
       v.array(v.object({ id: NonEmpty, annotationId: NonEmpty, createdAt: v.string() })),
     ),
   }),
-  "session.resolve": v.object({
+  "session.sendMessage": v.object({
     id: SessionId,
-    verdictKind: v.picklist(["comment", "approve", "request_changes"]),
+    outcome: v.picklist(["approved", "changes_requested"]),
     summary: v.optional(v.string(), ""),
     actionBodies: v.optional(v.record(v.string(), v.string())),
   }),
+  "harness.bind": v.object({
+    threadId: SessionId,
+    harness: NonEmpty,
+    harnessSessionId: NonEmpty,
+  }),
+  "harness.getBinding": v.object({ bindingId: NonEmpty }),
+  "harness.consumeApprovedRetry": v.object({
+    bindingId: NonEmpty,
+    messageId: NonEmpty,
+    content: v.string(),
+  }),
+  "delivery.pending": v.object({ bindingId: NonEmpty }),
+  "delivery.acknowledge": v.object({ deliveryId: NonEmpty }),
   "session.submitRevision": v.object({
     id: SessionId,
     content: v.string(),
+    files: v.optional(v.array(DiffFileContentsSchema)),
     /** Annotation ids the agent acted on; each is marked addressed. */
     addressedAnnotationIds: v.optional(v.array(NonEmpty), []),
   }),
@@ -286,12 +323,18 @@ export const RevisionSchema = v.object({
   submittedAt: v.string(),
 } satisfies EntriesOf<Revision>);
 
-export const VerdictSchema = v.object({
-  kind: v.picklist(["comment", "approve", "request_changes"]),
+export const MessageSchema = v.object({
+  id: NonEmpty,
+  outcome: v.picklist(["approved", "changes_requested"]),
   summary: v.string(),
-  feedback: v.string(),
-  resolvedAt: v.string(),
-} satisfies EntriesOf<Verdict>);
+  body: v.string(),
+  sentAt: v.string(),
+} satisfies EntriesOf<Message>);
+
+export const PendingDeliverySchema = v.object({
+  delivery: DeliverySchema,
+  message: MessageSchema,
+} satisfies EntriesOf<PendingDelivery>);
 
 const EntryBaseEntries = {
   id: NonEmpty,
@@ -309,7 +352,7 @@ export const SessionEntrySchema = v.variant("type", [
   }),
   v.object({ ...EntryBaseEntries, type: v.literal("comment"), annotationId: NonEmpty }),
   v.object({ ...EntryBaseEntries, type: v.literal("comment-removed"), annotationId: NonEmpty }),
-  v.object({ ...EntryBaseEntries, type: v.literal("verdict"), verdict: VerdictSchema }),
+  v.object({ ...EntryBaseEntries, type: v.literal("message"), message: MessageSchema }),
   v.object({
     ...EntryBaseEntries,
     type: v.literal("branch-summary"),
@@ -354,7 +397,7 @@ export const ThreadRecordSchema = v.object({
   ),
   workingCopy: v.optional(v.string()),
   viewedPaths: v.optional(v.array(v.string())),
-  verdict: v.nullable(VerdictSchema),
+  message: v.nullable(MessageSchema),
   status: v.picklist(["pending", "resolved"]),
   createdAt: v.string(),
   shelvedAnnotations: v.optional(v.array(FullAnnotationSchema)),