cueloop 0.1.0-alpha.33 → 0.1.0-alpha.35

package/package.json

@@ -1,37 +1,38 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.33",
+  "version": "0.1.0-alpha.35",
+  "description": "Terminal review surface for coding agents: annotate plans and diffs, return a verdict, send structured feedback back",
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
   "license": "Apache-2.0",
-  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mmurakaru/cueloop.git",
+    "directory": "packages/cli"
+  },
   "bin": {
     "cueloop": "./src/main.ts"
   },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "type": "module",
   "exports": {
     ".": "./src/main.ts"
   },
-  "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.33",
-    "@cueloop/daemon": "0.1.0-alpha.33",
-    "@cueloop/client": "0.1.0-alpha.33"
-  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "dependencies": {
+    "@cueloop/adapters": "0.1.0-alpha.35",
+    "@cueloop/client": "0.1.0-alpha.35",
+    "@cueloop/daemon": "0.1.0-alpha.35",
+    "@cueloop/schema": "0.1.0-alpha.35"
+  },
   "engines": {
     "bun": ">=1.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mmurakaru/cueloop.git",
-    "directory": "packages/cli"
-  },
-  "homepage": "https://github.com/mmurakaru/cueloop#readme",
-  "bugs": {
-    "url": "https://github.com/mmurakaru/cueloop/issues"
-  },
-  "description": "Terminal review surface for coding agents: annotate plans and diffs, return a verdict, send structured feedback back"
-}
+  }
+}

package/src/args.ts

@@ -31,7 +31,10 @@ export function parseArgs(argv: string[]): ParsedArgs {
   return { positional, flags };
 }
 
-export function stringFlag(flags: Record<string, string | boolean>, key: string): string | undefined {
+export function stringFlag(
+  flags: Record<string, string | boolean>,
+  key: string,
+): string | undefined {
   const value = flags[key];
   return typeof value === "string" ? value : undefined;
 }

package/src/main.ts

@@ -77,10 +77,18 @@ async function main(): Promise<number> {
       const { positional, flags } = parseArgs(argv.slice(1));
       const { shareCommand, sharePullCommand } = await import("./share-command");
       const port = stringFlag(flags, "port");
-      const target = { host: stringFlag(flags, "host"), port: port !== undefined ? Number(port) : undefined };
-      if (positional[0] === "pull") return sharePullCommand({ ...target, sessionId: positional[1] });
+      const target = {
+        host: stringFlag(flags, "host"),
+        port: port !== undefined ? Number(port) : undefined,
+      };
+      if (positional[0] === "pull")
+        return sharePullCommand({ ...target, sessionId: positional[1] });
       return shareCommand({ ...target, sessionId: positional[0] });
     }
+    case "wake": {
+      const { wakeCommand } = await import("./wake-command");
+      return wakeCommand(argv.slice(1));
+    }
     case "review":
       return reviewEntry(argv.slice(1));
     case "review-post": {
@@ -115,7 +123,9 @@ async function main(): Promise<number> {
  * latest pending review.
  */
 function openSelector(parsed: ParsedArgs): string | undefined {
-  return parsed.positional[0] ?? stringFlag(parsed.flags, "open") ?? stringFlag(parsed.flags, "latest");
+  return (
+    parsed.positional[0] ?? stringFlag(parsed.flags, "open") ?? stringFlag(parsed.flags, "latest")
+  );
 }
 
 /**
@@ -167,7 +177,7 @@ async function diffCommand(argv: string[]): Promise<number> {
 
   const workspace = await resolveWorkspace();
   const diff = await workingTreeDiff();
-  if (!diff.trim()) {
+  if (!diff.patch.trim()) {
     return openReviewOfKind(
       isDiffReview,
       "diff",
@@ -178,7 +188,8 @@ async function diffCommand(argv: string[]): Promise<number> {
   const client = await DaemonClient.connect({ autostart: true });
   const review = await openReview(client, {
     type: "diff",
-    content: diff,
+    content: diff.patch,
+    files: diff.files,
     workspace,
     title: `working tree @ ${workspace.branch}`,
   });
@@ -202,7 +213,11 @@ async function reviewEntry(argv: string[]): Promise<number> {
     const { reviewCommand } = await import("./pr");
     return reviewCommand(argv);
   }
-  return openReviewOfKind(isPrReview, "PR", explicitOpen || looksLikeSessionId ? selector : undefined);
+  return openReviewOfKind(
+    isPrReview,
+    "PR",
+    explicitOpen || looksLikeSessionId ? selector : undefined,
+  );
 }
 
 async function runTui(sessionId?: string): Promise<number> {
@@ -239,6 +254,7 @@ function printHelp(): void {
       "",
       "scripting:",
       "  cueloop session <verb> [flags]   script the daemon (create|get|list|wait|annotate|resolve|submit-revision)",
+      "  cueloop wake <id> [--harness codex --thread <id>]  resume the agent with the verdict (spawn detached)",
       "  cueloop review-post <id> <pr>    post a resolved session's verdict back to the PR",
       "  cueloop daemon                   run the daemon in the foreground",
       "",

package/src/open-target.test.ts

@@ -30,7 +30,10 @@ function session(overrides: {
     },
     revisions: [],
     annotations: [],
-    verdict: overrides.status === "resolved" ? { kind: "approve", summary: "", feedback: "", resolvedAt: "" } : null,
+    verdict:
+      overrides.status === "resolved"
+        ? { kind: "approve", summary: "", feedback: "", resolvedAt: "" }
+        : null,
     status: overrides.status ?? "pending",
     createdAt: overrides.createdAt ?? "2026-01-01T00:00:00.000Z",
   };
@@ -84,7 +87,10 @@ describe("resolveOpenTarget: latest pending default", () => {
     ];
 
     // Assert
-    expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({ kind: "session", sessionId: "ses_new" });
+    expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({
+      kind: "session",
+      sessionId: "ses_new",
+    });
   });
 
   test("ignores resolved sessions and other artifact types", () => {
@@ -96,7 +102,10 @@ describe("resolveOpenTarget: latest pending default", () => {
     ];
 
     // Assert
-    expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({ kind: "session", sessionId: "ses_plan" });
+    expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({
+      kind: "session",
+      sessionId: "ses_plan",
+    });
   });
 
   test("no pending session in scope reports no-pending", () => {
@@ -111,10 +120,7 @@ describe("resolveOpenTarget: latest pending default", () => {
 describe("resolveOpenTarget: by id", () => {
   test("an exact session id in scope opens that session, pending or not", () => {
     // Arrange
-    const sessions = [
-      session({ id: "ses_a" }),
-      session({ id: "ses_b", status: "resolved" }),
-    ];
+    const sessions = [session({ id: "ses_a" }), session({ id: "ses_b", status: "resolved" })];
 
     // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan, selector: "ses_b" })).toEqual({
@@ -193,7 +199,9 @@ describe("resolveOpenTarget: fuzzy by title", () => {
 
 describe("openTargetMessage", () => {
   test("no-pending mirrors the clean-tree tone", () => {
-    expect(openTargetMessage("plan", { kind: "no-pending" })).toBe("no pending plan review - nothing to open");
+    expect(openTargetMessage("plan", { kind: "no-pending" })).toBe(
+      "no pending plan review - nothing to open",
+    );
   });
 
   test("no-match names the selector", () => {
@@ -204,7 +212,11 @@ describe("openTargetMessage", () => {
 
   test("ambiguous lists the candidate titles", () => {
     // Act
-    const message = openTargetMessage("plan", { kind: "ambiguous", selector: "rollout", titles: ["A", "B"] });
+    const message = openTargetMessage("plan", {
+      kind: "ambiguous",
+      selector: "rollout",
+      titles: ["A", "B"],
+    });
 
     // Assert
     expect(message).toContain('"rollout" matches several plan reviews');

package/src/open-target.ts

@@ -62,8 +62,12 @@ export function resolveOpenTarget(sessions: ReviewSession[], query: OpenTargetQu
   const scoped = sessions.filter(query.match);
 
   if (query.selector === undefined) {
-    const latestPending = scoped.filter((candidate) => candidate.status === "pending").sort(newestFirst)[0];
-    return latestPending ? { kind: "session", sessionId: latestPending.id } : { kind: "no-pending" };
+    const latestPending = scoped
+      .filter((candidate) => candidate.status === "pending")
+      .sort(newestFirst)[0];
+    return latestPending
+      ? { kind: "session", sessionId: latestPending.id }
+      : { kind: "no-pending" };
   }
 
   const selector = query.selector;
@@ -83,7 +87,11 @@ export function resolveOpenTarget(sessions: ReviewSession[], query: OpenTargetQu
     .sort(newestFirst);
   if (substringMatches.length === 1) return { kind: "session", sessionId: substringMatches[0]!.id };
   if (substringMatches.length === 0) return { kind: "no-match", selector };
-  return { kind: "ambiguous", selector, titles: substringMatches.map((candidate) => candidate.artifact.meta.title!) };
+  return {
+    kind: "ambiguous",
+    selector,
+    titles: substringMatches.map((candidate) => candidate.artifact.meta.title!),
+  };
 }
 
 /**
@@ -91,7 +99,10 @@ export function resolveOpenTarget(sessions: ReviewSession[], query: OpenTargetQu
  * to review" tone. `label` is the human word for the verb's scope ("plan",
  * "diff", "PR"). The "session" outcome has no message - the caller opens it.
  */
-export function openTargetMessage(label: string, target: Exclude<OpenTarget, { kind: "session" }>): string {
+export function openTargetMessage(
+  label: string,
+  target: Exclude<OpenTarget, { kind: "session" }>,
+): string {
   switch (target.kind) {
     case "no-pending":
       return `no pending ${label} review - nothing to open`;

package/src/pr.ts

@@ -56,6 +56,8 @@ export async function reviewCommand(argv: string[]): Promise<number> {
     return 1;
   }
   const client = await DaemonClient.connect({ autostart: true });
+  // A PR diff is a partial patch with no full file contents, so no `files` here;
+  // hunk curation stays disabled for PR reviews (see diff-hunk-curate.ts).
   const review = await openReview(client, {
     type: "diff",
     content: diff.stdout,
@@ -109,7 +111,14 @@ async function getSession(id: string): Promise<ReviewSession> {
 /** Post the resolved session's verdict to the PR: feedback.md is the review body. */
 async function postVerdict(session: ReviewSession, pr: string): Promise<number> {
   const verdict = session.verdict!;
-  const result = await gh(["pr", "review", pr, VERDICT_FLAG[verdict.kind], "--body", verdict.feedback]);
+  const result = await gh([
+    "pr",
+    "review",
+    pr,
+    VERDICT_FLAG[verdict.kind],
+    "--body",
+    verdict.feedback,
+  ]);
   if (result.code !== 0) {
     console.error(result.stderr.trim() || `gh pr review ${pr} failed (exit ${result.code})`);
     return 1;

package/src/session-commands.ts

@@ -29,7 +29,9 @@ export async function sessionCommand(argv: string[]): Promise<number> {
         const content = contentFile ? await Bun.file(contentFile).text() : await readStdin();
         // per-file agent notes for diff sessions: a JSON array of { path, body }
         const notesFile = stringFlag(flags, "notes-file");
-        const notes = notesFile ? (JSON.parse(await Bun.file(notesFile).text()) as ReviewNote[]) : undefined;
+        const notes = notesFile
+          ? (JSON.parse(await Bun.file(notesFile).text()) as ReviewNote[])
+          : undefined;
         const review = await openReview(client, {
           type: (stringFlag(flags, "type") ?? "plan") as ArtifactType,
           content,

package/src/share-command.test.ts

@@ -19,7 +19,13 @@ function sessionFixture(id: string, overrides: Partial<ReviewSession> = {}): Rev
 }
 
 function annotationFixture(id: string, author?: string): Annotation {
-  const base: Annotation = { id, kind: "comment", anchor: { quote: "Plan", prefix: "", suffix: "" }, body: "note", createdAt: "2026-01-01T00:00:00.000Z" };
+  const base: Annotation = {
+    id,
+    kind: "comment",
+    anchor: { quote: "Plan", prefix: "", suffix: "" },
+    body: "note",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
   return author ? { ...base, author } : base;
 }
 
@@ -36,7 +42,8 @@ function fakeClient(sessions: ReviewSession[]): SessionClient {
     sessionMergeShared: mock(async (id: string, incoming: { annotations: Annotation[] }) => {
       const session = sessions.find((candidate) => candidate.id === id)!;
       const known = new Set(session.annotations.map((annotation) => annotation.id));
-      for (const annotation of incoming.annotations) if (!known.has(annotation.id)) session.annotations.push(annotation);
+      for (const annotation of incoming.annotations)
+        if (!known.has(annotation.id)) session.annotations.push(annotation);
       return session;
     }),
   } as unknown as SessionClient;
@@ -55,11 +62,20 @@ function depsSpy(overrides: Partial<ShareDeps> = {}): ShareDeps & { lines: strin
 describe(shareSession, () => {
   test("publishes the named session and reports the copied ssh line", async () => {
     // Arrange
-    const publish = mock(async (session: ReviewSession) => (expect(session.id).toBe("ses_2"), { line: "ssh p_abc123xy@cueloop.dev", copied: true }));
+    const publish = mock(
+      async (session: ReviewSession) => (
+        expect(session.id).toBe("ses_2"),
+        { line: "ssh p_abc123xy@cueloop.dev", copied: true }
+      ),
+    );
     const deps = depsSpy({ publish });
 
     // Act
-    const code = await shareSession(fakeClient([sessionFixture("ses_1"), sessionFixture("ses_2")]), { sessionId: "ses_2" }, deps);
+    const code = await shareSession(
+      fakeClient([sessionFixture("ses_1"), sessionFixture("ses_2")]),
+      { sessionId: "ses_2" },
+      deps,
+    );
 
     // Assert
     expect(code).toBe(0);
@@ -68,7 +84,12 @@ describe(shareSession, () => {
 
   test("without an id, shares the most recent session", async () => {
     // Arrange
-    const publish = mock(async (session: ReviewSession) => (expect(session.id).toBe("ses_2"), { line: "ssh p_zzzzzzzz@cueloop.dev", copied: true }));
+    const publish = mock(
+      async (session: ReviewSession) => (
+        expect(session.id).toBe("ses_2"),
+        { line: "ssh p_zzzzzzzz@cueloop.dev", copied: true }
+      ),
+    );
     const deps = depsSpy({ publish });
 
     // Act
@@ -80,7 +101,9 @@ describe(shareSession, () => {
 
   test("prints the bare line when the clipboard is unavailable", async () => {
     // Arrange
-    const deps = depsSpy({ publish: mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: false })) });
+    const deps = depsSpy({
+      publish: mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: false })),
+    });
 
     // Act
     await shareSession(fakeClient([sessionFixture("ses_1")]), { sessionId: "ses_1" }, deps);
@@ -118,15 +141,24 @@ describe(shareSession, () => {
 
 function pullDepsSpy(remote: ReviewSession): PullDeps & { lines: string[] } {
   const lines: string[] = [];
-  return { pull: mock(async () => remote), out: (message: string) => void lines.push(message), lines };
+  return {
+    pull: mock(async () => remote),
+    out: (message: string) => void lines.push(message),
+    lines,
+  };
 }
 
 describe(pullSession, () => {
   test("unions collaborator notes in, ignoring the planner's own unauthored notes", async () => {
     // Arrange - the planner's own note carries no author; the collaborator's does
-    const local = sessionFixture("ses_1", { shareId: "p_abc123xy", annotations: [annotationFixture("mine")] });
+    const local = sessionFixture("ses_1", {
+      shareId: "p_abc123xy",
+      annotations: [annotationFixture("mine")],
+    });
     const client = fakeClient([local]);
-    const remote = sessionFixture("ses_1", { annotations: [annotationFixture("mine"), annotationFixture("theirs", "SHA256:mate")] });
+    const remote = sessionFixture("ses_1", {
+      annotations: [annotationFixture("mine"), annotationFixture("theirs", "SHA256:mate")],
+    });
     const deps = pullDepsSpy(remote);
 
     // Act
@@ -154,8 +186,13 @@ describe(pullSession, () => {
 
   test("reports when nothing new came back", async () => {
     // Arrange
-    const local = sessionFixture("ses_1", { shareId: "p_abc123xy", annotations: [annotationFixture("theirs", "SHA256:mate")] });
-    const deps = pullDepsSpy(sessionFixture("ses_1", { annotations: [annotationFixture("theirs", "SHA256:mate")] }));
+    const local = sessionFixture("ses_1", {
+      shareId: "p_abc123xy",
+      annotations: [annotationFixture("theirs", "SHA256:mate")],
+    });
+    const deps = pullDepsSpy(
+      sessionFixture("ses_1", { annotations: [annotationFixture("theirs", "SHA256:mate")] }),
+    );
 
     // Act
     await pullSession(fakeClient([local]), { sessionId: "ses_1" }, deps);
@@ -169,7 +206,11 @@ describe(pullSession, () => {
     const deps = pullDepsSpy(sessionFixture("ses_1"));
 
     // Act
-    const code = await pullSession(fakeClient([sessionFixture("ses_1")]), { sessionId: "ses_1" }, deps);
+    const code = await pullSession(
+      fakeClient([sessionFixture("ses_1")]),
+      { sessionId: "ses_1" },
+      deps,
+    );
 
     // Assert
     expect(code).toBe(1);

package/src/share-command.ts

@@ -7,7 +7,14 @@
  */
 
 import { DaemonClient, type SessionClient } from "@cueloop/daemon/client";
-import { collaboratorAnnotations, publishShare, pullShare, shareIdFromLine, type ShareResult, type ShareTarget } from "@cueloop/client";
+import {
+  collaboratorAnnotations,
+  publishShare,
+  pullShare,
+  shareIdFromLine,
+  type ShareResult,
+  type ShareTarget,
+} from "@cueloop/client";
 import type { ReviewSession } from "@cueloop/schema";
 
 export interface ShareParams {
@@ -31,7 +38,10 @@ const defaultDeps: ShareDeps = { publish: publishShare, out: (message) => consol
 const defaultPullDeps: PullDeps = { pull: pullShare, out: (message) => console.log(message) };
 
 /** Connect to the local daemon, then share the chosen session. */
-export async function shareCommand(params: ShareParams, deps: ShareDeps = defaultDeps): Promise<number> {
+export async function shareCommand(
+  params: ShareParams,
+  deps: ShareDeps = defaultDeps,
+): Promise<number> {
   const client = await DaemonClient.connect({ home: params.home, autostart: true });
   try {
     return await shareSession(client, params, deps);
@@ -41,7 +51,10 @@ export async function shareCommand(params: ShareParams, deps: ShareDeps = defaul
 }
 
 /** Connect to the local daemon, then pull collaborator notes for the plan. */
-export async function sharePullCommand(params: ShareParams, deps: PullDeps = defaultPullDeps): Promise<number> {
+export async function sharePullCommand(
+  params: ShareParams,
+  deps: PullDeps = defaultPullDeps,
+): Promise<number> {
   const client = await DaemonClient.connect({ home: params.home, autostart: true });
   try {
     return await pullSession(client, params, deps);
@@ -51,7 +64,11 @@ export async function sharePullCommand(params: ShareParams, deps: PullDeps = def
 }
 
 /** The share orchestration, over any SessionClient - the seam the tests drive. */
-export async function shareSession(client: SessionClient, params: ShareParams, deps: ShareDeps): Promise<number> {
+export async function shareSession(
+  client: SessionClient,
+  params: ShareParams,
+  deps: ShareDeps,
+): Promise<number> {
   const session = await pickSession(client, params.sessionId);
   if (!session) {
     deps.out("no plan to share - open a review first");
@@ -69,7 +86,11 @@ export async function shareSession(client: SessionClient, params: ShareParams, d
  * plan. Union-by-id keeps the planner's own notes; only collaborators' new
  * ones land. The gateway lets only the fingerprint that shared it pull.
  */
-export async function pullSession(client: SessionClient, params: ShareParams, deps: PullDeps): Promise<number> {
+export async function pullSession(
+  client: SessionClient,
+  params: ShareParams,
+  deps: PullDeps,
+): Promise<number> {
   const session = await pickSharedSession(client, params.sessionId);
   if (!session) {
     deps.out("no shared plan to pull - run `cueloop share` first");
@@ -82,19 +103,27 @@ export async function pullSession(client: SessionClient, params: ShareParams, de
     participants: remote.participants,
   });
   const added = merged.annotations.length - before;
-  deps.out(added > 0 ? `pulled ${added} new annotation${added === 1 ? "" : "s"}` : "no new annotations");
+  deps.out(
+    added > 0 ? `pulled ${added} new annotation${added === 1 ? "" : "s"}` : "no new annotations",
+  );
   return 0;
 }
 
 /** The named session, or the most recent one when no id is given. */
-async function pickSession(client: SessionClient, sessionId?: string): Promise<ReviewSession | null> {
+async function pickSession(
+  client: SessionClient,
+  sessionId?: string,
+): Promise<ReviewSession | null> {
   if (sessionId) return client.sessionGet(sessionId);
   const sessions = await client.sessionList();
   return sessions.at(-1) ?? null;
 }
 
 /** The named session (if shared), or the most recent shared one. */
-async function pickSharedSession(client: SessionClient, sessionId?: string): Promise<ReviewSession | null> {
+async function pickSharedSession(
+  client: SessionClient,
+  sessionId?: string,
+): Promise<ReviewSession | null> {
   if (sessionId) {
     const session = await client.sessionGet(sessionId);
     return session.shareId ? session : null;

package/src/wake-command.test.ts

@@ -0,0 +1,14 @@
+/** cueloop wake argument guards: a missing session id and a codex wake without a thread id both fail with a usage code before any daemon or harness work. */
+
+import { describe, expect, test } from "bun:test";
+import { wakeCommand } from "./wake-command";
+
+describe("wakeCommand argument guards", () => {
+  test("a missing session id is a usage error", async () => {
+    expect(await wakeCommand([])).toBe(2);
+  });
+
+  test("a codex wake without a thread id is a usage error", async () => {
+    expect(await wakeCommand(["ses_1", "--harness", "codex"])).toBe(2);
+  });
+});

package/src/wake-command.ts

@@ -0,0 +1,37 @@
+/**
+ * `cueloop wake <session-id>` - the production caller for the non-blocking wake.
+ * A detached child of a coding-agent session parks on the review's verdict and
+ * injects it back into that same live session when the human decides, so the
+ * agent resumes itself without a blocked, pinned tool call. The plan skill (and
+ * the Claude Code hook's non-blocking path) spawn this right after a
+ * non-blocking review:  `cueloop wake <session-id> &`.
+ *
+ * Claude Code is the default and reads its inbox socket from the environment.
+ * Codex needs its running thread id (`--harness codex --thread <thread-id>`).
+ * pi wakes in-process from its extension and does not use this command.
+ */
+
+import { parseArgs, stringFlag } from "./args";
+
+export async function wakeCommand(argv: string[]): Promise<number> {
+  const { positional, flags } = parseArgs(argv);
+  const sessionId = positional[0];
+  if (sessionId === undefined) {
+    console.error(
+      "usage: cueloop wake <session-id> [--harness claude-code|codex] [--thread <codex-thread-id>]",
+    );
+    return 2;
+  }
+  const harness = stringFlag(flags, "harness") ?? "claude-code";
+  if (harness === "codex") {
+    const threadId = stringFlag(flags, "thread");
+    if (threadId === undefined) {
+      console.error("cueloop wake --harness codex needs --thread <codex-thread-id>");
+      return 2;
+    }
+    const { runCodexWake } = await import("@cueloop/adapters/codex/wake");
+    return (await runCodexWake(sessionId, threadId)) ? 0 : 1;
+  }
+  const { runInboxWake } = await import("@cueloop/adapters/claude-code/wake");
+  return (await runInboxWake(sessionId)) ? 0 : 1;
+}

package/src/working-tree.ts

@@ -1,27 +1,100 @@
 /** Working-tree diff capture for `cueloop diff`, untracked files included. */
 
+import { join } from "node:path";
+import type { DiffFileContents } from "@cueloop/schema";
+
 async function git(args: string[], cwd: string): Promise<string | null> {
-  const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
-  const out = await new Response(proc.stdout).text();
-  if ((await proc.exited) !== 0) return null;
-  return out.trim();
+  const gitProcess = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+  const stdout = await new Response(gitProcess.stdout).text();
+  if ((await gitProcess.exited) !== 0) return null;
+  return stdout.trim();
+}
+
+/** The blob at HEAD for a path, or "" when the path is not in HEAD (new file). */
+async function headContents(path: string, cwd: string): Promise<string> {
+  const gitProcess = Bun.spawn(["git", "show", `HEAD:${path}`], {
+    cwd,
+    stdout: "pipe",
+    stderr: "ignore",
+  });
+  const stdout = await new Response(gitProcess.stdout).text();
+  return (await gitProcess.exited) === 0 ? stdout : "";
+}
+
+/** The working-tree file, or "" when it is gone (deleted). */
+async function workingContents(path: string, cwd: string): Promise<string> {
+  try {
+    return await Bun.file(join(cwd, path)).text();
+  } catch {
+    return "";
+  }
+}
+
+/** A NUL byte marks content git would treat as binary - not text-curatable. */
+function looksBinary(text: string): boolean {
+  for (let index = 0; index < text.length; index++) {
+    if (text.charCodeAt(index) === 0) return true;
+  }
+  return false;
+}
+
+/**
+ * Full old/new contents for every tracked change against HEAD, classified by
+ * git's own status letter. Renames/copies and binary files are omitted: a
+ * path+text pair cannot express a rename header or a binary blob, so curation
+ * would emit a patch that drops the old path or corrupts the file - leaving them
+ * out keeps those changes in the patch but simply not curatable. The
+ * NUL-delimited stream survives paths with spaces or unicode.
+ */
+async function trackedFileContents(cwd: string): Promise<DiffFileContents[]> {
+  const nameStatus = (await git(["diff", "HEAD", "--name-status", "-z"], cwd)) ?? "";
+  const tokens = nameStatus.split("\0").filter((token) => token.length > 0);
+  const files: DiffFileContents[] = [];
+  let cursor = 0;
+  while (cursor < tokens.length) {
+    const code = tokens[cursor++]![0];
+    if (code === "R" || code === "C") {
+      cursor += 2;
+      continue;
+    }
+    const path = tokens[cursor++]!;
+    const oldContents = code === "A" ? "" : await headContents(path, cwd);
+    const newContents = code === "D" ? "" : await workingContents(path, cwd);
+    if (looksBinary(oldContents) || looksBinary(newContents)) continue;
+    const status = code === "A" ? "added" : code === "D" ? "deleted" : "modified";
+    files.push({ path, oldContents, newContents, status });
+  }
+  return files;
+}
+
+export interface WorkingTreeDiff {
+  patch: string;
+  /** Full file contents per curatable changed file, keeping curation applyable. */
+  files: DiffFileContents[];
 }
 
-export async function workingTreeDiff(cwd = process.cwd()): Promise<string> {
+export async function workingTreeDiff(cwd = process.cwd()): Promise<WorkingTreeDiff> {
   const tracked = (await git(["diff", "HEAD"], cwd)) ?? "";
+  const files = await trackedFileContents(cwd);
   // untracked files included by default
   const untrackedList = (await git(["ls-files", "--others", "--exclude-standard"], cwd)) ?? "";
   let untracked = "";
   for (const file of untrackedList.split("\n").filter(Boolean)) {
     // `git diff --no-index` exits 1 when the files differ - that is success here
-    const proc = Bun.spawn(["git", "diff", "--no-index", "--", "/dev/null", file], {
+    const gitProcess = Bun.spawn(["git", "diff", "--no-index", "--", "/dev/null", file], {
       cwd,
       stdout: "pipe",
       stderr: "ignore",
     });
-    const out = await new Response(proc.stdout).text();
-    const code = await proc.exited;
-    if ((code === 0 || code === 1) && out.trim()) untracked += out.trim() + "\n";
+    const stdout = await new Response(gitProcess.stdout).text();
+    const code = await gitProcess.exited;
+    if ((code === 0 || code === 1) && stdout.trim()) {
+      untracked += stdout.trim() + "\n";
+      const newContents = await workingContents(file, cwd);
+      if (!looksBinary(newContents)) {
+        files.push({ path: file, oldContents: "", newContents, status: "added" });
+      }
+    }
   }
-  return [tracked, untracked].filter(Boolean).join("\n");
+  return { patch: [tracked, untracked].filter(Boolean).join("\n"), files };
 }