@cueloop/client 0.1.0-alpha.10 → 0.1.0-alpha.101

package/native/build-pty.sh

@@ -0,0 +1,51 @@
+#!/bin/sh
+# Build libcuelooppty: the flat forkpty(3) FFI shim in src/pty.zig. Pure libc, so
+# unlike build.sh this needs no Ghostty clone - just the pinned Zig toolchain.
+# Output lands in native/<os>-<arch>/libcuelooppty.{dylib,so}. Requires curl.
+set -eu
+
+ZIG_VERSION="0.16.0"
+
+here="$(cd "$(dirname "$0")" && pwd)"
+work="${TMPDIR:-/tmp}/cueloop-libghostty-build"
+mkdir -p "$work"
+export ZIG_GLOBAL_CACHE_DIR="$work/zig-gcache"
+export ZIG_LOCAL_CACHE_DIR="$work/zig-lcache"
+cd "$work"
+
+arch="$(uname -m)"; os="$(uname -s | tr '[:upper:]' '[:lower:]')"
+case "$os" in darwin) zig_os="macos"; dylib="libcuelooppty.dylib";; linux) zig_os="linux"; dylib="libcuelooppty.so";; *) echo "unsupported os $os" >&2; exit 1;; esac
+case "$arch-$os" in
+  arm64-darwin|aarch64-linux) zig_arch="aarch64"; bun_arch="arm64";;
+  x86_64-darwin|x86_64-linux) zig_arch="x86_64"; bun_arch="x64";;
+  *) echo "unsupported architecture $arch on $os" >&2; exit 1;;
+esac
+case "$zig_arch-$zig_os" in
+  aarch64-macos) zig_sha="b23d70deaa879b5c2d486ed3316f7eaa53e84acf6fc9cc747de152450d401489";;
+  x86_64-macos) zig_sha="0387557ed1877bc6a2e1802c8391953baddba76081876301c522f52977b52ba7";;
+  aarch64-linux) zig_sha="ea4b09bfb22ec6f6c6ceac57ab63efb6b46e17ab08d21f69f3a48b38e1534f17";;
+  x86_64-linux) zig_sha="70e49664a74374b48b51e6f3fdfbf437f6395d42509050588bd49abe52ba3d00";;
+esac
+outdir="$here/${os}-${bun_arch}"
+zig_archive="zig-$zig_arch-$zig_os-$ZIG_VERSION.tar.xz"
+
+if [ ! -f "$zig_archive" ]; then
+  echo "== fetching zig $ZIG_VERSION =="
+  curl -fsSL -o "$zig_archive" "https://ziglang.org/download/$ZIG_VERSION/$zig_archive"
+fi
+printf '%s  %s\n' "$zig_sha" "$zig_archive" | shasum -a 256 -c -
+
+build_root="$(mktemp -d "$work/native-pty-build.XXXXXX")"
+trap 'rm -rf "$build_root"' EXIT HUP INT TERM
+tar -xf "$zig_archive" -C "$build_root"
+zig="$build_root/zig-$zig_arch-$zig_os-$ZIG_VERSION/zig"
+
+echo "== building pty shim -> $outdir/$dylib =="
+mkdir -p "$outdir"
+if [ "$os" = "darwin" ]; then
+  "$zig" build-lib -dynamic -OReleaseFast -lc -femit-bin="$outdir/$dylib" \
+    -install_name "@rpath/$dylib" "$here/src/pty.zig"
+else
+  "$zig" build-lib -dynamic -OReleaseFast -lc -femit-bin="$outdir/$dylib" "$here/src/pty.zig"
+fi
+echo "== done: $outdir/$dylib =="

package/native/build.sh

@@ -0,0 +1,82 @@
+#!/bin/sh
+# Rebuild libcueloopvt.dylib: libghostty-vt (Ghostty's VT core) statically linked
+# behind the flat FFI shim. Pinned to a Ghostty commit + Zig 0.16.0.
+# Output lands in native/<os>-<arch>/libcueloopvt.dylib. Requires curl and git.
+set -eu
+
+GHOSTTY_COMMIT="5834a0e3df621802e9578e4562d88b0c2ad4ada8"
+ZIG_VERSION="0.16.0"
+
+here="$(cd "$(dirname "$0")" && pwd)"
+work="${TMPDIR:-/tmp}/cueloop-libghostty-build"
+mkdir -p "$work"
+export ZIG_GLOBAL_CACHE_DIR="$work/zig-gcache"
+export ZIG_LOCAL_CACHE_DIR="$work/zig-lcache"
+cd "$work"
+
+# Host triple for the Bun prebuilt dir and Zig download. The two tools use
+# different architecture names.
+arch="$(uname -m)"; os="$(uname -s | tr '[:upper:]' '[:lower:]')"
+case "$os" in darwin) zig_os="macos"; dylib="libcueloopvt.dylib";; linux) zig_os="linux"; dylib="libcueloopvt.so";; *) echo "unsupported os $os" >&2; exit 1;; esac
+case "$arch-$os" in
+  arm64-darwin|aarch64-linux) zig_arch="aarch64"; bun_arch="arm64";;
+  x86_64-darwin|x86_64-linux) zig_arch="x86_64"; bun_arch="x64";;
+  *) echo "unsupported architecture $arch on $os" >&2; exit 1;;
+esac
+case "$zig_arch-$zig_os" in
+  aarch64-macos) zig_sha="b23d70deaa879b5c2d486ed3316f7eaa53e84acf6fc9cc747de152450d401489";;
+  x86_64-macos) zig_sha="0387557ed1877bc6a2e1802c8391953baddba76081876301c522f52977b52ba7";;
+  aarch64-linux) zig_sha="ea4b09bfb22ec6f6c6ceac57ab63efb6b46e17ab08d21f69f3a48b38e1534f17";;
+  x86_64-linux) zig_sha="70e49664a74374b48b51e6f3fdfbf437f6395d42509050588bd49abe52ba3d00";;
+esac
+outdir="$here/${os}-${bun_arch}"
+zig_archive="zig-$zig_arch-$zig_os-$ZIG_VERSION.tar.xz"
+
+if [ ! -f "$zig_archive" ]; then
+  echo "== fetching zig $ZIG_VERSION =="
+  curl -fsSL -o "$zig_archive" "https://ziglang.org/download/$ZIG_VERSION/$zig_archive"
+fi
+printf '%s  %s\n' "$zig_sha" "$zig_archive" | shasum -a 256 -c -
+
+if [ ! -d ghostty ]; then
+  echo "== cloning ghostty @ $GHOSTTY_COMMIT =="
+  mkdir ghostty && cd ghostty && git init -q
+  git remote add origin https://github.com/ghostty-org/ghostty.git
+  cd ..
+fi
+if ! git -C ghostty cat-file -e "$GHOSTTY_COMMIT^{commit}" 2>/dev/null; then
+  git -C ghostty fetch -q --depth 1 origin "$GHOSTTY_COMMIT"
+fi
+
+# Build only from fresh trees materialized from the verified archive and exact
+# Git object. Cached working-tree edits and stale install outputs cannot enter.
+build_root="$(mktemp -d "$work/native-build.XXXXXX")"
+trap 'rm -rf "$build_root"' EXIT HUP INT TERM
+tar -xf "$zig_archive" -C "$build_root"
+zig="$build_root/zig-$zig_arch-$zig_os-$ZIG_VERSION/zig"
+ghostty_source="$build_root/ghostty"
+mkdir "$ghostty_source"
+git -C ghostty archive "$GHOSTTY_COMMIT" | tar -x -C "$ghostty_source"
+
+echo "== building libghostty-vt (ReleaseFast) =="
+cd "$ghostty_source"
+# The final xcframework packaging step can fail while the .a we need is produced,
+# so tolerate a non-zero exit here but assert the static lib exists below.
+vt_install="$build_root/vt-install"
+"$zig" build -Demit-lib-vt -Doptimize=ReleaseFast --prefix "$vt_install" || true
+cd ..
+staticlib="$vt_install/lib/libghostty-vt.a"
+[ -f "$staticlib" ] || { echo "build failed: $staticlib not produced" >&2; exit 1; }
+
+echo "== linking shim -> $outdir/$dylib =="
+mkdir -p "$outdir"
+if [ "$os" = "darwin" ]; then
+  "$zig" build-lib -dynamic -OReleaseFast -lc -femit-bin="$outdir/$dylib" \
+    -install_name "@rpath/$dylib" \
+    -I"$vt_install/include" "$here/src/shim.zig" "$staticlib" \
+    -framework CoreFoundation -framework CoreText -framework CoreGraphics
+else
+  "$zig" build-lib -dynamic -OReleaseFast -lc -femit-bin="$outdir/$dylib" \
+    -I"$vt_install/include" "$here/src/shim.zig" "$staticlib" -lm -lpthread
+fi
+echo "== done: $outdir/$dylib =="

package/native/src/pty.zig

@@ -0,0 +1,193 @@
+// Flat, FFI-trivial pseudo-terminal over libc forkpty(3). Exposes exactly what
+// the embedded Agent-tab terminal needs: spawn a child on a PTY, non-blocking
+// read of its output, write, resize, and reap. Handles are small ints into a
+// fixed table so bun:ffi only ever passes ints and byte pointers, never structs.
+//
+// Packed-argument contract (avoids shell parsing and per-token FFI marshalling):
+//   argv_packed: "arg0\0arg1\0...\0"  - NUL-separated, terminated by an empty
+//                                       token (a trailing extra NUL).
+//   env_packed:  "K=V\0K=V\0...\0"    - same shape; empty means inherit parent.
+//   cwd:         a plain C string, or empty to keep the parent's directory.
+
+const std = @import("std");
+const builtin = @import("builtin");
+
+const c = @cImport({
+    @cInclude("unistd.h");
+    @cInclude("fcntl.h");
+    @cInclude("errno.h");
+    @cInclude("signal.h");
+    @cInclude("stdlib.h");
+    @cInclude("string.h");
+    @cInclude("termios.h");
+    @cInclude("sys/ioctl.h");
+    @cInclude("sys/wait.h");
+    if (builtin.os.tag == .macos) @cInclude("util.h") else @cInclude("pty.h");
+});
+
+extern var environ: [*c][*c]u8;
+
+const MAX_SESSIONS = 64;
+const MAX_TOKENS = 1024;
+
+const PtySession = struct {
+    in_use: bool = false,
+    master_fd: c_int = -1,
+    pid: c.pid_t = 0,
+    reaped: bool = false,
+    exit_code: c_int = 0,
+};
+
+var sessions = [_]PtySession{.{}} ** MAX_SESSIONS;
+
+// Split a double-NUL-terminated packed buffer into a NULL-terminated array of
+// pointers into that same buffer. Returns the token count, or -1 on overflow.
+fn splitPacked(packed_buffer: [*c]u8, out: [][*c]u8) c_int {
+    var count: usize = 0;
+    var cursor: [*c]u8 = packed_buffer;
+    while (cursor[0] != 0) {
+        if (count >= out.len - 1) return -1;
+        out[count] = cursor;
+        count += 1;
+        cursor += c.strlen(cursor) + 1;
+    }
+    out[count] = null;
+    return @intCast(count);
+}
+
+// Reap the child once, recording its exit status. WNOHANG unless `block`.
+fn reapSession(session: *PtySession, block: bool) void {
+    if (session.reaped) return;
+    var status: c_int = 0;
+    const result = c.waitpid(session.pid, &status, if (block) 0 else c.WNOHANG);
+    if (result != session.pid) return;
+    session.reaped = true;
+    if (c.WIFEXITED(status)) {
+        session.exit_code = c.WEXITSTATUS(status);
+    } else if (c.WIFSIGNALED(status)) {
+        session.exit_code = 128 + c.WTERMSIG(status);
+    } else {
+        session.exit_code = -1;
+    }
+}
+
+fn sessionOf(handle: c_int) ?*PtySession {
+    if (handle < 0 or handle >= MAX_SESSIONS) return null;
+    const session = &sessions[@intCast(handle)];
+    if (!session.in_use) return null;
+    return session;
+}
+
+// Spawn `argv_packed` on a fresh PTY sized cols x rows, in cwd, with env_packed
+// (or the parent's env when empty). Returns a session handle, or -1 on failure.
+export fn cueloop_pty_spawn(argv_packed: [*c]u8, cwd: [*c]const u8, env_packed: [*c]u8, cols: c_int, rows: c_int) c_int {
+    var handle: c_int = -1;
+    for (0..MAX_SESSIONS) |index| {
+        if (!sessions[index].in_use) {
+            handle = @intCast(index);
+            break;
+        }
+    }
+    if (handle < 0) return -1;
+
+    var argv: [MAX_TOKENS][*c]u8 = undefined;
+    if (splitPacked(argv_packed, &argv) < 1) return -1;
+
+    var envp: [MAX_TOKENS][*c]u8 = undefined;
+    const have_env = env_packed != null and env_packed[0] != 0;
+    if (have_env and splitPacked(env_packed, &envp) < 0) return -1;
+
+    var winsize = std.mem.zeroes(c.struct_winsize);
+    winsize.ws_col = @intCast(cols);
+    winsize.ws_row = @intCast(rows);
+
+    var master_fd: c_int = -1;
+    const pid = c.forkpty(&master_fd, null, null, &winsize);
+    if (pid < 0) return -1;
+
+    if (pid == 0) {
+        // Child: adopt cwd/env then exec; _exit on any failure so a broken child never runs JS.
+        if (cwd != null and cwd[0] != 0) {
+            if (c.chdir(cwd) != 0) c._exit(127);
+        }
+        if (have_env) environ = &envp;
+        _ = c.execvp(argv[0], &argv);
+        c._exit(127);
+    }
+
+    // Parent: non-blocking master so reads can poll without stalling the loop.
+    const flags = c.fcntl(master_fd, c.F_GETFL, @as(c_int, 0));
+    _ = c.fcntl(master_fd, c.F_SETFL, flags | c.O_NONBLOCK);
+
+    sessions[@intCast(handle)] = .{
+        .in_use = true,
+        .master_fd = master_fd,
+        .pid = pid,
+        .reaped = false,
+        .exit_code = 0,
+    };
+    return handle;
+}
+
+export fn cueloop_pty_write(handle: c_int, data: [*c]const u8, len: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    const written = c.write(session.master_fd, data, @intCast(len));
+    return @intCast(written);
+}
+
+// Non-blocking read of child output. Returns bytes read (>0), 0 when nothing is
+// available yet, -2 once the child has exited and its output is drained, or -1.
+export fn cueloop_pty_read(handle: c_int, buf: [*c]u8, len: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    const bytes_read = c.read(session.master_fd, buf, @intCast(len));
+    if (bytes_read > 0) return @intCast(bytes_read);
+    if (bytes_read == 0) {
+        reapSession(session, true);
+        return -2; // EOF: slave closed
+    }
+    const err = std.c._errno().*;
+    if (err == c.EAGAIN or err == c.EWOULDBLOCK) {
+        reapSession(session, false);
+        return if (session.reaped) -2 else 0; // exited with no more output vs still running
+    }
+    if (err == c.EIO) {
+        reapSession(session, true);
+        return -2; // Linux: slave gone
+    }
+    return -1;
+}
+
+export fn cueloop_pty_resize(handle: c_int, cols: c_int, rows: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    var winsize = std.mem.zeroes(c.struct_winsize);
+    winsize.ws_col = @intCast(cols);
+    winsize.ws_row = @intCast(rows);
+    return c.ioctl(session.master_fd, c.TIOCSWINSZ, &winsize);
+}
+
+export fn cueloop_pty_kill(handle: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    return c.kill(session.pid, c.SIGTERM);
+}
+
+export fn cueloop_pty_get_pid(handle: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    return @intCast(session.pid);
+}
+
+export fn cueloop_pty_get_exit_code(handle: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    reapSession(session, true);
+    return session.exit_code;
+}
+
+export fn cueloop_pty_close(handle: c_int) void {
+    const session = sessionOf(handle) orelse return;
+    // Close the master first (hangs up the child), then block to reap it: after the
+    // SIGTERM from kill() plus this SIGHUP a well-behaved child exits at once, so the
+    // wait returns promptly and never leaves a zombie.
+    if (session.master_fd >= 0) _ = c.close(session.master_fd);
+    reapSession(session, true);
+    session.in_use = false;
+    session.master_fd = -1;
+}

package/native/src/shim.zig

@@ -0,0 +1,114 @@
+// Flat FFI wrapper over libghostty-vt. It hides the allocator vtable, the
+// by-value GhosttyPoint that bun:ffi cannot pass, and packed-cell decoding.
+const std = @import("std");
+const ghostty = @cImport({
+    @cInclude("ghostty/vt/types.h");
+    @cInclude("ghostty/vt/allocator.h");
+    @cInclude("ghostty/vt/terminal.h");
+    @cInclude("ghostty/vt/point.h");
+    @cInclude("ghostty/vt/grid_ref.h");
+    @cInclude("ghostty/vt/screen.h");
+    @cInclude("ghostty/vt/style.h");
+    @cInclude("ghostty/vt/color.h");
+});
+
+const CvtCell = extern struct {
+    codepoint: u32,
+    fg_r: u8,
+    fg_g: u8,
+    fg_b: u8,
+    fg_kind: u8,
+    bg_r: u8,
+    bg_g: u8,
+    bg_b: u8,
+    bg_kind: u8,
+    width: u8,
+    flags: u8,
+    _pad: u16,
+};
+
+comptime {
+    std.debug.assert(@sizeOf(CvtCell) == 16);
+}
+
+export fn cvt_new(cols: u16, rows: u16) ?*anyopaque {
+    var terminal: ghostty.GhosttyTerminal = null;
+    if (ghostty.ghostty_terminal_new(null, &terminal, cols, rows) != ghostty.GHOSTTY_SUCCESS) {
+        return null;
+    }
+    return terminal;
+}
+
+export fn cvt_free(terminal: ?*anyopaque) void {
+    if (terminal) |handle| ghostty.ghostty_terminal_free(@ptrCast(handle));
+}
+
+export fn cvt_write(terminal: *anyopaque, data: [*]const u8, len: usize) void {
+    ghostty.ghostty_terminal_vt_write(@ptrCast(terminal), data, len);
+}
+
+export fn cvt_resize(terminal: *anyopaque, cols: u16, rows: u16) void {
+    // Cell pixel size does not affect the character grid.
+    _ = ghostty.ghostty_terminal_resize(@ptrCast(terminal), cols, rows, 1, 1);
+}
+
+// Writes [col u16 LE, row u16 LE, visible u8] into the caller's eight bytes.
+export fn cvt_cursor(terminal: *anyopaque, out: [*]u8) void {
+    var x: u16 = 0;
+    var y: u16 = 0;
+    var visible = false;
+    _ = ghostty.ghostty_terminal_get(@ptrCast(terminal), ghostty.GHOSTTY_TERMINAL_DATA_CURSOR_X, &x);
+    _ = ghostty.ghostty_terminal_get(@ptrCast(terminal), ghostty.GHOSTTY_TERMINAL_DATA_CURSOR_Y, &y);
+    _ = ghostty.ghostty_terminal_get(@ptrCast(terminal), ghostty.GHOSTTY_TERMINAL_DATA_CURSOR_VISIBLE, &visible);
+    out[0] = @truncate(x);
+    out[1] = @truncate(x >> 8);
+    out[2] = @truncate(y);
+    out[3] = @truncate(y >> 8);
+    out[4] = @intFromBool(visible);
+}
+
+fn decodeColor(color: *const ghostty.GhosttyStyleColor, red: *u8, green: *u8, blue: *u8, kind: *u8) void {
+    if (color.tag == ghostty.GHOSTTY_STYLE_COLOR_RGB) {
+        kind.* = 2;
+        red.* = color.value.rgb.r;
+        green.* = color.value.rgb.g;
+        blue.* = color.value.rgb.b;
+    } else if (color.tag == ghostty.GHOSTTY_STYLE_COLOR_PALETTE) {
+        kind.* = 1;
+        red.* = @intCast(color.value.palette);
+    }
+}
+
+export fn cvt_cell(terminal: *anyopaque, x: u16, y: u32, out: *CvtCell) c_int {
+    out.* = std.mem.zeroes(CvtCell);
+
+    var point: ghostty.GhosttyPoint = undefined;
+    point.tag = ghostty.GHOSTTY_POINT_TAG_VIEWPORT;
+    point.value.coordinate.x = x;
+    point.value.coordinate.y = y;
+
+    var reference: ghostty.GhosttyGridRef = undefined;
+    if (ghostty.ghostty_terminal_grid_ref(@ptrCast(terminal), point, &reference) != ghostty.GHOSTTY_SUCCESS) return -1;
+
+    var cell: ghostty.GhosttyCell = undefined;
+    if (ghostty.ghostty_grid_ref_cell(&reference, &cell) != ghostty.GHOSTTY_SUCCESS) return -1;
+
+    _ = ghostty.ghostty_cell_get(cell, ghostty.GHOSTTY_CELL_DATA_CODEPOINT, &out.codepoint);
+    var width: u32 = 0;
+    _ = ghostty.ghostty_cell_get(cell, ghostty.GHOSTTY_CELL_DATA_WIDE, &width);
+    out.width = @intCast(width);
+
+    var style: ghostty.GhosttyStyle = undefined;
+    ghostty.ghostty_style_default(&style);
+    if (ghostty.ghostty_grid_ref_style(&reference, &style) == ghostty.GHOSTTY_SUCCESS) {
+        decodeColor(&style.fg_color, &out.fg_r, &out.fg_g, &out.fg_b, &out.fg_kind);
+        decodeColor(&style.bg_color, &out.bg_r, &out.bg_g, &out.bg_b, &out.bg_kind);
+        if (style.bold) out.flags |= 1;
+        if (style.italic) out.flags |= 2;
+        if (style.underline != 0) out.flags |= 4;
+        if (style.inverse) out.flags |= 8;
+        if (style.faint) out.flags |= 16;
+        if (style.strikethrough) out.flags |= 32;
+    }
+    return 0;
+}

package/package.json

@@ -1,46 +1,54 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.101",
+  "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mmurakaru/cueloop.git",
+    "directory": "packages/client"
+  },
+  "files": [
+    "src",
+    "native",
+    "README.md"
+  ],
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./config": "./src/settings/config.ts",
+    "./slash-palette": "./src/keyboard/slash-palette.ts"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.10",
-    "@cueloop/extension-api": "0.1.0-alpha.10",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.10",
-    "@cueloop/schema": "0.1.0-alpha.10",
-    "@opentui/core": "^0.4.3",
-    "@opentui/react": "^0.4.3",
-    "@opentui/ssh": "0.4.5",
-    "@pierre/diffs": "^1.3.5",
-    "react": "^19.2.0",
-    "shiki": "^4.4.2"
+    "@cueloop/daemon": "0.1.0-alpha.101",
+    "@cueloop/extension-api": "0.1.0-alpha.101",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.101",
+    "@cueloop/schema": "0.1.0-alpha.101",
+    "@opentui/core": "^0.5.14",
+    "@opentui/keymap": "0.5.14",
+    "@opentui/react": "^0.5.14",
+    "@opentui/ssh": "0.5.14",
+    "@pierre/diffs": "^1.5.1",
+    "@tanstack/virtual-core": "^3.17.11",
+    "diff": "^9",
+    "puppeteer-core": "^25.12.0",
+    "react": "^19.3.0",
+    "valibot": "^1.5.0",
+    "zustand": "^5.0.15"
   },
   "devDependencies": {
-    "@types/react": "^19.2.0",
-    "ssh2": "^1.17.0",
-    "@types/ssh2": "^1.15.5"
+    "@types/react": "^19.3.0",
+    "@types/ssh2": "^1.15.6",
+    "ssh2": "^1.17.0"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "src",
-    "README.md"
-  ],
   "engines": {
     "bun": ">=1.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mmurakaru/cueloop.git",
-    "directory": "packages/client"
-  },
-  "homepage": "https://github.com/mmurakaru/cueloop#readme",
-  "bugs": {
-    "url": "https://github.com/mmurakaru/cueloop/issues"
-  },
-  "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail"
-}
+  }
+}

package/src/annotations/annotation-palette.ts

@@ -0,0 +1,62 @@
+/**
+ * The shared annotation palette: how a marked stretch, the caret cell, and a
+ * discussion card's accent edge paint, in every surface that hosts inline
+ * comments (the plan thread view and the diff sheet). One source, so a mark
+ * looks the same wherever it is drawn.
+ */
+
+import { createTextAttributes } from "@opentui/core";
+import type { Theme } from "../appearance/theme";
+
+export const UNDERLINE = createTextAttributes({ underline: true });
+export const CUT = createTextAttributes({ strikethrough: true, dim: true });
+export const BOLD = createTextAttributes({ bold: true });
+export const ITALIC = createTextAttributes({ italic: true });
+
+/** The marked-words treatment: a violet backdrop under an underline. */
+const MARK_BACKDROP_DARK = "#463852";
+const MARK_BACKDROP_LIGHT = "#e6ddf5";
+/** The discussion card's accent left edge. */
+const CARD_EDGE_DARK = "#ab7aca";
+const CARD_EDGE_LIGHT = "#8b5fd6";
+/** The caret cell: a visible cursor painted on the character under the caret. */
+const CARET_CELL_DARK = "#565b68";
+const CARET_CELL_LIGHT = "#b8bcc8";
+
+export interface AnnotationPalette {
+  markBackdrop: string;
+  cardEdge: string;
+  caretCell: string;
+}
+
+/** Dark tokens carry light text; use that to pick the palette variant. */
+export function annotationPaletteFor(tokens: Theme): AnnotationPalette {
+  const dark = Number.parseInt(tokens.text.slice(1, 3) || "e4", 16) > 128;
+
+  return dark
+    ? { markBackdrop: MARK_BACKDROP_DARK, cardEdge: CARD_EDGE_DARK, caretCell: CARET_CELL_DARK }
+    : {
+        markBackdrop: MARK_BACKDROP_LIGHT,
+        cardEdge: CARD_EDGE_LIGHT,
+        caretCell: CARET_CELL_LIGHT,
+      };
+}
+
+/** Focus cue: mix a hex color toward white, keeping its hue readable. */
+export function lighten(hex: string, amount = 0.25): string {
+  const channels = hex.match(/^#(..)(..)(..)$/);
+
+  if (!channels) return hex;
+  const lifted = channels
+    .slice(1)
+    .map((channel) => {
+      const value = Number.parseInt(channel, 16);
+
+      return Math.round(value + (255 - value) * amount)
+        .toString(16)
+        .padStart(2, "0");
+    })
+    .join("");
+
+  return `#${lifted}`;
+}

package/src/annotations/components/AnnotationCards.stories.tsx

@@ -0,0 +1,86 @@
+import React from "react";
+import type { Annotation } from "@cueloop/schema";
+import { DARK } from "../../appearance/theme";
+import { annotationPaletteFor } from "../annotation-palette";
+import { slashItemsFrom } from "../../keyboard/slash-palette";
+import { DEFAULT_QUICK_ACTIONS } from "../../settings/config";
+import type { Story, StoryMeta } from "../../stories/story";
+import { CommentRow, ComposerPalette, DiscussionCard } from "./AnnotationCards";
+
+export const meta: StoryMeta = { title: "Chrome/AnnotationCards" };
+
+const palette = annotationPaletteFor(DARK);
+
+function annotation(id: string, body: string, author?: string): Annotation {
+  const comment: Annotation = {
+    id,
+    kind: "comment",
+    anchor: { quote: "the daemon", prefix: "", suffix: "" },
+    body,
+    createdAt: "2026-09-07T10:00:00.000Z",
+  };
+
+  if (author !== undefined) comment.author = author;
+
+  return comment;
+}
+
+// A two-voice discussion: the owner's comment then a collaborator's reply, each
+// segment wearing its own accent edge.
+export const TwoVoices: Story = {
+  render: () => (
+    <DiscussionCard
+      tokens={DARK}
+      segments={[
+        {
+          color: palette.cardEdge,
+          node: <CommentRow annotation={annotation("a", "Which daemon?")} tokens={DARK} />,
+        },
+        {
+          color: DARK.text,
+          node: (
+            <CommentRow
+              annotation={annotation("b", "The one the CLI spawns.", "fp:collab")}
+              tokens={DARK}
+            />
+          ),
+        },
+      ]}
+    />
+  ),
+  expectedColors: [palette.cardEdge, DARK.text],
+  size: { width: 60, height: 8 },
+};
+
+export const FocusedCard: Story = {
+  render: () => (
+    <DiscussionCard
+      focused
+      tokens={DARK}
+      segments={[
+        {
+          color: palette.cardEdge,
+          node: (
+            <CommentRow annotation={annotation("a", "Needs an eviction story.")} tokens={DARK} />
+          ),
+        },
+      ]}
+    />
+  ),
+  expectedColors: [DARK.text],
+  size: { width: 60, height: 6 },
+};
+
+// The palette a leading "/" opens under the composer, with the second item selected.
+export const SlashPaletteOpen: Story = {
+  render: () => (
+    <ComposerPalette
+      slashActive
+      slashItems={slashItemsFrom(DEFAULT_QUICK_ACTIONS)}
+      slashIndex={1}
+      tokens={DARK}
+    />
+  ),
+  expectedColors: [DARK.accent, DARK.textDim],
+  size: { width: 90, height: 8 },
+};