@cueloop/client 0.1.0-alpha.16 → 0.1.0-alpha.18

package/src/components/DiffSheet.tsx

@@ -13,7 +13,7 @@ import type { Annotation } from "@cueloop/schema";
 import type { DiffRow } from "../view-diff";
 import type { Theme } from "../theme";
 import { useComponentTheme } from "./theme-context";
-import { truncate } from "./format";
+import { truncateToSingleLine } from "./truncate-text";
 
 export interface DiffSheetProps {
   rows: DiffRow[];
@@ -43,7 +43,7 @@ function segmentRows(rows: DiffRow[], annotatedByRow: Map<number, Annotation>):
   };
   for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
     const row = rows[rowIndex]!;
-    if (row.t === "file" || row.t === "hunk") {
+    if (row.kind === "file" || row.kind === "hunk") {
       closeChunk(null);
       segments.push({ kind: "header", rowIndex, row });
       chunkStart = rowIndex + 1;
@@ -79,7 +79,7 @@ function DiffChunk({
   const lineNumbers = useMemo(() => {
     const numbers = new Map<number, number>();
     segment.rows.forEach((row, lineIndex) => {
-      const gutterNumber = row.t === "del" ? row.oldLine : row.newLine;
+      const gutterNumber = row.kind === "del" ? row.oldLine : row.newLine;
       if (gutterNumber !== undefined) numbers.set(lineIndex, gutterNumber);
     });
     return numbers;
@@ -132,8 +132,8 @@ function DiffChunk({
       >
         <text style={{ wrapMode: "none" }} selectable={false}>
           {segment.rows.map((row, lineIndex) => {
-            const sign = row.t === "add" ? "+" : row.t === "del" ? "-" : " ";
-            const foreground = row.t === "add" ? tokens.insFg : row.t === "del" ? tokens.delFg : tokens.textMuted;
+            const sign = row.kind === "add" ? "+" : row.kind === "del" ? "-" : " ";
+            const foreground = row.kind === "add" ? tokens.insFg : row.kind === "del" ? tokens.delFg : tokens.textMuted;
             const isCursorRow = lineIndex === cursorInChunk;
             const isAnnotatedRow = segment.annotation !== null && lineIndex === segment.rows.length - 1;
             return (
@@ -152,7 +152,7 @@ function DiffChunk({
         <text>
           <span fg={tokens.textDim}>{"      "}</span>
           <span fg={segment.annotation.id === focusedAnnotationId ? tokens.text : tokens.accent}>
-            ◆ {truncate(segment.annotation.body, 70)}
+            ◆ {truncateToSingleLine(segment.annotation.body, 70)}
           </span>
         </text>
       ) : null}
@@ -168,7 +168,7 @@ export function DiffSheet({ rows, cursor, annotations, focusedAnnotationId, them
     const byRow = new Map<number, Annotation>();
     for (const annotation of annotations) {
       const rowIndex = rows.findIndex(
-        (row) => row.text === annotation.anchor.quote && (row.t === "ctx" || row.t === "add" || row.t === "del"),
+        (row) => row.text === annotation.anchor.quote && (row.kind === "ctx" || row.kind === "add" || row.kind === "del"),
       );
       if (rowIndex !== -1) byRow.set(rowIndex, annotation);
     }
@@ -213,7 +213,7 @@ export function DiffSheet({ rows, cursor, annotations, focusedAnnotationId, them
         {segments.map((segment, segmentIndex) => {
           if (segment.kind === "header") {
             const isCursor = segment.rowIndex === cursor;
-            if (segment.row.t === "file") {
+            if (segment.row.kind === "file") {
               return (
                 <text key={segmentIndex} fg={tokens.text} bg={isCursor ? tokens.cursorBg : tokens.panel}>
                   {isCursor ? "▎" : " "}■ {rowLine(segment.row)}

package/src/components/PlanSheet.stories.tsx

@@ -32,7 +32,7 @@ export const SpanSelection: Story = {
       display={fixtureDisplay()}
       marks={new Map()}
       cursor={2}
-      activeSpan={{ dispIdx: 2, start: 0, end: 10 }}
+      activeSpan={{ displayIndex: 2, start: 0, end: 10 }}
       compose={null}
       editOrphanCount={0}
       {...callbacks}
@@ -49,10 +49,10 @@ export const InlineCompose: Story = {
       display={fixtureDisplay()}
       marks={new Map()}
       cursor={2}
-      activeSpan={{ dispIdx: 2, start: 0, end: 10 }}
+      activeSpan={{ displayIndex: 2, start: 0, end: 10 }}
       compose={{
         kind: "comment",
-        dispIdx: 2,
+        displayIndex: 2,
         quote: "The daemon",
         draft: { text: "Which daemon?", onInput: () => {}, onSave: () => {}, onCancel: () => {} },
       }}

package/src/components/PlanSheet.tsx

@@ -23,7 +23,7 @@ import {
   type Mark,
   type SpanState,
   type StyleRun,
-} from "../view";
+} from "../view-plan";
 import type { Theme } from "../theme";
 import { useComponentTheme } from "./theme-context";
 import { CodeBlock } from "./CodeBlock";
@@ -32,7 +32,7 @@ import { Button } from "./primitives/Button";
 import { Toolbar } from "./primitives/Toolbar";
 
 export interface PlanSelection {
-  dispIdx: number;
+  displayIndex: number;
   start: number;
   end: number;
 }
@@ -43,12 +43,12 @@ export interface PlanSheetHandle {
   /** Anchor/extend the renderer's native selection from keyboard span offsets. */
   driveSpanSelection(span: SpanState): void;
   clearSelection(): void;
-  revealBlock(dispIdx: number): void;
+  revealBlock(displayIndex: number): void;
 }
 
 export interface PlanComposeState {
   kind: "comment" | "suggestion";
-  dispIdx: number;
+  displayIndex: number;
   quote: string;
   draft: AnnotationDraft;
 }
@@ -59,10 +59,10 @@ export interface PlanSheetProps {
   marks: Map<number, Mark[]>;
   cursor: number;
   /** Extra selection-style paint on one block (keyboard span or compose anchor). */
-  activeSpan: { dispIdx: number; start: number; end: number } | null;
+  activeSpan: { displayIndex: number; start: number; end: number } | null;
   compose: PlanComposeState | null;
   editOrphanCount: number;
-  onLineActivate: (dispIdx: number) => void;
+  onLineActivate: (displayIndex: number) => void;
   onEditRequest: () => void;
   theme?: Theme;
 }
@@ -110,17 +110,17 @@ export const PlanSheet = forwardRef<PlanSheetHandle, PlanSheetProps>(function Pl
     readSelection: (): PlanSelection | null => {
       if (!renderer?.hasSelection) return null;
       const ordered = [...blockRefs.current.entries()].sort(([a], [b]) => a - b);
-      for (const [dispIdx, blockRef] of ordered) {
+      for (const [displayIndex, blockRef] of ordered) {
         const selection = blockRef.renderable.getSelection();
         if (!selection || selection.end <= selection.start) continue;
         const range = workRangeForRendered(blockRef.runs, selection.start, selection.end);
-        if (range) return { dispIdx, ...range };
+        if (range) return { displayIndex, ...range };
       }
       return null;
     },
     driveSpanSelection: (span: SpanState): void => {
       if (!renderer) return;
-      const blockRef = blockRefs.current.get(span.dispIdx);
+      const blockRef = blockRefs.current.get(span.displayIndex);
       if (!blockRef) return;
       const renderedStart = renderedOffsetFor(blockRef.runs, span.start);
       const renderedEnd = renderedOffsetFor(blockRef.runs, span.end - 1);
@@ -133,48 +133,48 @@ export const PlanSheet = forwardRef<PlanSheetHandle, PlanSheetProps>(function Pl
     clearSelection: (): void => {
       renderer?.clearSelection();
     },
-    revealBlock: (dispIdx: number): void => {
+    revealBlock: (displayIndex: number): void => {
       try {
-        scrollRef.current?.scrollChildIntoView(`plan-block-${dispIdx}`);
+        scrollRef.current?.scrollChildIntoView(`plan-block-${displayIndex}`);
       } catch {
         // reveal is best-effort; selection state is already correct
       }
     },
   }));
 
-  const registerBlock = (dispIdx: number, renderable: TextRenderable | null, runs: StyleRun[]): void => {
-    if (renderable) blockRefs.current.set(dispIdx, { renderable, runs });
-    else blockRefs.current.delete(dispIdx);
+  const registerBlock = (displayIndex: number, renderable: TextRenderable | null, runs: StyleRun[]): void => {
+    if (renderable) blockRefs.current.set(displayIndex, { renderable, runs });
+    else blockRefs.current.delete(displayIndex);
   };
   // stale refs must not survive a shrinking display list
   useEffect(() => {
-    for (const dispIdx of blockRefs.current.keys()) {
-      if (dispIdx >= display.length) blockRefs.current.delete(dispIdx);
+    for (const displayIndex of blockRefs.current.keys()) {
+      if (displayIndex >= display.length) blockRefs.current.delete(displayIndex);
     }
   }, [display]);
 
   const children: React.ReactNode[] = [];
-  for (let dispIdx = 0; dispIdx < display.length; dispIdx++) {
-    const block = display[dispIdx]!;
-    const isCursor = dispIdx === cursor;
-    const gap = topGap(display[dispIdx - 1], block);
+  for (let displayIndex = 0; displayIndex < display.length; displayIndex++) {
+    const block = display[displayIndex]!;
+    const isCursor = displayIndex === cursor;
+    const gap = topGap(display[displayIndex - 1], block);
     if (block.kind === "code") {
       children.push(
         <CodeBlock
-          key={dispIdx}
-          id={`plan-block-${dispIdx}`}
+          key={displayIndex}
+          id={`plan-block-${displayIndex}`}
           language={(block.work ?? block.base)?.lang}
           content={displayText(block)}
           isCursor={isCursor}
           marginTop={gap}
-          isAnnotated={(marks.get(dispIdx) ?? []).length > 0}
+          isAnnotated={(marks.get(displayIndex) ?? []).length > 0}
           changeTag={block.type !== "same" ? tagLabel(block) : undefined}
           theme={theme}
         />,
       );
     } else {
-      const blockMarks = [...(marks.get(dispIdx) ?? [])];
-      if (activeSpan && activeSpan.dispIdx === dispIdx) {
+      const blockMarks = [...(marks.get(displayIndex) ?? [])];
+      if (activeSpan && activeSpan.displayIndex === displayIndex) {
         blockMarks.push({ start: activeSpan.start, end: activeSpan.end, role: "kspan" });
       }
       const runs = overlayMarks(blockRuns(block, true), blockMarks);
@@ -182,7 +182,7 @@ export const PlanSheet = forwardRef<PlanSheetHandle, PlanSheetProps>(function Pl
       const mappedRuns: StyleRun[] =
         block.type !== "same" ? [...runs, { text: ` [${tagLabel(block)}]`, role: "plain", start: null }] : runs;
       children.push(
-        <box key={dispIdx} id={`plan-block-${dispIdx}`} style={{ flexDirection: "row", marginTop: gap }}>
+        <box key={displayIndex} id={`plan-block-${displayIndex}`} style={{ flexDirection: "row", marginTop: gap }}>
           <text selectable={false}>
             <span fg={isCursor ? tokens.accent : tokens.textDim}>{isCursor ? "▎ " : "  "}</span>
             <span fg={tokens.textDim}>{marker(block)}</span>
@@ -193,8 +193,8 @@ export const PlanSheet = forwardRef<PlanSheetHandle, PlanSheetProps>(function Pl
             selectionBg={tokens.accent}
             selectionFg={tokens.accentInk}
             style={{ wrapMode: "word", flexGrow: 1, flexShrink: 1 }}
-            ref={(renderable: TextRenderable | null) => registerBlock(dispIdx, renderable, mappedRuns)}
-            onMouseUp={() => onLineActivate(dispIdx)}
+            ref={(renderable: TextRenderable | null) => registerBlock(displayIndex, renderable, mappedRuns)}
+            onMouseUp={() => onLineActivate(displayIndex)}
           >
             {runs.map((run, runIndex) => (
               <span key={runIndex} {...runStyle(run, block, tokens)}>
@@ -206,9 +206,9 @@ export const PlanSheet = forwardRef<PlanSheetHandle, PlanSheetProps>(function Pl
         </box>,
       );
     }
-    if (compose && compose.dispIdx === dispIdx) {
+    if (compose && compose.displayIndex === displayIndex) {
       children.push(
-        <AnnotationCard key={`compose-${dispIdx}`} kind={compose.kind} quote={compose.quote} draft={compose.draft} theme={theme} />,
+        <AnnotationCard key={`compose-${displayIndex}`} kind={compose.kind} quote={compose.quote} draft={compose.draft} theme={theme} />,
       );
     }
   }
@@ -274,7 +274,7 @@ function topGap(previous: DisplayBlock | undefined, current: DisplayBlock): numb
 
 function marker(block: DisplayBlock): string {
   if (block.kind === "li") return "- ";
-  if (block.kind === "oli") return `${block.oliNum ?? 1}. `;
+  if (block.kind === "oli") return `${block.orderedItemNumber ?? 1}. `;
   if (block.kind === "quote") return "▏ ";
   return "";
 }

package/src/components/WalkWizard.tsx

@@ -1,5 +1,5 @@
 /**
- * The guided walk's focused card wizard (#83): one card per changed file
+ * The guided walk's focused card wizard: one card per changed file
  * floating over the dimmed diff, with a plain step count in the title - no
  * progress bar. Below the main card a separate gray-bordered block carries
  * the submitting agent's note for the file, when one exists. Past the last

package/src/components/stories.test.tsx

@@ -1,5 +1,5 @@
 /**
- * The catalog IS the regression suite (#86): every exported story renders in
+ * The catalog IS the regression suite: every exported story renders in
  * a virtual terminal, its char frame snapshots, and its declared colors must
  * appear among the styled spans. A component file without a colocated
  * stories file fails the harness, so the safety net cannot silently thin.

package/src/components/story-fixtures.ts

@@ -1,7 +1,7 @@
 /** Shared fixture data for the stories catalog: one plan session, one diff. */
 
 import type { Annotation, ReviewSession } from "@cueloop/schema";
-import { buildDisplay, marksByDisplay } from "../view";
+import { buildDisplay, marksByDisplay } from "../view-plan";
 import { diffRows } from "../view-diff";
 
 export const FIXTURE_PLAN = `# Migration Plan

package/src/components/story.ts

@@ -1,5 +1,5 @@
 /**
- * The story contract (#86). Every component file in components/ ships a
+ * The story contract. Every component file in components/ ships a
  * colocated *.stories.tsx that exports `meta` plus named Story objects.
  * The catalog IS the regression suite: stories.test.tsx walks every story,
  * snapshots its char frame, and asserts declared colors against the styled

package/src/components/syntax-highlight.ts

@@ -1,5 +1,5 @@
 /**
- * Code highlighting tokens (#86): the theme's named tokens projected onto
+ * Code highlighting tokens: the theme's named tokens projected onto
  * tree-sitter capture names for the native code renderable. One SyntaxStyle
  * per theme object, cached, so every code block on screen shares a handle.
  * Unknown languages simply render unstyled - highlighting is an enhancement,

package/src/components/theme-context.tsx

@@ -1,5 +1,5 @@
 /**
- * Provider theming for the component system (#86). The context default is the
+ * Provider theming for the component system. The context default is the
  * built-in dark theme, so embedding a component (or rendering a story) needs
  * no provider at all. One ThemeProvider swap switches the live theme; every
  * component also accepts an optional `theme` prop that overrides the context

package/src/components/truncate-text.ts

@@ -0,0 +1,6 @@
+/** Truncate text to one line of at most maxLength characters, ellipsis-terminated. */
+
+export function truncateToSingleLine(value: string, maxLength: number): string {
+  const oneLine = value.replace(/\n/g, " ");
+  return oneLine.length > maxLength ? oneLine.slice(0, maxLength - 1) + "…" : oneLine;
+}

package/src/config.test.ts

@@ -7,9 +7,9 @@ import { DARK } from "./theme";
 
 describe("loadConfig", () => {
   test("defaults when no file exists", () => {
-    const c = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
-    expect(c.keys["comment"]).toEqual(["c"]);
-    expect(c.theme.accent).toBe(DARK.accent);
+    const config = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
+    expect(config.keys["comment"]).toEqual(["c"]);
+    expect(config.theme.accent).toBe(DARK.accent);
   });
 
   test("user config rebinds actions and overrides theme tokens", () => {
@@ -20,12 +20,12 @@ describe("loadConfig", () => {
       `[keys]\ncomment = "a"\nsubmit = ["return", "S"]\n\n[theme]\naccent = "#ff0000"\n`,
     );
     try {
-      const c = loadConfig({ userConfigPath: path });
-      expect(c.keys["comment"]).toEqual(["a"]);
-      expect(c.keys["submit"]).toEqual(["return", "S"]);
-      expect(c.keys["cut"]).toEqual(["x"]); // untouched defaults survive
-      expect(c.theme.accent).toBe("#ff0000");
-      expect(c.theme.green).toBe(DARK.green);
+      const config = loadConfig({ userConfigPath: path });
+      expect(config.keys["comment"]).toEqual(["a"]);
+      expect(config.keys["submit"]).toEqual(["return", "S"]);
+      expect(config.keys["cut"]).toEqual(["x"]); // untouched defaults survive
+      expect(config.theme.accent).toBe("#ff0000");
+      expect(config.theme.green).toBe(DARK.green);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -39,8 +39,8 @@ describe("loadConfig", () => {
     Bun.spawnSync(["mkdir", "-p", join(repoRoot, ".cueloop")]);
     writeFileSync(join(repoRoot, ".cueloop", "config.toml"), `[keys]\ncomment = "z"\n`);
     try {
-      const c = loadConfig({ userConfigPath: user, repoRoot });
-      expect(c.keys["comment"]).toEqual(["z"]);
+      const config = loadConfig({ userConfigPath: user, repoRoot });
+      expect(config.keys["comment"]).toEqual(["z"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -51,8 +51,8 @@ describe("loadConfig", () => {
     const path = join(dir, "config.toml");
     writeFileSync(path, "not [valid toml");
     try {
-      const c = loadConfig({ userConfigPath: path });
-      expect(c.keys["comment"]).toEqual(["c"]);
+      const config = loadConfig({ userConfigPath: path });
+      expect(config.keys["comment"]).toEqual(["c"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -61,12 +61,12 @@ describe("loadConfig", () => {
 
 describe("integrations.obsidian config", () => {
   test("defaults when the section is absent", () => {
-    const c = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
-    expect(c.integrations.obsidian.vault).toBeUndefined();
-    expect(c.integrations.obsidian.folder).toBe("cueloop");
-    expect(c.integrations.obsidian.filenameFormat).toBe("{YYYY}-{MM}-{DD} - {title}");
-    expect(c.integrations.obsidian.separator).toBe("space");
-    expect(c.integrations.obsidian.exportOn).toBe("manual");
+    const config = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
+    expect(config.integrations.obsidian.vault).toBeUndefined();
+    expect(config.integrations.obsidian.folder).toBe("cueloop");
+    expect(config.integrations.obsidian.filenameFormat).toBe("{YYYY}-{MM}-{DD} - {title}");
+    expect(config.integrations.obsidian.separator).toBe("space");
+    expect(config.integrations.obsidian.exportOn).toBe("manual");
   });
 
   test("user config sets the section; invalid enum values are ignored", () => {
@@ -77,12 +77,12 @@ describe("integrations.obsidian config", () => {
       `[integrations.obsidian]\nvault = "/notes/vault"\nfolder = "plans"\nexportOn = "approve"\nseparator = "comma"\n`,
     );
     try {
-      const c = loadConfig({ userConfigPath: path });
-      expect(c.integrations.obsidian.vault).toBe("/notes/vault");
-      expect(c.integrations.obsidian.folder).toBe("plans");
-      expect(c.integrations.obsidian.exportOn).toBe("approve");
-      expect(c.integrations.obsidian.separator).toBe("space"); // invalid value falls back
-      expect(c.keys["comment"]).toEqual(["c"]); // other sections untouched
+      const config = loadConfig({ userConfigPath: path });
+      expect(config.integrations.obsidian.vault).toBe("/notes/vault");
+      expect(config.integrations.obsidian.folder).toBe("plans");
+      expect(config.integrations.obsidian.exportOn).toBe("approve");
+      expect(config.integrations.obsidian.separator).toBe("space"); // invalid value falls back
+      expect(config.keys["comment"]).toEqual(["c"]); // other sections untouched
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -96,10 +96,10 @@ describe("integrations.obsidian config", () => {
     Bun.spawnSync(["mkdir", "-p", join(repoRoot, ".cueloop")]);
     writeFileSync(join(repoRoot, ".cueloop", "config.toml"), `[integrations.obsidian]\nfolder = "repo-plans"\n`);
     try {
-      const c = loadConfig({ userConfigPath: user, repoRoot });
-      expect(c.integrations.obsidian.vault).toBe("/user/vault"); // user layer survives
-      expect(c.integrations.obsidian.exportOn).toBe("resolve");
-      expect(c.integrations.obsidian.folder).toBe("repo-plans"); // repo layer wins
+      const config = loadConfig({ userConfigPath: user, repoRoot });
+      expect(config.integrations.obsidian.vault).toBe("/user/vault"); // user layer survives
+      expect(config.integrations.obsidian.exportOn).toBe("resolve");
+      expect(config.integrations.obsidian.folder).toBe("repo-plans"); // repo layer wins
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }

package/src/config.ts

@@ -1,5 +1,5 @@
 /**
- * Layered TOML config (#20): built-in defaults → user config → trusted repo
+ * Layered TOML config: built-in defaults → user config → trusted repo
  * config → env. Sections: [keys] action = "combo" (every action rebindable),
  * [theme] per-token overrides, [integrations.obsidian] notes-vault export.
  */
@@ -83,19 +83,19 @@ function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig
   const integrations = raw["integrations"] as Record<string, unknown> | undefined;
   const obsidian = integrations?.["obsidian"] as Record<string, unknown> | undefined;
   if (obsidian) {
-    const o = out.integrations.obsidian;
-    if (typeof obsidian["vault"] === "string") o.vault = obsidian["vault"];
-    if (typeof obsidian["folder"] === "string") o.folder = obsidian["folder"];
-    if (typeof obsidian["filenameFormat"] === "string") o.filenameFormat = obsidian["filenameFormat"];
-    const sep = obsidian["separator"];
-    if (sep === "space" || sep === "dash" || sep === "underscore") o.separator = sep;
-    const on = obsidian["exportOn"];
-    if (on === "approve" || on === "resolve" || on === "manual") o.exportOn = on;
+    const obsidianConfig = out.integrations.obsidian;
+    if (typeof obsidian["vault"] === "string") obsidianConfig.vault = obsidian["vault"];
+    if (typeof obsidian["folder"] === "string") obsidianConfig.folder = obsidian["folder"];
+    if (typeof obsidian["filenameFormat"] === "string") obsidianConfig.filenameFormat = obsidian["filenameFormat"];
+    const separator = obsidian["separator"];
+    if (separator === "space" || separator === "dash" || separator === "underscore") obsidianConfig.separator = separator;
+    const exportOn = obsidian["exportOn"];
+    if (exportOn === "approve" || exportOn === "resolve" || exportOn === "manual") obsidianConfig.exportOn = exportOn;
   }
   return out;
 }
 
-export function loadConfig(opts: { repoRoot?: string; userConfigPath?: string } = {}): CueloopConfig {
+export function loadConfig(options: { repoRoot?: string; userConfigPath?: string } = {}): CueloopConfig {
   let config: CueloopConfig = {
     keys: { ...DEFAULT_KEYS },
     theme: { ...DARK },
@@ -103,10 +103,10 @@ export function loadConfig(opts: { repoRoot?: string; userConfigPath?: string }
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
   };
   const userPath =
-    opts.userConfigPath ??
+    options.userConfigPath ??
     process.env.CUELOOP_CONFIG ??
     join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
-  for (const path of [userPath, opts.repoRoot ? join(opts.repoRoot, ".cueloop", "config.toml") : undefined]) {
+  for (const path of [userPath, options.repoRoot ? join(options.repoRoot, ".cueloop", "config.toml") : undefined]) {
     if (!path || !existsSync(path)) continue;
     try {
       config = layer(config, parseToml(readFileSync(path, "utf8")));

package/src/editor.ts

@@ -1,5 +1,5 @@
 /**
- * File-level edit mode = the $EDITOR hand-off (#22, #11): write the working
+ * File-level edit mode = the $EDITOR hand-off: write the working
  * copy to a temp file, run the user's editor on it, read the result back.
  * Tests point CUELOOP_EDITOR at a non-interactive command.
  */

package/src/herdr.test.ts

@@ -2,46 +2,17 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { focusHerdrPane, returnPaneFor } from "./herdr";
+import { focusHerdrPane } from "./herdr";
 
 let dir: string;
-const savedEnv: Record<string, string | undefined> = {};
 
 beforeEach(() => {
   dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-"));
-  for (const k of ["HERDR_ENV", "HERDR_PANE_ID", "HERDR_BIN_PATH", "CUELOOP_RETURN_PANE"]) {
-    savedEnv[k] = process.env[k];
-    delete process.env[k];
-  }
 });
 afterEach(() => {
-  for (const [k, v] of Object.entries(savedEnv)) {
-    if (v === undefined) delete process.env[k];
-    else process.env[k] = v;
-  }
   rmSync(dir, { recursive: true, force: true });
 });
 
-describe("returnPaneFor", () => {
-  test("outside herdr there is never a return target", () => {
-    expect(returnPaneFor("w1:p1")).toBeUndefined();
-  });
-
-  test("env override wins, session meta is the fallback", () => {
-    process.env.HERDR_ENV = "1";
-    process.env.HERDR_PANE_ID = "w1:p9";
-    expect(returnPaneFor("w1:p1")).toBe("w1:p1");
-    process.env.CUELOOP_RETURN_PANE = "w1:p2";
-    expect(returnPaneFor("w1:p1")).toBe("w1:p2");
-  });
-
-  test("returning to our own pane is a no-op", () => {
-    process.env.HERDR_ENV = "1";
-    process.env.HERDR_PANE_ID = "w1:p1";
-    expect(returnPaneFor("w1:p1")).toBeUndefined();
-  });
-});
-
 describe("focusHerdrPane", () => {
   test("resolves the pane's tab and focuses it", () => {
     const log = join(dir, "calls.log");
@@ -54,15 +25,13 @@ if [ "$1" = "pane" ]; then echo '{"result":{"pane":{"tab_id":"w1:t3"}}}'; fi
 `,
     );
     Bun.spawnSync(["chmod", "+x", stub]);
-    process.env.HERDR_BIN_PATH = stub;
-    expect(focusHerdrPane("w1:p1")).toBe(true);
+    expect(focusHerdrPane(stub, "w1:p1")).toBe(true);
     const calls = readFileSync(log, "utf8").trim().split("\n");
     expect(calls[0]).toBe("pane get w1:p1");
     expect(calls[1]).toBe("tab focus w1:t3");
   });
 
   test("a missing binary never throws", () => {
-    process.env.HERDR_BIN_PATH = join(dir, "nope");
-    expect(focusHerdrPane("w1:p1")).toBe(false);
+    expect(focusHerdrPane(join(dir, "nope"), "w1:p1")).toBe(false);
   });
 });

package/src/herdr.ts

@@ -1,33 +1,20 @@
 /**
- * First-class herdr return (#23): a review opened beside an agent should hand
- * focus back to the agent's pane when it closes, not leave the reviewer on a
- * dead tab. Detection is the ambient env contract; the return target comes
- * from CUELOOP_RETURN_PANE (set by whoever opened this pane) or the session's
- * recorded herdrPane (set by the adapter hook). Everything here is
- * best-effort: focus failures never block closing the review.
+ * First-class herdr return: a review opened beside an agent hands focus back
+ * to the agent's pane when it closes, not leaving the reviewer on a dead tab.
+ * The env contract and the return-target rule live in @cueloop/schema; this
+ * module owns the one reviewer-side action that spawns the herdr CLI. Focus
+ * is best-effort - a failure never blocks closing the review.
  */
 
-export function insideHerdr(): boolean {
-  return process.env.HERDR_ENV === "1";
-}
-
-export function returnPaneFor(sessionHerdrPane?: string): string | undefined {
-  if (!insideHerdr()) return undefined;
-  const pane = process.env.CUELOOP_RETURN_PANE ?? sessionHerdrPane;
-  // returning to our own pane would be a no-op at best
-  return pane && pane !== process.env.HERDR_PANE_ID ? pane : undefined;
-}
-
 /** Focus the tab holding the target pane. Synchronous: runs just before exit. */
-export function focusHerdrPane(paneId: string): boolean {
-  const bin = process.env.HERDR_BIN_PATH ?? "herdr";
+export function focusHerdrPane(binPath: string, paneId: string): boolean {
   try {
-    const got = Bun.spawnSync([bin, "pane", "get", paneId], { stdout: "pipe", stderr: "ignore" });
+    const got = Bun.spawnSync([binPath, "pane", "get", paneId], { stdout: "pipe", stderr: "ignore" });
     if (got.exitCode !== 0) return false;
     const parsed = JSON.parse(got.stdout.toString()) as { result?: { pane?: { tab_id?: string } } };
     const tab = parsed.result?.pane?.tab_id;
     if (!tab) return false;
-    return Bun.spawnSync([bin, "tab", "focus", tab], { stdout: "ignore", stderr: "ignore" }).exitCode === 0;
+    return Bun.spawnSync([binPath, "tab", "focus", tab], { stdout: "ignore", stderr: "ignore" }).exitCode === 0;
   } catch {
     return false;
   }

package/src/key-bindings.ts

@@ -1,5 +1,5 @@
 /**
- * Binding resolution over @opentui/keymap (#86): the loaded config keymap
+ * Binding resolution over @opentui/keymap: the loaded config keymap
  * registers as layers (grammar, span, compose, submit, completion) on one
  * Keymap instance, key events resolve to action names through its dispatch,
  * and the status-line hints generate from getActiveKeys() - a rebound key