@cueloop/client 0.1.0-alpha.63 → 0.1.0-alpha.65

package/src/components/story-fixtures.ts

@@ -63,9 +63,11 @@ export function fixturePlanSession(overrides: Partial<ReviewSession> = {}): Revi
     },
     revisions: [{ revision: 1, content: FIXTURE_PLAN, submittedAt: "2026-01-01T00:00:00Z" }],
     annotations: FIXTURE_ANNOTATIONS,
+    verdict: null,
     status: "pending",
+    createdAt: "2026-01-01T00:00:00Z",
     ...overrides,
-  } as ReviewSession;
+  };
 }
 
 export function fixtureDiffSession(overrides: Partial<ReviewSession> = {}): ReviewSession {
@@ -80,9 +82,11 @@ export function fixtureDiffSession(overrides: Partial<ReviewSession> = {}): Revi
     },
     revisions: [{ revision: 1, content: FIXTURE_PATCH, submittedAt: "2026-01-01T00:00:00Z" }],
     annotations: [],
+    verdict: null,
     status: "pending",
+    createdAt: "2026-01-01T00:00:00Z",
     ...overrides,
-  } as ReviewSession;
+  };
 }
 
 export function fixtureDisplay() {

package/src/components/story.ts

@@ -32,7 +32,19 @@ export interface LoadedStory {
 
 export function isStory(value: unknown): value is Story {
   return (
-    typeof value === "object" && value !== null && typeof (value as Story).render === "function"
+    typeof value === "object" &&
+    value !== null &&
+    "render" in value &&
+    typeof value.render === "function"
+  );
+}
+
+function isStoryMeta(value: unknown): value is StoryMeta {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "title" in value &&
+    typeof value.title === "string"
   );
 }
 
@@ -43,9 +55,9 @@ export async function loadStories(): Promise<LoadedStory[]> {
   const loaded: LoadedStory[] = [];
 
   for (const file of files) {
-    const moduleExports = (await import(`${import.meta.dir}/${file}`)) as Record<string, unknown>;
-    const meta = moduleExports["meta"] as StoryMeta | undefined;
-    const moduleTitle = meta?.title ?? file.replace(/\.stories\.tsx$/, "");
+    const moduleExports = await import(`${import.meta.dir}/${file}`);
+    const meta = moduleExports["meta"];
+    const moduleTitle = isStoryMeta(meta) ? meta.title : file.replace(/\.stories\.tsx$/, "");
 
     for (const [exportName, exported] of Object.entries(moduleExports)) {
       if (exportName === "meta" || !isStory(exported)) continue;

package/src/components/syntax-highlight.ts

@@ -19,7 +19,7 @@ export function filetypeFor(language?: string): string | undefined {
   const info = (language ?? "").toLowerCase();
 
   if (!info) return undefined;
-  const aliases: Record<string, string> = {
+  const aliases: SyntaxAliases = {
     ts: "typescript",
     js: "javascript",
     py: "python",
@@ -47,13 +47,21 @@ export function filetypeForPath(path: string): string | undefined {
   return extensionToFiletype.get(basename.slice(dotIndex + 1).toLowerCase());
 }
 
+interface SyntaxAliases {
+  [alias: string]: string;
+}
+
 interface SyntaxGroupStyle {
   fg: string;
   italic?: boolean;
 }
 
+interface SyntaxGroupStyles {
+  [group: string]: SyntaxGroupStyle;
+}
+
 /** The one group -> style map, keyed by tree-sitter capture name. */
-function syntaxGroupStyles(theme: Theme): Record<string, SyntaxGroupStyle> {
+function syntaxGroupStyles(theme: Theme): SyntaxGroupStyles {
   return {
     default: { fg: theme.textMuted },
     comment: { fg: theme.textDim, italic: true },

package/src/components/terminal-pane.test.tsx

@@ -34,7 +34,7 @@ describe("TerminalPaneRenderable", () => {
 
   test("exposes availability + the renderable class", () => {
     // Assert - the module loads and reports platform support honestly
-    expect(typeof embeddedTerminalAvailable()).toBe("boolean");
+    expect([true, false]).toContain(embeddedTerminalAvailable());
     expect(TerminalPaneRenderable).toBeDefined();
   });
 });

package/src/components/terminal-pane.ts

@@ -47,6 +47,12 @@ export interface TerminalPaneOptions extends RenderableOptions {
   onExit?: (exitCode: number) => void;
 }
 
+function terminalEnvironment(env: NodeJS.ProcessEnv) {
+  return Object.fromEntries(
+    Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined),
+  );
+}
+
 const encoder = new TextEncoder();
 const DEFAULT_FG = RGBA.fromInts(208, 208, 208, 255);
 const TRANSPARENT = RGBA.fromValues(0, 0, 0, 0);
@@ -87,7 +93,7 @@ export class TerminalPaneRenderable extends Renderable {
       cols,
       rows,
       cwd: this.opts.cwd ?? process.cwd(),
-      env: (this.opts.env ?? process.env) as Record<string, string>,
+      env: this.opts.env ?? terminalEnvironment(process.env),
     });
     this.pty.onData((data) => {
       // the shim streams a UTF-8-decoded string (split multibyte is handled); a

package/src/config.ts

@@ -12,6 +12,7 @@ import { join } from "node:path";
 import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obsidian";
 import { writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
+import * as v from "valibot";
 import { DARK, type Theme } from "./theme";
 import { DEFAULT_THEME_NAME, isThemeName, themeForName, type ThemeName } from "./theme-presets";
 import { REVIEW_DEFAULT_WIDTH, clampWidth, type ReviewPanelMode } from "./review-panel";
@@ -112,7 +113,7 @@ export interface CueloopConfig {
 }
 
 /** Every action in the grammar, with its default binding(s). */
-export const DEFAULT_KEYS: Record<string, string[]> = {
+export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   down: ["j", "down"],
   up: ["k", "up"],
   top: ["g"],
@@ -136,100 +137,87 @@ export const DEFAULT_KEYS: Record<string, string[]> = {
   review_narrower: ["["],
 };
 
-function parseToml(text: string): Record<string, unknown> {
-  // Bun ships a native TOML parser
-  return Bun.TOML.parse(text) as Record<string, unknown>;
+const ConfigDocumentSchema = v.object({
+  actions: v.optional(v.array(v.unknown())),
+  authors: v.optional(v.unknown()),
+  integrations: v.optional(v.unknown()),
+  keys: v.optional(v.unknown()),
+  theme: v.optional(v.unknown()),
+  ui: v.optional(v.unknown()),
+});
+
+const QuickActionSchema = v.object({
+  prompt: v.pipe(
+    v.string(),
+    v.check((prompt) => Boolean(prompt.trim())),
+  ),
+  metadata: v.optional(v.string()),
+});
+
+const AuthorsSchema = v.record(v.string(), v.unknown());
+const KeysSchema = v.record(v.string(), v.unknown());
+const KeyComboSchema = v.union([v.string(), v.array(v.string())]);
+// Every field falls back to undefined on its own, so one bad value in a
+// section never discards the section's other settings.
+const UiSchema = v.object({
+  auto_close: v.fallback(
+    v.optional(v.union([v.literal("off"), v.pipe(v.number(), v.minValue(0))])),
+    undefined,
+  ),
+  editor: v.fallback(v.optional(v.string()), undefined),
+  review_width: v.fallback(v.optional(v.pipe(v.number(), v.finite())), undefined),
+  review_state: v.fallback(v.optional(v.picklist(["expanded", "compact", "hidden"])), undefined),
+  theme: v.fallback(v.optional(v.string()), undefined),
+});
+const ObsidianSchema = v.object({
+  vault: v.fallback(v.optional(v.string()), undefined),
+  folder: v.fallback(v.optional(v.string()), undefined),
+  filenameFormat: v.fallback(v.optional(v.string()), undefined),
+  separator: v.fallback(v.optional(v.picklist(["space", "dash", "underscore"])), undefined),
+  exportOn: v.fallback(v.optional(v.picklist(["approve", "resolve", "manual"])), undefined),
+});
+const IntegrationsSchema = v.object({ obsidian: v.optional(ObsidianSchema) });
+const ThemeOverridesSchema = v.record(v.string(), v.unknown());
+
+function isThemeToken(token: string): token is keyof Theme {
+  return token in DARK;
 }
 
-/**
- * Parse a `[[actions]]` array-of-tables. A table without a non-empty `prompt`
- * is skipped; any valid table REPLACES the defaults (the whole set is the
- * user's, not merged). Returns undefined when nothing usable is present.
- */
-function parseActions(raw: unknown): QuickAction[] | undefined {
-  if (!Array.isArray(raw)) return undefined;
-  const actions: QuickAction[] = [];
-
-  for (const entry of raw) {
-    if (!entry || typeof entry !== "object") continue;
-    const table = entry as Record<string, unknown>;
-    const prompt = table["prompt"];
-
-    if (typeof prompt !== "string" || !prompt.trim()) continue;
-    const metadata = table["metadata"];
-
-    actions.push(
-      typeof metadata === "string" && metadata.trim() ? { prompt, metadata } : { prompt },
-    );
-  }
-
-  return actions.length ? actions : undefined;
+function parseToml(text: string) {
+  return v.parse(ConfigDocumentSchema, Bun.TOML.parse(text));
 }
 
-function mergeAuthors(target: Record<string, string>, raw: unknown): void {
-  const authors = raw as Record<string, unknown> | undefined;
+function parseActions(entries: readonly unknown[] | undefined): QuickAction[] | undefined {
+  if (!entries) return undefined;
+  const actions: QuickAction[] = [];
 
-  if (!authors) return;
-  for (const [id, value] of Object.entries(authors)) {
-    if (typeof value === "string") target[id] = value;
-  }
-}
+  for (const entry of entries) {
+    const result = v.safeParse(QuickActionSchema, entry);
 
-function mergeKeys(target: Record<string, string[]>, raw: unknown): void {
-  const keys = raw as KeymapConfig | undefined;
+    if (!result.success) continue;
+    const { prompt, metadata } = result.output;
 
-  if (!keys) return;
-  for (const [action, combo] of Object.entries(keys)) {
-    target[action] = Array.isArray(combo) ? combo : [combo];
+    actions.push(metadata?.trim() ? { prompt, metadata } : { prompt });
   }
-}
 
-function mergeAutoClose(target: CueloopConfig["ui"], value: unknown): void {
-  if (value === undefined) return;
-  if (value === "off") target.autoClose = "off";
-  else if (typeof value === "number" && value >= 0) target.autoClose = value;
-}
-
-function mergeUi(target: CueloopConfig["ui"], raw: unknown): void {
-  const ui = raw as
-    | { auto_close?: unknown; editor?: unknown; review_width?: unknown; review_state?: unknown }
-    | undefined;
-
-  if (!ui) return;
-  mergeAutoClose(target, ui.auto_close);
-  if (typeof ui.editor === "string" && ui.editor.trim()) target.editor = ui.editor.trim();
-  if (typeof ui.review_width === "number" && Number.isFinite(ui.review_width)) {
-    target.reviewWidth = clampWidth(ui.review_width);
-  }
-  if (
-    ui.review_state === "expanded" ||
-    ui.review_state === "compact" ||
-    ui.review_state === "hidden"
-  ) {
-    target.reviewState = ui.review_state;
-  }
+  return actions.length ? actions : undefined;
 }
 
-function mergeObsidian(target: ObsidianConfig, raw: unknown): void {
-  const integrations = raw as Record<string, unknown> | undefined;
-  const obsidian = integrations?.["obsidian"] as Record<string, unknown> | undefined;
-
-  if (!obsidian) return;
-  if (typeof obsidian["vault"] === "string") target.vault = obsidian["vault"];
-  if (typeof obsidian["folder"] === "string") target.folder = obsidian["folder"];
-  if (typeof obsidian["filenameFormat"] === "string")
-    target.filenameFormat = obsidian["filenameFormat"];
-  const separator = obsidian["separator"];
-
-  if (separator === "space" || separator === "dash" || separator === "underscore")
-    target.separator = separator;
-  const exportOn = obsidian["exportOn"];
-
-  if (exportOn === "approve" || exportOn === "resolve" || exportOn === "manual")
-    target.exportOn = exportOn;
+function mergeObsidian(
+  target: ObsidianConfig,
+  obsidian: v.InferOutput<typeof ObsidianSchema>,
+): void {
+  if (obsidian.vault !== undefined) target.vault = obsidian.vault;
+  if (obsidian.folder !== undefined) target.folder = obsidian.folder;
+  if (obsidian.filenameFormat !== undefined) target.filenameFormat = obsidian.filenameFormat;
+  if (obsidian.separator !== undefined) target.separator = obsidian.separator;
+  if (obsidian.exportOn !== undefined) target.exportOn = obsidian.exportOn;
 }
 
-function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig {
+function layer(
+  base: CueloopConfig,
+  raw: v.InferOutput<typeof ConfigDocumentSchema>,
+): CueloopConfig {
   const out: CueloopConfig = {
     keys: { ...base.keys },
     theme: { ...base.theme },
@@ -239,13 +227,38 @@ function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig
     actions: [...base.actions],
     integrations: { obsidian: { ...base.integrations.obsidian } },
   };
-  const actions = parseActions(raw["actions"]);
+  const actions = parseActions(raw.actions);
+  const authors = v.safeParse(AuthorsSchema, raw.authors);
+  const keys = v.safeParse(KeysSchema, raw.keys);
+  const ui = v.safeParse(UiSchema, raw.ui);
+  const integrations = v.safeParse(IntegrationsSchema, raw.integrations);
 
   if (actions) out.actions = actions;
-  mergeAuthors(out.authors, raw["authors"]);
-  mergeKeys(out.keys, raw["keys"]);
-  mergeUi(out.ui, raw["ui"]);
-  mergeObsidian(out.integrations.obsidian, raw["integrations"]);
+  if (authors.success) {
+    for (const [id, value] of Object.entries(authors.output)) {
+      const name = v.safeParse(v.string(), value);
+
+      if (name.success) out.authors[id] = name.output;
+    }
+  }
+  if (keys.success) {
+    for (const [action, value] of Object.entries(keys.output)) {
+      const combo = v.safeParse(KeyComboSchema, value);
+
+      if (combo.success)
+        out.keys[action] = Array.isArray(combo.output) ? combo.output : [combo.output];
+    }
+  }
+  if (ui.success) {
+    if (ui.output.auto_close !== undefined) out.ui.autoClose = ui.output.auto_close;
+    if (ui.output.editor?.trim()) out.ui.editor = ui.output.editor.trim();
+    if (ui.output.review_width !== undefined)
+      out.ui.reviewWidth = clampWidth(ui.output.review_width);
+    if (ui.output.review_state !== undefined) out.ui.reviewState = ui.output.review_state;
+  }
+  if (integrations.success && integrations.output.obsidian) {
+    mergeObsidian(out.integrations.obsidian, integrations.output.obsidian);
+  }
 
   return out;
 }
@@ -284,10 +297,18 @@ export function loadConfig(
       const raw = parseToml(readFileSync(path, "utf8"));
 
       config = layer(config, raw);
-      const rawTheme = (raw["ui"] as { theme?: unknown } | undefined)?.theme;
-
-      if (typeof rawTheme === "string" && isThemeName(rawTheme)) themeName = rawTheme;
-      collectThemeOverrides(raw["theme"], themeOverrides);
+      const ui = v.safeParse(UiSchema, raw.ui);
+      const rawTheme = ui.success ? ui.output.theme : undefined;
+      const parsedThemeOverrides = v.safeParse(ThemeOverridesSchema, raw.theme);
+
+      if (rawTheme && isThemeName(rawTheme)) themeName = rawTheme;
+      if (parsedThemeOverrides.success) {
+        for (const [token, value] of Object.entries(parsedThemeOverrides.output)) {
+          const override = v.safeParse(v.string(), value);
+
+          if (override.success && isThemeToken(token)) themeOverrides[token] = override.output;
+        }
+      }
     } catch {
       // a broken config never blocks a review; defaults win
     }
@@ -299,14 +320,6 @@ export function loadConfig(
   return config;
 }
 
-/** Merge a raw `[theme]` table's known string tokens into the accumulated overrides. */
-function collectThemeOverrides(raw: unknown, into: Partial<Record<keyof Theme, string>>): void {
-  if (!raw || typeof raw !== "object") return;
-  for (const [token, value] of Object.entries(raw)) {
-    if (token in DARK && typeof value === "string") into[token as keyof Theme] = value;
-  }
-}
-
 /** Reverse lookup: key name (+shift) → action, per the loaded keymap. */
 export function actionFor(
   keys: Record<string, string[]>,

package/src/diff-hunk-curate.ts

@@ -13,16 +13,12 @@
  * the stored git patch and the model split hunks differently.
  */
 
-import { parseDiffFromFile, diffAcceptRejectHunk, type FileDiffMetadata } from "@pierre/diffs";
-import { unifiedDiffText, type DiffFileContents, type DiffFileStatus } from "@cueloop/schema";
+import type { FileDiffMetadata } from "@pierre/diffs";
+import type { HunkRejection } from "@cueloop/schema";
 import type { DiffRow } from "./view-diff";
 
-/** One reject decision; `changeIndex` absent rejects the whole hunk. */
-export interface HunkRejection {
-  path: string;
-  hunkIndex: number;
-  changeIndex?: number;
-}
+export { curateDiff, parseFileDiff } from "@cueloop/daemon/curate";
+export type { HunkRejection } from "@cueloop/schema";
 
 /** Which side of the diff a line number addresses. */
 type DiffSide = "addition" | "deletion";
@@ -34,24 +30,6 @@ export interface LocatedLine {
   changeIndex?: number;
 }
 
-/**
- * Context lines around each change. Matching git's default (3) makes the model
- * split hunks like the rendered working-tree patch does; git's coalescing can
- * still merge adjacent hunks differently, but the row is mapped by absolute line
- * number (not by counting hunks), so a whole-hunk reject can only ever span the
- * model hunk it lands in - never the wrong file or a crash.
- */
-const DIFF_CONTEXT = 3;
-
-/** Parse one file's full contents into a non-partial diff model. */
-export function parseFileDiff(file: DiffFileContents): FileDiffMetadata {
-  return parseDiffFromFile(
-    { name: file.path, contents: file.oldContents },
-    { name: file.path, contents: file.newContents },
-    { context: DIFF_CONTEXT },
-  );
-}
-
 /**
  * Resolve a 1-based file line on one side to its hunk and, when the line is
  * part of a change block, that block's `hunkContent` index.
@@ -173,81 +151,3 @@ export function isRowRejected(
       (rejection.changeIndex === undefined || rejection.changeIndex === located.changeIndex),
   );
 }
-
-/**
- * Apply one file's rejections and return its curated patch, or null when the
- * curated content equals the old content (every change rejected - no patch).
- * Whole-hunk rejections supersede change-level ones for the same hunk. Because
- * `diffAcceptRejectHunk` returns a model with the same hunk/content shape, the
- * indices stay valid across calls; they are applied high-to-low regardless, so
- * the order is deterministic.
- */
-function curateFilePatch(file: DiffFileContents, rejections: HunkRejection[]): string | null {
-  let model = parseFileDiff(file);
-  const wholeHunks = new Set(
-    rejections
-      .filter((rejection) => rejection.changeIndex === undefined)
-      .map((rejection) => rejection.hunkIndex),
-  );
-
-  for (const hunkIndex of [...wholeHunks].sort((a, b) => b - a)) {
-    model = diffAcceptRejectHunk(model, hunkIndex, "reject");
-  }
-  const changeRejections = rejections
-    .filter(
-      (rejection) => rejection.changeIndex !== undefined && !wholeHunks.has(rejection.hunkIndex),
-    )
-    .sort((a, b) => b.hunkIndex - a.hunkIndex || b.changeIndex! - a.changeIndex!);
-
-  for (const rejection of changeRejections) {
-    model = diffAcceptRejectHunk(model, rejection.hunkIndex, {
-      type: "reject",
-      changeIndex: rejection.changeIndex!,
-    });
-  }
-  const curatedNew = model.additionLines.join("");
-
-  if (curatedNew === file.oldContents) return null;
-  const patch = unifiedDiffText(file.oldContents, curatedNew, file.path);
-
-  if (patch === null) return null;
-
-  return withFileStateHeaders(patch, file.path, file.status, curatedNew);
-}
-
-/**
- * Point the diff headers at /dev/null for a created or fully-deleted file so the
- * curated patch applies. git's status - not empty contents - decides existence,
- * so editing an existing empty file stays a modify; a deletion whose removals
- * were partly restored also falls back to a modify.
- */
-function withFileStateHeaders(
-  patch: string,
-  path: string,
-  status: DiffFileStatus,
-  curatedNew: string,
-): string {
-  if (status === "added") return patch.replace(`--- a/${path}`, "--- /dev/null");
-  if (status === "deleted" && curatedNew === "") {
-    return patch.replace(`+++ b/${path}`, "+++ /dev/null");
-  }
-
-  return patch;
-}
-
-/**
- * The curated unified-diff patch of the accepted changes across every file.
- * Files with no net change (unchanged, or with all changes rejected) drop out.
- */
-export function curateDiff(files: DiffFileContents[], rejections: HunkRejection[]): string {
-  const parts: string[] = [];
-
-  for (const file of files) {
-    const fileRejections = rejections.filter((rejection) => rejection.path === file.path);
-    const patch = curateFilePatch(file, fileRejections);
-
-    if (patch) parts.push(patch);
-  }
-
-  return parts.join("\n");
-}

package/src/editor.ts

@@ -21,7 +21,11 @@ export interface EditResult {
 const DEFAULT_EDITOR = "nano";
 
 /** GUI editors fork and return immediately unless given their wait flag. */
-const GUI_WAIT_FLAGS: Record<string, string[]> = {
+interface GuiWaitFlags {
+  [editor: string]: string[];
+}
+
+const GUI_WAIT_FLAGS: GuiWaitFlags = {
   code: ["--wait"],
   "code-insiders": ["--wait"],
   codium: ["--wait"],

package/src/ghostty-terminal.test.ts

@@ -8,7 +8,7 @@ const factory = loadGhosttyTerminals();
 describe("ghostty-terminal FFI", () => {
   test("reports platform support without throwing", () => {
     // Assert - null on unsupported platforms, a factory where a dylib ships
-    expect(factory === null || typeof factory.create === "function").toBe(true);
+    expect(factory === null || factory.create !== undefined).toBe(true);
   });
 
   test.skipIf(!factory)("writes VT bytes and reads back decoded cells", () => {

package/src/herdr.ts

@@ -6,6 +6,12 @@
  * is best-effort - a failure never blocks closing the review.
  */
 
+import * as v from "valibot";
+
+const HerdrPaneSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.object({ tab_id: v.optional(v.string()) })) })),
+});
+
 /** Focus the tab holding the target pane. Synchronous: runs just before exit. */
 export function focusHerdrPane(binPath: string, paneId: string): boolean {
   try {
@@ -15,8 +21,10 @@ export function focusHerdrPane(binPath: string, paneId: string): boolean {
     });
 
     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;
+    const parsed = v.safeParse(HerdrPaneSchema, JSON.parse(got.stdout.toString()));
+
+    if (!parsed.success) return false;
+    const tab = parsed.output.result?.pane?.tab_id;
 
     if (!tab) return false;
 

package/src/index.ts

@@ -3,6 +3,7 @@ export { serveClient, type ServeHandle, type ServeOptions } from "./serve";
 export { App, type AppProps } from "./App";
 export {
   collaboratorAnnotations,
+  mergeFromShare,
   publishShare,
   pullShare,
   pushShare,