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

package/src/harness-state-store.ts

@@ -0,0 +1,182 @@
+/**
+ * Durable harness routing state. Bindings identify where a Thread came from;
+ * deliveries record which Message still needs to reach that binding. Keeping
+ * both outside Thread records prevents harness identity from leaking into the
+ * product primitive and makes redelivery independent of the review lifecycle.
+ */
+
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import type { Delivery, HarnessBinding } from "@cueloop/schema";
+import * as v from "valibot";
+import { harnessStatePath } from "./paths";
+import { DeliverySchema, HarnessBindingSchema } from "./validate";
+
+type BindInput = Pick<HarnessBinding, "threadId" | "harness" | "harnessSessionId">;
+type EnqueueInput = Pick<Delivery, "bindingId" | "messageId">;
+
+const HarnessStateSchema = v.object({
+  bindings: v.array(HarnessBindingSchema),
+  deliveries: v.array(DeliverySchema),
+});
+const FileErrorSchema = v.object({ code: v.string() });
+
+export class HarnessStateStore {
+  private readonly path: string;
+  private bindings = new Map<string, HarnessBinding>();
+  private deliveries = new Map<string, Delivery>();
+
+  constructor(home: string) {
+    this.path = harnessStatePath(home);
+    this.load();
+  }
+
+  bind(input: BindInput): HarnessBinding {
+    const existing = [...this.bindings.values()].find(
+      (binding) =>
+        binding.threadId === input.threadId &&
+        binding.harness === input.harness &&
+        binding.harnessSessionId === input.harnessSessionId,
+    );
+
+    if (existing) return existing;
+    const binding: HarnessBinding = {
+      ...input,
+      id: newRoutingId("bind"),
+      createdAt: new Date().toISOString(),
+    };
+
+    this.bindings.set(binding.id, binding);
+    this.persist();
+
+    return binding;
+  }
+
+  binding(id: string): HarnessBinding | null {
+    return this.bindings.get(id) ?? null;
+  }
+
+  consumeApprovedRetry(bindingId: string, messageId: string): boolean {
+    const binding = this.bindings.get(bindingId);
+
+    if (!binding) throw new Error(`no harness binding ${bindingId}`);
+
+    if (binding.approvedRetryMessageId === messageId) return false;
+
+    this.bindings.set(bindingId, { ...binding, approvedRetryMessageId: messageId });
+    this.persist();
+
+    return true;
+  }
+
+  /** The first binding is the submitter; other bindings need explicit future routing. */
+  submittingBinding(threadId: string): HarnessBinding | null {
+    return [...this.bindings.values()].find((binding) => binding.threadId === threadId) ?? null;
+  }
+
+  enqueue(input: EnqueueInput): Delivery {
+    const existing = [...this.deliveries.values()].find(
+      (delivery) =>
+        delivery.bindingId === input.bindingId && delivery.messageId === input.messageId,
+    );
+
+    if (existing) return existing;
+    const delivery: Delivery = {
+      ...input,
+      id: newRoutingId("del"),
+      status: "pending",
+      createdAt: new Date().toISOString(),
+    };
+
+    this.deliveries.set(delivery.id, delivery);
+    this.persist();
+
+    return delivery;
+  }
+
+  pending(bindingId: string): Delivery[] {
+    return [...this.deliveries.values()].filter(
+      (delivery) => delivery.bindingId === bindingId && delivery.status === "pending",
+    );
+  }
+
+  /** A pending delivery keeps its Thread's immutable Message body available for redelivery. */
+  pendingThreadIds(): Set<string> {
+    const ids = new Set<string>();
+
+    for (const delivery of this.deliveries.values()) {
+      if (delivery.status !== "pending") continue;
+      const binding = this.bindings.get(delivery.bindingId);
+
+      if (binding) ids.add(binding.threadId);
+    }
+
+    return ids;
+  }
+
+  acknowledged(bindingId: string, messageId: string): boolean {
+    return [...this.deliveries.values()].some(
+      (delivery) =>
+        delivery.bindingId === bindingId &&
+        delivery.messageId === messageId &&
+        delivery.status === "acknowledged",
+    );
+  }
+
+  delivery(deliveryId: string): Delivery | null {
+    return this.deliveries.get(deliveryId) ?? null;
+  }
+
+  acknowledge(deliveryId: string, acknowledgedAt = new Date().toISOString()): Delivery {
+    const delivery = this.deliveries.get(deliveryId);
+
+    if (!delivery) throw new Error(`no delivery ${deliveryId}`);
+
+    if (delivery.status === "acknowledged") return delivery;
+    const acknowledged: Delivery = {
+      ...delivery,
+      status: "acknowledged",
+      acknowledgedAt,
+    };
+
+    this.deliveries.set(deliveryId, acknowledged);
+    this.persist();
+
+    return acknowledged;
+  }
+
+  private load(): void {
+    let serialized: string;
+
+    try {
+      serialized = readFileSync(this.path, "utf8");
+    } catch (error) {
+      const parsed = v.safeParse(FileErrorSchema, error);
+
+      if (parsed.success && parsed.output.code === "ENOENT") {
+        return;
+      }
+
+      throw error;
+    }
+
+    const state = v.parse(HarnessStateSchema, JSON.parse(serialized));
+
+    this.bindings = new Map(state.bindings.map((binding) => [binding.id, binding]));
+    this.deliveries = new Map(state.deliveries.map((delivery) => [delivery.id, delivery]));
+  }
+
+  private persist(): void {
+    const temporaryPath = this.path + ".tmp";
+    const state = {
+      bindings: [...this.bindings.values()],
+      deliveries: [...this.deliveries.values()],
+    };
+
+    writeFileSync(temporaryPath, JSON.stringify(state, null, 2));
+    renameSync(temporaryPath, this.path);
+  }
+}
+
+function newRoutingId(prefix: "bind" | "del"): string {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}

package/src/herdr-pane.test.ts

@@ -0,0 +1,240 @@
+/** Creation-side herdr pane opener: a stubbed herdr binary logs its argv, openHerdrPane returns the tab handle, and openHerdrPaneForReview opens+records for a new review, focuses a still-alive recorded tab, and reopens a dead one - collision-free by pane id. */
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Thread } from "@cueloop/schema";
+import { openHerdrPane, openHerdrPaneForReview } from "./herdr-pane";
+import type { HerdrTabPersistence } from "./herdr-pane";
+import type { HerdrTabHandle } from "./herdr-tab-store";
+
+const dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-pane-"));
+
+/**
+ * A stub herdr binary. It logs argv, prints the tab-create result carrying both
+ * pane_id and tab_id (herdr 0.8.2 shape), and answers `pane get` alive or dead
+ * per `paneAlive` so the liveness branch can be exercised.
+ */
+function makeStub(name: string, paneAlive = false) {
+  const logPath = join(dir, `${name}.log`);
+  const binPath = join(dir, `${name}.sh`);
+  const paneGet = paneAlive ? `printf '{"result":{"pane":{"pane_id":"w1:p2"}}}'` : "exit 1";
+
+  writeFileSync(
+    binPath,
+    `#!/bin/sh
+printf '%s\\n' "$*" >> "${logPath}"
+if [ "$1" = "tab" ] && [ "$2" = "create" ]; then
+  printf '{"result":{"root_pane":{"pane_id":"w1:p2","tab_id":"w1:t2"}}}'
+fi
+if [ "$1" = "pane" ] && [ "$2" = "get" ]; then ${paneGet}; fi
+exit 0
+`,
+  );
+  chmodSync(binPath, 0o755);
+
+  return { binPath, logPath };
+}
+
+function readLines(logPath: string): string[] {
+  if (!existsSync(logPath)) return [];
+
+  return readFileSync(logPath, "utf8").split("\n").filter(Boolean);
+}
+
+/** In-memory persistence double: records what openHerdrPaneForReview saves. */
+function fakePersistence(initial: HerdrTabHandle | null = null) {
+  let stored = initial;
+
+  return {
+    persistence: {
+      herdrGetTab: async () => stored,
+      herdrSetTab: async (_sessionId: string, handle: HerdrTabHandle) => {
+        stored = handle;
+      },
+    },
+    saved: () => stored,
+  };
+}
+
+function newSession(overrides: Partial<Thread> = {}): Thread {
+  return {
+    schemaVersion: "1",
+    id: "ses_new1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# P", meta: { cwd: "/repo/work", title: "Rollout Plan" } },
+    revisions: [{ revision: 1, content: "# P", submittedAt: "now" }],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt: "now",
+    ...overrides,
+  };
+}
+
+describe("openHerdrPane", () => {
+  test("creates a focused tab, launches the review, and returns the handle", () => {
+    // Arrange
+    const stub = makeStub("open");
+
+    // Act
+    const handle = openHerdrPane({
+      sessionId: "ses_abc",
+      cwd: "/repo/work",
+      binPath: stub.binPath,
+      label: "Rollout Plan",
+    });
+
+    // Assert
+    expect(handle).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop ses_abc",
+      "pane send-keys w1:p2 enter",
+    ]);
+  });
+
+  test("returns null and never throws on a broken binary", () => {
+    expect(
+      openHerdrPane({
+        sessionId: "ses_abc",
+        cwd: "/repo/work",
+        binPath: join(dir, "missing-bin"),
+        label: "x",
+      }),
+    ).toBeNull();
+  });
+
+  test("returns null when tab create yields no ids - no send-text, no send-keys", () => {
+    // Arrange
+    const logPath = join(dir, "nopane.log");
+    const binPath = join(dir, "nopane.sh");
+
+    writeFileSync(
+      binPath,
+      `#!/bin/sh\nprintf '%s\\n' "$*" >> "${logPath}"\nprintf '{"result":{}}'\n`,
+    );
+    chmodSync(binPath, 0o755);
+
+    // Act
+    const handle = openHerdrPane({ sessionId: "ses_abc", cwd: "/repo/work", binPath, label: "x" });
+
+    // Assert
+    expect(handle).toBeNull();
+    expect(readLines(logPath)).toEqual(["tab create --cwd /repo/work --label x --focus"]);
+  });
+});
+
+describe("openHerdrPaneForReview", () => {
+  test("opens and records a tab for a review with no recorded tab", async () => {
+    // Arrange
+    const stub = makeStub("gated-new");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const store = fakePersistence(null);
+
+    // Act
+    await openHerdrPaneForReview(newSession({ id: "ses_xyz" }), store.persistence, env);
+
+    // Assert
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop ses_xyz",
+      "pane send-keys w1:p2 enter",
+    ]);
+    expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+  });
+
+  test("no-op outside herdr - no herdr process is spawned", async () => {
+    // Arrange
+    const stub = makeStub("gated-outside");
+    const store = fakePersistence(null);
+
+    // Act
+    await openHerdrPaneForReview(newSession(), store.persistence, {
+      HERDR_PANE_ID: "w1:p1",
+      HERDR_BIN_PATH: stub.binPath,
+    });
+
+    // Assert
+    expect(existsSync(stub.logPath)).toBeFalse();
+    expect(store.saved()).toBeNull();
+  });
+
+  test("focuses the recorded tab when its pane is still alive, without reopening", async () => {
+    // Arrange
+    const stub = makeStub("gated-alive", true);
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const store = fakePersistence({ tabId: "w9:t9", paneId: "w9:p9" });
+
+    // Act
+    await openHerdrPaneForReview(newSession(), store.persistence, env);
+
+    // Assert
+    const lines = readLines(stub.logPath);
+
+    expect(lines).toContain("pane get w9:p9");
+    expect(lines).toContain("tab focus w9:t9");
+    expect(lines.some((line) => line.startsWith("tab create"))).toBeFalse();
+    expect(store.saved()).toEqual({ tabId: "w9:t9", paneId: "w9:p9" });
+  });
+
+  test("a persistence failure never escapes - review creation stays best-effort", async () => {
+    // Arrange - the daemon store rejects; the opener must still resolve quietly
+    const stub = makeStub("gated-persist-fail");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const persistence: HerdrTabPersistence = {
+      herdrGetTab: async () => null,
+      herdrSetTab: async () => {
+        throw new Error("disk full");
+      },
+    };
+
+    // Act & Assert - no throw
+    await openHerdrPaneForReview(newSession(), persistence, env);
+    expect(readLines(stub.logPath).some((line) => line.startsWith("tab create"))).toBeTrue();
+  });
+
+  test("a recall failure (stale daemon) still opens a fresh tab", async () => {
+    // Arrange - a daemon predating the herdr-tab primitives rejects the recall
+    const stub = makeStub("gated-recall-fail");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const persistence: HerdrTabPersistence = {
+      herdrGetTab: async () => {
+        throw new Error("unknown method herdr.getTab");
+      },
+      herdrSetTab: async () => {},
+    };
+
+    // Act
+    await openHerdrPaneForReview(newSession({ id: "ses_stale" }), persistence, env);
+
+    // Assert - the recall throwing must not abort the open
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop ses_stale",
+      "pane send-keys w1:p2 enter",
+    ]);
+  });
+
+  test("reopens and re-records when the recorded pane is dead", async () => {
+    // Arrange
+    const stub = makeStub("gated-dead", false);
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const store = fakePersistence({ tabId: "old:t", paneId: "old:p" });
+
+    // Act
+    await openHerdrPaneForReview(newSession({ id: "ses_re" }), store.persistence, env);
+
+    // Assert
+    const lines = readLines(stub.logPath);
+
+    expect(lines).toContain("pane get old:p");
+    expect(lines).toContain("tab create --cwd /repo/work --label Rollout Plan --focus");
+    expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+  });
+});
+
+afterAll(() => {
+  rmSync(dir, { recursive: true, force: true, maxRetries: 3 });
+});

package/src/herdr-pane.ts

@@ -0,0 +1,167 @@
+/**
+ * Opens a herdr tab that renders a review, from the creation sites (the Claude
+ * Code hook and `cueloop session create`) that run inside a herdr pane. On a
+ * resubmit it reopens only when the recorded pane is dead, so a live tab is
+ * focused rather than duplicated. Best-effort: any spawn failure is swallowed
+ * and never blocks review creation; each spawn is bounded by a timeout.
+ */
+
+import { detectHerdr, type HerdrEnv, type Thread } from "@cueloop/schema";
+import * as v from "valibot";
+import type { HerdrTabHandle } from "./herdr-tab-store";
+
+const HERDR_SPAWN_TIMEOUT_MS = 2000;
+const CreatedTabSchema = v.object({
+  result: v.optional(
+    v.object({
+      root_pane: v.optional(
+        v.object({ pane_id: v.optional(v.string()), tab_id: v.optional(v.string()) }),
+      ),
+    }),
+  ),
+});
+const PaneResultSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.unknown()) })),
+});
+
+export interface OpenHerdrPaneOptions {
+  sessionId: string;
+  cwd: string;
+  binPath: string;
+  label: string;
+}
+
+/** The daemon-side handle store, as the two methods this module needs. DaemonClient satisfies it. */
+export interface HerdrTabPersistence {
+  herdrGetTab(sessionId: string): Promise<HerdrTabHandle | null>;
+  herdrSetTab(sessionId: string, handle: HerdrTabHandle): Promise<void>;
+}
+
+/**
+ * Open a focused tab and launch the review in it. `tab create` prints
+ * `{ result: { root_pane: { pane_id, tab_id } } }` (herdr 0.8.2); both ids are
+ * returned so a later resubmit can liveness-check and focus. Null on any
+ * best-effort bail-out.
+ */
+export function openHerdrPane(options: OpenHerdrPaneOptions): HerdrTabHandle | null {
+  const { sessionId, cwd, binPath, label } = options;
+
+  try {
+    const created = Bun.spawnSync(
+      [binPath, "tab", "create", "--cwd", cwd, "--label", label, "--focus"],
+      { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
+    );
+
+    if (created.exitCode !== 0) return null;
+    const parsed = v.safeParse(CreatedTabSchema, JSON.parse(created.stdout.toString()));
+
+    if (!parsed.success) return null;
+    const paneId = parsed.output.result?.root_pane?.pane_id;
+    const tabId = parsed.output.result?.root_pane?.tab_id;
+
+    if (!paneId || !tabId) return null;
+    // A fresh tab hosts a plain shell, so the review is typed in like a human.
+    const typed = Bun.spawnSync([binPath, "pane", "send-text", paneId, `cueloop ${sessionId}`], {
+      stdout: "ignore",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+
+    if (typed.exitCode !== 0) return null;
+    const entered = Bun.spawnSync([binPath, "pane", "send-keys", paneId, "enter"], {
+      stdout: "ignore",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+
+    return entered.exitCode === 0 ? { tabId, paneId } : null;
+  } catch {
+    return null;
+  }
+}
+
+/** True when the pane still exists (`herdr pane get` returns it). */
+function herdrPaneAlive(binPath: string, paneId: string): boolean {
+  try {
+    const got = Bun.spawnSync([binPath, "pane", "get", paneId], {
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+
+    if (got.exitCode !== 0) return false;
+    const parsed = v.safeParse(PaneResultSchema, JSON.parse(got.stdout.toString()));
+
+    return parsed.success && parsed.output.result?.pane != null;
+  } catch {
+    return false;
+  }
+}
+
+/** Bring an existing review tab to the front; best-effort. */
+function focusHerdrTab(binPath: string, tabId: string): void {
+  try {
+    Bun.spawnSync([binPath, "tab", "focus", tabId], {
+      stdout: "ignore",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+  } catch {
+    // best-effort
+  }
+}
+
+/**
+ * Ensure a herdr tab is rendering this review. Inside herdr only: focus the
+ * recorded tab if its pane is still alive, otherwise open a fresh one and record
+ * its handle. No-op outside herdr.
+ */
+export async function openHerdrPaneForReview(
+  session: Thread,
+  persistence: HerdrTabPersistence,
+  env: HerdrEnv = process.env,
+): Promise<void> {
+  const herdr = detectHerdr(env);
+
+  if (!herdr) return;
+  const recorded = await recallHerdrTab(persistence, session.id);
+
+  if (recorded && herdrPaneAlive(herdr.binPath, recorded.paneId)) {
+    focusHerdrTab(herdr.binPath, recorded.tabId);
+
+    return;
+  }
+  const opened = openHerdrPane({
+    sessionId: session.id,
+    cwd: session.artifact.meta.cwd ?? process.cwd(),
+    binPath: herdr.binPath,
+    label: session.artifact.meta.title ?? session.id,
+  });
+
+  if (opened) await rememberHerdrTab(persistence, session.id, opened);
+}
+
+/** The recorded handle, or null on any recall failure - a stale daemon must still open a fresh tab, not abort. */
+async function recallHerdrTab(
+  persistence: HerdrTabPersistence,
+  sessionId: string,
+): Promise<HerdrTabHandle | null> {
+  try {
+    return await persistence.herdrGetTab(sessionId);
+  } catch {
+    return null;
+  }
+}
+
+/** Record the handle for later liveness checks; a store failure loses dedup, never the already-open tab. */
+async function rememberHerdrTab(
+  persistence: HerdrTabPersistence,
+  sessionId: string,
+  handle: HerdrTabHandle,
+): Promise<void> {
+  try {
+    await persistence.herdrSetTab(sessionId, handle);
+  } catch {
+    // stale daemon: the tab is already shown; only the liveness-dedup handle is lost
+  }
+}

package/src/herdr-split.test.ts

@@ -0,0 +1,106 @@
+/** launchHarnessInSplit: a stubbed herdr binary logs its argv, and the launcher splits the current pane, runs the harness in the new pane, and optionally types the plan-context seed - a no-op outside herdr. */
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { launchHarnessInSplit } from "./herdr-split";
+
+const dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-split-"));
+
+/** A stub herdr binary that logs argv and prints the pane-split result (pane_id of the new split). */
+function makeStub(name: string, splitOk = true) {
+  const logPath = join(dir, `${name}.log`);
+  const binPath = join(dir, `${name}.sh`);
+  const splitResult = splitOk
+    ? `printf '{"result":{"pane":{"pane_id":"w1:p9"}}}'`
+    : `printf '{"result":{}}'`;
+
+  writeFileSync(
+    binPath,
+    `#!/bin/sh
+printf '%s\\n' "$*" >> "${logPath}"
+if [ "$1" = "pane" ] && [ "$2" = "split" ]; then ${splitResult}; fi
+exit 0
+`,
+  );
+  chmodSync(binPath, 0o755);
+
+  return { binPath, logPath };
+}
+
+function readLines(logPath: string): string[] {
+  if (!existsSync(logPath)) return [];
+
+  return readFileSync(logPath, "utf8").split("\n").filter(Boolean);
+}
+
+describe("launchHarnessInSplit", () => {
+  test("splits the current pane and runs the harness in the new pane", () => {
+    // Arrange
+    const stub = makeStub("run");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+
+    // Act
+    const launched = launchHarnessInSplit({ command: "cc", cwd: "/repo/work" }, env);
+
+    // Assert
+    expect(launched).toBeTrue();
+    expect(readLines(stub.logPath)).toEqual([
+      "pane split w1:p1 --direction right --ratio 0.4 --cwd /repo/work",
+      "pane send-text w1:p9 cc",
+      "pane send-keys w1:p9 enter",
+    ]);
+  });
+
+  test("types the plan-context seed into the split after launching", () => {
+    // Arrange
+    const stub = makeStub("seeded");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+
+    // Act
+    launchHarnessInSplit({ command: "pi", cwd: "/repo", seedText: "read plan ses_1" }, env);
+
+    // Assert
+    expect(readLines(stub.logPath)).toEqual([
+      "pane split w1:p1 --direction right --ratio 0.4 --cwd /repo",
+      "pane send-text w1:p9 pi",
+      "pane send-keys w1:p9 enter",
+      "pane send-text w1:p9 read plan ses_1",
+    ]);
+  });
+
+  test("no-op outside herdr - returns false and spawns nothing", () => {
+    // Arrange
+    const stub = makeStub("outside");
+
+    // Act
+    const launched = launchHarnessInSplit(
+      { command: "cc", cwd: "/repo" },
+      { HERDR_BIN_PATH: stub.binPath },
+    );
+
+    // Assert
+    expect(launched).toBeFalse();
+    expect(existsSync(stub.logPath)).toBeFalse();
+  });
+
+  test("returns false when the split yields no pane id", () => {
+    // Arrange
+    const stub = makeStub("nopane", false);
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+
+    // Act
+    const launched = launchHarnessInSplit({ command: "cc", cwd: "/repo" }, env);
+
+    // Assert - the split ran but no harness was launched into a missing pane
+    expect(launched).toBeFalse();
+    expect(readLines(stub.logPath)).toEqual([
+      "pane split w1:p1 --direction right --ratio 0.4 --cwd /repo",
+    ]);
+  });
+});
+
+afterAll(() => {
+  rmSync(dir, { recursive: true, force: true, maxRetries: 3 });
+});