@cueloop/daemon 0.1.0-alpha.91 → 0.1.0-alpha.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.91",
+  "version": "0.1.0-alpha.93",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -39,8 +39,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/extension-api": "0.1.0-alpha.91",
-    "@cueloop/schema": "0.1.0-alpha.91",
+    "@cueloop/extension-api": "0.1.0-alpha.93",
+    "@cueloop/schema": "0.1.0-alpha.93",
     "@pierre/diffs": "^1.4.1",
     "effect": "^4.0.0-rc.116",
     "smol-toml": "^1.8.0",

package/src/client.ts

@@ -86,6 +86,7 @@ const HerdrThreadSurfaceResultSchema = v.nullable(
     tabId: v.string(),
     paneId: v.string(),
     mode: v.optional(v.picklist(["tab", "pane"])),
+    layout: v.optional(v.literal("pair")),
   }),
 );
 const GhosttyThreadSurfaceResultSchema = v.nullable(v.object({ terminalId: v.string() }));

package/src/diff-watcher.ts

@@ -163,6 +163,9 @@ export class DiffWatcher {
           if (isRefChange(filename)) this.scheduleRepoRefresh(repoRoot);
         });
     }
+
+    // Reconcile changes made while the platform activates its new watch.
+    this.scheduleRepoRefresh(repoRoot);
   }
 
   private startJjPoll(repoWatch: RepoWatch, repoRoot: string, sessionId: string): void {

package/src/herdr-thread-surface-store.ts

@@ -5,6 +5,7 @@ import { herdrThreadSurfacesPath } from "./paths";
 /** Herdr-native handle, stored outside the canonical Thread. */
 export interface HerdrThreadSurfaceHandle {
   mode?: "tab" | "pane";
+  layout?: "pair";
   tabId: string;
   paneId: string;
 }
@@ -13,6 +14,7 @@ const HerdrThreadSurfaceHandleSchema = v.object({
   tabId: v.string(),
   paneId: v.string(),
   mode: v.optional(v.picklist(["tab", "pane"])),
+  layout: v.optional(v.literal("pair")),
 });
 const HerdrThreadSurfaceMapSchema = v.record(v.string(), v.unknown());
 

package/src/herdr-thread-surface.test.ts

@@ -358,6 +358,60 @@ describe("openHerdrThreadSurface", () => {
     expect(store.saved()).toEqual({ tabId: "w9:t9", paneId: "w9:p9" });
   });
 
+  test("opens a tab when the recorded live surface is a pane", async () => {
+    const stub = makeStub("pane-to-tab", true);
+    const herdrEnvironment = {
+      HERDR_ENV: "1",
+      HERDR_PANE_ID: "w1:p1",
+      HERDR_BIN_PATH: stub.binPath,
+    };
+    const store = fakePersistence({ mode: "pane", tabId: "w1:t1", paneId: "w1:p3" });
+
+    expect(
+      await openHerdrThreadSurface(
+        newSession(),
+        store.persistence,
+        herdrEnvironment,
+        "tab",
+        "pair",
+      ),
+    ).toBe("opened");
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop pair ses_new1",
+      "pane send-keys w1:p2 enter",
+      "pane close w1:p3",
+    ]);
+    expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2", layout: "pair" });
+  });
+
+  test("replaces a generic review tab with the pairing layout", async () => {
+    const stub = makeStub("review-to-pair", true);
+    const herdrEnvironment = {
+      HERDR_ENV: "1",
+      HERDR_PANE_ID: "w1:p1",
+      HERDR_BIN_PATH: stub.binPath,
+    };
+    const store = fakePersistence({ tabId: "w9:t9", paneId: "w9:p9" });
+
+    expect(
+      await openHerdrThreadSurface(
+        newSession(),
+        store.persistence,
+        herdrEnvironment,
+        "tab",
+        "pair",
+      ),
+    ).toBe("opened");
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop pair ses_new1",
+      "pane send-keys w1:p2 enter",
+      "tab close w9:t9",
+    ]);
+    expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2", layout: "pair" });
+  });
+
   test("a persistence failure never escapes - review creation stays best-effort", async () => {
     const stub = makeStub("gated-persist-fail");
     const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };

package/src/herdr-thread-surface.ts

@@ -60,6 +60,7 @@ export interface OpenHerdrThreadTabOptions {
   binPath: string;
   label: string;
   workspaceId?: string;
+  layout?: "pair";
 }
 
 /** Daemon-owned native handles, separate from canonical Thread records. */
@@ -72,7 +73,7 @@ export interface HerdrThreadSurfacePersistence {
 export function openHerdrThreadTab(
   options: OpenHerdrThreadTabOptions,
 ): HerdrThreadSurfaceHandle | null {
-  const { sessionId, cwd, binPath, label, workspaceId } = options;
+  const { sessionId, cwd, binPath, label, workspaceId, layout } = options;
 
   try {
     const created = runHerdrCommand(
@@ -99,13 +100,13 @@ export function openHerdrThreadTab(
 
     if (!paneId || !tabId) return null;
 
-    if (!sendCueloopThreadCommand(binPath, paneId, sessionId)) {
-      closeUnlaunchedHerdrSurface(binPath, "tab", tabId);
+    if (!sendCueloopThreadCommand(binPath, paneId, sessionId, layout)) {
+      closeHerdrThreadSurface(binPath, "tab", tabId);
 
       return null;
     }
 
-    return { tabId, paneId };
+    return { tabId, paneId, ...(layout && { layout }) };
   } catch {
     return null;
   }
@@ -118,13 +119,14 @@ export interface OpenHerdrThreadPaneOptions {
   binPath: string;
   sourcePaneId: string;
   tabId: string;
+  layout?: "pair";
 }
 
 /** Split the calling Herdr pane right at 50 percent and launch cueloop in it. */
 export function openHerdrThreadPane(
   options: OpenHerdrThreadPaneOptions,
 ): HerdrThreadSurfaceHandle | null {
-  const { sessionId, cwd, binPath, sourcePaneId, tabId } = options;
+  const { sessionId, cwd, binPath, sourcePaneId, tabId, layout } = options;
 
   try {
     const created = runHerdrCommand(
@@ -149,19 +151,19 @@ export function openHerdrThreadPane(
     const paneId = parsed.success ? parsed.output.result?.pane?.pane_id : undefined;
 
     if (!paneId) return null;
-    if (!sendCueloopThreadCommand(binPath, paneId, sessionId)) {
-      closeUnlaunchedHerdrSurface(binPath, "pane", paneId);
+    if (!sendCueloopThreadCommand(binPath, paneId, sessionId, layout)) {
+      closeHerdrThreadSurface(binPath, "pane", paneId);
 
       return null;
     }
 
-    return { mode: "pane", tabId, paneId };
+    return { mode: "pane", tabId, paneId, ...(layout && { layout }) };
   } catch {
     return null;
   }
 }
 
-function closeUnlaunchedHerdrSurface(binPath: string, kind: "tab" | "pane", id: string): void {
+function closeHerdrThreadSurface(binPath: string, kind: "tab" | "pane", id: string): void {
   try {
     runHerdrCommand([binPath, kind, "close", id], {
       stdout: "ignore",
@@ -173,8 +175,14 @@ function closeUnlaunchedHerdrSurface(binPath: string, kind: "tab" | "pane", id:
   }
 }
 
-function sendCueloopThreadCommand(binPath: string, paneId: string, sessionId: string): boolean {
-  const typed = runHerdrCommand([binPath, "pane", "send-text", paneId, `cueloop ${sessionId}`], {
+function sendCueloopThreadCommand(
+  binPath: string,
+  paneId: string,
+  sessionId: string,
+  layout?: "pair",
+): boolean {
+  const command = layout === "pair" ? `cueloop pair ${sessionId}` : `cueloop ${sessionId}`;
+  const typed = runHerdrCommand([binPath, "pane", "send-text", paneId, command], {
     stdout: "ignore",
     stderr: "ignore",
     timeout: HERDR_SPAWN_TIMEOUT_MS,
@@ -292,6 +300,7 @@ export async function openHerdrThreadSurface(
   persistence: HerdrThreadSurfacePersistence,
   env: HerdrEnv = process.env,
   mode: HerdrThreadSurface = loadHerdrThreadSurface(),
+  layout?: "pair",
 ): Promise<ThreadSurfaceOpenStatus> {
   const herdr = detectHerdr(env);
 
@@ -300,7 +309,12 @@ export async function openHerdrThreadSurface(
   if (mode === "none") return "disabled";
   const recorded = await recallHerdrThreadSurface(persistence, session.id);
 
-  if (recorded && herdrPaneAlive(herdr.binPath, recorded.paneId)) {
+  if (
+    recorded &&
+    (recorded.mode ?? "tab") === mode &&
+    recorded.layout === layout &&
+    herdrPaneAlive(herdr.binPath, recorded.paneId)
+  ) {
     return focusHerdrThreadSurface(herdr.binPath, recorded) ? "focused" : "failed";
   }
   const cwd = session.artifact.meta.cwd ?? session.workspace.repoRoot;
@@ -313,6 +327,7 @@ export async function openHerdrThreadSurface(
             binPath: herdr.binPath,
             sourcePaneId: herdr.paneId,
             tabId: env.HERDR_TAB_ID,
+            layout,
           })
         : null
       : openHerdrThreadTab({
@@ -321,9 +336,17 @@ export async function openHerdrThreadSurface(
           binPath: herdr.binPath,
           label: session.artifact.meta.title ?? session.id,
           workspaceId: env.HERDR_WORKSPACE_ID,
+          layout,
         });
 
   if (!opened) return "failed";
+  if (recorded && recorded.paneId !== opened.paneId) {
+    closeHerdrThreadSurface(
+      herdr.binPath,
+      recorded.mode === "pane" ? "pane" : "tab",
+      recorded.mode === "pane" ? recorded.paneId : recorded.tabId,
+    );
+  }
   await rememberHerdrThreadSurface(persistence, session.id, opened);
 
   return "opened";

package/src/project-files.test.ts

@@ -41,6 +41,16 @@ describe("listProjectFiles", () => {
     expect(files).toEqual(["a.ts", "m.ts", "z.ts"]);
   });
 
+  test("omits a tracked file deleted from the working tree", async () => {
+    writeFileSync(join(repo, "keep.ts"), "export const keep = true;\n");
+    writeFileSync(join(repo, "gone.ts"), "export const gone = true;\n");
+    git(["add", "."], repo);
+    git(["commit", "-qm", "init"], repo);
+    rmSync(join(repo, "gone.ts"));
+
+    expect(await listProjectFiles(repo)).toEqual(["keep.ts"]);
+  });
+
   test("returns [] for a directory that is not a git repo", async () => {
     // Given a plain directory with a file but no git repo
     const plain = mkdtempSync(join(tmpdir(), "cueloop-project-files-plain-"));

package/src/project-files.ts

@@ -8,20 +8,32 @@ const MAX_FILES = 5000;
 /** Ceiling on a served file; the panel renders source, not multi-megabyte blobs. */
 const MAX_FILE_BYTES = 1024 * 1024;
 
-/** Tracked, repo-relative paths from `git ls-files`, sorted ascending and capped; [] on any failure or non-repo. */
+async function gitFileList(repoRoot: string, args: string[]): Promise<string[] | null> {
+  const gitProcess = Bun.spawn(["git", "-C", repoRoot, "ls-files", "-z", ...args], {
+    stdout: "pipe",
+    stderr: "ignore",
+  });
+  const stdout = await new Response(gitProcess.stdout).text();
+
+  return (await gitProcess.exited) === 0 ? stdout.split("\0").filter(Boolean) : null;
+}
+
+/** Existing tracked paths, sorted ascending and capped; [] on failure or a non-repo. */
 export async function listProjectFiles(repoRoot: string | undefined): Promise<string[]> {
   if (repoRoot === undefined || repoRoot.length === 0) return [];
   try {
-    const gitProcess = Bun.spawn(["git", "-C", repoRoot, "ls-files", "-z"], {
-      stdout: "pipe",
-      stderr: "ignore",
-    });
-    const stdout = await new Response(gitProcess.stdout).text();
+    const [tracked, deleted] = await Promise.all([
+      gitFileList(repoRoot, ["--cached"]),
+      gitFileList(repoRoot, ["--deleted"]),
+    ]);
 
-    if ((await gitProcess.exited) !== 0) return [];
-    const paths = stdout.split("\0").filter((path) => path.length > 0);
+    if (tracked === null || deleted === null) return [];
+    const missing = new Set(deleted);
 
-    return paths.toSorted().slice(0, MAX_FILES);
+    return tracked
+      .filter((path) => !missing.has(path))
+      .toSorted()
+      .slice(0, MAX_FILES);
   } catch {
     return [];
   }

package/src/server.ts

@@ -550,6 +550,7 @@ export class DaemonServer {
         tabId: params.tabId,
         paneId: params.paneId,
         mode: params.mode,
+        layout: params.layout,
       });
 
       return {};

package/src/validate.ts

@@ -353,6 +353,7 @@ export const Params = {
     tabId: NonEmpty,
     paneId: NonEmpty,
     mode: v.optional(v.picklist(["tab", "pane"])),
+    layout: v.optional(v.literal("pair")),
   }),
   "ghostty.getThreadSurface": v.object({ id: SessionId }),
   "ghostty.setThreadSurface": v.object({ id: SessionId, terminalId: NonEmpty }),