cueloop 0.1.0-alpha.69 → 0.1.0-alpha.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.69",
+  "version": "0.1.0-alpha.70",
   "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": {
@@ -30,10 +30,10 @@
     "build:binary": "bun build --compile --external cpu-features ./src/main.ts --outfile dist/cueloop"
   },
   "dependencies": {
-    "@cueloop/adapters": "0.1.0-alpha.69",
-    "@cueloop/client": "0.1.0-alpha.69",
-    "@cueloop/daemon": "0.1.0-alpha.69",
-    "@cueloop/schema": "0.1.0-alpha.69",
+    "@cueloop/adapters": "0.1.0-alpha.70",
+    "@cueloop/client": "0.1.0-alpha.70",
+    "@cueloop/daemon": "0.1.0-alpha.70",
+    "@cueloop/schema": "0.1.0-alpha.70",
     "valibot": "^1.4.2"
   },
   "engines": {

package/src/main.ts

@@ -24,7 +24,7 @@ import { sessionCommand } from "./session-commands";
 import { CLI_VERSION } from "./version";
 import { DaemonClient } from "@cueloop/daemon/client";
 import { workingTreeDiff } from "@cueloop/daemon/working-tree";
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 import { openReview, resolveWorkspace } from "@cueloop/daemon/review";
 
 const argv = process.argv.slice(2);
@@ -162,13 +162,13 @@ function openSelector(parsed: ParsedArgs): string | undefined {
  * one caller that needs a scope-specific hint (a clean working tree).
  */
 async function openReviewOfKind(
-  match: (session: ReviewSession) => boolean,
+  match: (session: Thread) => boolean,
   label: string,
   selector: string | undefined,
   emptyMessage?: string,
 ): Promise<number> {
   const client = await DaemonClient.connect({ autostart: true });
-  let sessions: ReviewSession[];
+  let sessions: Thread[];
 
   try {
     sessions = await client.sessionList();

package/src/open-target.test.ts

@@ -1,7 +1,7 @@
 /** Primitive-first open resolution over a plain session list: latest-pending default, by-id, and fuzzy-by-title (exact wins, unique substring wins, else ambiguous). Pure over the array - no daemon, no TUI. */
 
 import { describe, expect, test } from "bun:test";
-import type { ArtifactType, ReviewSession } from "@cueloop/schema";
+import type { ArtifactType, Thread } from "@cueloop/schema";
 import {
   isDiffReview,
   isPlanReview,
@@ -20,7 +20,7 @@ function session(overrides: {
   status?: "pending" | "resolved";
   createdAt?: string;
   pr?: string;
-}): ReviewSession {
+}): Thread {
   return {
     schemaVersion: "1",
     id: overrides.id,

package/src/open-target.ts

@@ -16,7 +16,7 @@
  * ever resolves to its own artifact kind.
  */
 
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 
 /**
  * The primitive scopes, kept disjoint on purpose so a single session never resolves
@@ -25,19 +25,19 @@ import type { ReviewSession } from "@cueloop/schema";
  * diff scope must exclude those - otherwise `cueloop diff` and `cueloop
  * review` would both open the same pending PR review.
  */
-export function isPlanReview(session: ReviewSession): boolean {
+export function isPlanReview(session: Thread): boolean {
   return session.artifact.type === "plan";
 }
-export function isReplyReview(session: ReviewSession): boolean {
+export function isReplyReview(session: Thread): boolean {
   return session.artifact.type === "reply";
 }
-export function isPrototypeReview(session: ReviewSession): boolean {
+export function isPrototypeReview(session: Thread): boolean {
   return session.artifact.type === "prototype";
 }
-export function isDiffReview(session: ReviewSession): boolean {
+export function isDiffReview(session: Thread): boolean {
   return session.artifact.type === "diff" && session.artifact.meta.pr === undefined;
 }
-export function isPrReview(session: ReviewSession): boolean {
+export function isPrReview(session: Thread): boolean {
   return session.artifact.type === "diff" && session.artifact.meta.pr !== undefined;
 }
 
@@ -48,7 +48,7 @@ export function isSessionId(value: string): boolean {
 
 export interface OpenTargetQuery {
   /** Only sessions this predicate accepts are eligible - the primitive's artifact scope. */
-  match: (session: ReviewSession) => boolean;
+  match: (session: Thread) => boolean;
   /** Positional id-or-title selector; absent means "latest pending". */
   selector?: string;
 }
@@ -60,11 +60,11 @@ export type OpenTarget =
   | { kind: "ambiguous"; selector: string; titles: string[] };
 
 /** Most-recent-first, so the head of a sorted list is always the latest. */
-function newestFirst(left: ReviewSession, right: ReviewSession): number {
+function newestFirst(left: Thread, right: Thread): number {
   return right.createdAt.localeCompare(left.createdAt);
 }
 
-export function resolveOpenTarget(sessions: ReviewSession[], query: OpenTargetQuery): OpenTarget {
+export function resolveOpenTarget(sessions: Thread[], query: OpenTargetQuery): OpenTarget {
   const scoped = sessions.filter(query.match);
 
   if (query.selector === undefined) {

package/src/pr.ts

@@ -6,7 +6,7 @@
  * half for agents and scripts.
  */
 
-import type { ReviewSession, VerdictKind } from "@cueloop/schema";
+import type { Thread, VerdictKind } from "@cueloop/schema";
 import { DaemonClient } from "@cueloop/daemon/client";
 import { openReview } from "@cueloop/daemon/review";
 import { parseArgs } from "./args";
@@ -116,7 +116,7 @@ export async function reviewPostCommand(argv: string[]): Promise<number> {
   return postVerdict(session, pr);
 }
 
-async function getSession(id: string): Promise<ReviewSession> {
+async function getSession(id: string): Promise<Thread> {
   const client = await DaemonClient.connect({ autostart: true });
 
   try {
@@ -127,7 +127,7 @@ 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> {
+async function postVerdict(session: Thread, pr: string): Promise<number> {
   const verdict = session.verdict!;
   const result = await gh([
     "pr",

package/src/refine-command.test.ts

@@ -4,8 +4,8 @@ import { describe, expect, test } from "bun:test";
 import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { Annotation, ReviewSession, Verdict, VerdictKind } from "@cueloop/schema";
-import { SessionStore } from "@cueloop/daemon/store";
+import type { Annotation, Thread, Verdict, VerdictKind } from "@cueloop/schema";
+import { ThreadStore } from "@cueloop/daemon/store";
 import { reportsDir } from "@cueloop/daemon/paths";
 import { buildRefineReport, refineCommand } from "./refine-command";
 
@@ -29,8 +29,8 @@ function verdict(kind: VerdictKind): Verdict {
 
 function session(
   id: string,
-  overrides: Partial<ReviewSession> & { type?: ReviewSession["artifact"]["type"] } = {},
-): ReviewSession {
+  overrides: Partial<Thread> & { type?: Thread["artifact"]["type"] } = {},
+): Thread {
   const { type, ...rest } = overrides;
 
   return {
@@ -87,7 +87,7 @@ describe("refineCommand", () => {
   test("writes a report, skips signal-free sessions, and consumes only resolved sessions", async () => {
     // Arrange
     const home = tempHome();
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
 
     store.upsert(session("ses_a", { verdict: verdict("approve"), status: "resolved" }));
     store.upsert(
@@ -120,7 +120,7 @@ describe("refineCommand", () => {
   test("re-analyzes a resolved session that is reopened and resolved again with new feedback", async () => {
     // Arrange
     const home = tempHome();
-    const store = new SessionStore(home);
+    const store = new ThreadStore(home);
 
     store.upsert(
       session("ses_x", {

package/src/refine-command.ts

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { cueloopHome, reportsDir } from "@cueloop/daemon/paths";
-import { SessionStore } from "@cueloop/daemon/store";
+import { ThreadStore } from "@cueloop/daemon/store";
 import {
   LATEST_REPORT_FILENAME,
   parseRefineState,
@@ -9,7 +9,7 @@ import {
   resolveCleanupPeriodDays,
   timestampedReportFilename,
 } from "@cueloop/daemon/retention";
-import { isAgentNote, type Annotation, type ReviewSession } from "@cueloop/schema";
+import { isAgentNote, type Annotation, type Thread } from "@cueloop/schema";
 import { parseArgs, stringFlag } from "./args";
 
 const DEFAULT_SESSION_LIMIT = 200;
@@ -18,7 +18,7 @@ const BODY_LIMIT = 100;
 
 interface AnnotatedEntry {
   annotation: Annotation;
-  session: ReviewSession;
+  session: Thread;
 }
 
 export async function refineCommand(argv: string[]): Promise<number> {
@@ -27,7 +27,7 @@ export async function refineCommand(argv: string[]): Promise<number> {
   const limit = parseLimit(stringFlag(flags, "limit"));
   const nowMs = Date.now();
 
-  const store = new SessionStore(home);
+  const store = new ThreadStore(home);
 
   store.recover();
   const all = store.list();
@@ -72,7 +72,7 @@ export async function refineCommand(argv: string[]): Promise<number> {
 }
 
 export function buildRefineReport(
-  analyzed: ReviewSession[],
+  analyzed: Thread[],
   totalCount: number,
   generatedAt: string,
 ): string {
@@ -137,13 +137,13 @@ export function buildRefineReport(
   return lines.join("\n");
 }
 
-function hasReviewSignal(session: ReviewSession): boolean {
+function hasReviewSignal(session: Thread): boolean {
   return (
     session.verdict !== null || session.annotations.some((annotation) => !isAgentNote(annotation))
   );
 }
 
-function flattenReviewAnnotations(sessions: ReviewSession[]): AnnotatedEntry[] {
+function flattenReviewAnnotations(sessions: Thread[]): AnnotatedEntry[] {
   const entries: AnnotatedEntry[] = [];
 
   for (const session of sessions) {
@@ -194,13 +194,13 @@ function tally<T>(items: T[], keyOf: (item: T) => string): Map<string, number> {
   return counts;
 }
 
-function primitiveLabel(session: ReviewSession): string {
+function primitiveLabel(session: Thread): string {
   if (session.artifact.type === "diff" && session.artifact.meta.pr) return "pull request";
 
   return session.artifact.type;
 }
 
-function verdictLabel(session: ReviewSession): string {
+function verdictLabel(session: Thread): string {
   switch (session.verdict?.kind) {
     case "approve":
       return "approve";
@@ -239,7 +239,7 @@ function parseLimit(raw: string | undefined): number {
   return Number.isInteger(value) && value > 0 ? value : DEFAULT_SESSION_LIMIT;
 }
 
-function analysisFingerprint(session: ReviewSession): string {
+function analysisFingerprint(session: Thread): string {
   return `${session.revisions.length}:${session.annotations.length}:${session.verdict?.resolvedAt ?? "pending"}`;
 }
 

package/src/share-command.test.ts

@@ -4,12 +4,12 @@ import {
   historyFromLinear,
   SCHEMA_VERSION,
   type Annotation,
-  type ReviewSession,
+  type Thread,
 } from "@cueloop/schema";
 import type { SessionClient } from "@cueloop/daemon/client";
 import { pullSession, shareSession, type PullDeps, type ShareDeps } from "./share-command";
 
-function sessionFixture(id: string, overrides: Partial<ReviewSession> = {}): ReviewSession {
+function sessionFixture(id: string, overrides: Partial<Thread> = {}): Thread {
   return {
     schemaVersion: SCHEMA_VERSION,
     id,
@@ -40,12 +40,13 @@ const unimplemented = (member: string) => () =>
   Promise.reject(new Error(`fakeClient does not implement ${member}`));
 
 /** A SessionClient that answers get/list from a fixed list and records the share/merge primitives. */
-function fakeClient(sessions: ReviewSession[]): SessionClient {
+function fakeClient(sessions: Thread[]): SessionClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async (id: string) => sessions.find((session) => session.id === id)!,
     sessionList: async () => sessions,
+    sessionComment: unimplemented("sessionComment"),
     sessionAnnotate: unimplemented("sessionAnnotate"),
     sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
     sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
@@ -113,7 +114,7 @@ describe(shareSession, () => {
   test("publishes the named session and reports the copied ssh line", async () => {
     // Arrange
     const publish = mock(
-      async (session: ReviewSession) => (
+      async (session: Thread) => (
         expect(session.id).toBe("ses_2"),
         { line: "ssh p_abc123xy@cueloop.dev", copied: true }
       ),
@@ -135,7 +136,7 @@ describe(shareSession, () => {
   test("without an id, shares the most recent session", async () => {
     // Arrange
     const publish = mock(
-      async (session: ReviewSession) => (
+      async (session: Thread) => (
         expect(session.id).toBe("ses_2"),
         { line: "ssh p_zzzzzzzz@cueloop.dev", copied: true }
       ),
@@ -211,7 +212,7 @@ describe(shareSession, () => {
   });
 });
 
-function pullDepsSpy(remote: ReviewSession): PullDeps & { lines: string[] } {
+function pullDepsSpy(remote: Thread): PullDeps & { lines: string[] } {
   const lines: string[] = [];
 
   return {

package/src/share-command.ts

@@ -15,7 +15,7 @@ import {
   type ShareResult,
   type ShareTarget,
 } from "@cueloop/client";
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 
 export interface ShareParams {
   sessionId?: string;
@@ -27,12 +27,12 @@ export interface ShareParams {
 }
 
 export interface ShareDeps {
-  publish: (session: ReviewSession, target: ShareTarget) => Promise<ShareResult>;
+  publish: (session: Thread, target: ShareTarget) => Promise<ShareResult>;
   out: (message: string) => void;
 }
 
 export interface PullDeps {
-  pull: (shareId: string, target: ShareTarget) => Promise<ReviewSession>;
+  pull: (shareId: string, target: ShareTarget) => Promise<Thread>;
   out: (message: string) => void;
 }
 
@@ -122,10 +122,7 @@ export async function pullSession(
 }
 
 /** 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<Thread | null> {
   if (sessionId) return client.sessionGet(sessionId);
   const sessions = await client.sessionList();
 
@@ -136,7 +133,7 @@ async function pickSession(
 async function pickSharedSession(
   client: SessionClient,
   sessionId?: string,
-): Promise<ReviewSession | null> {
+): Promise<Thread | null> {
   if (sessionId) {
     const session = await client.sessionGet(sessionId);