@cueloop/client 0.1.0-alpha.5 → 0.1.0-alpha.50

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,45 +1,50 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.5",
+  "version": "0.1.0-alpha.50",
+  "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/config.ts"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.5",
-    "@cueloop/extension-api": "0.1.0-alpha.5",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.5",
-    "@cueloop/schema": "0.1.0-alpha.5",
-    "@opentui/core": "^0.4.3",
-    "@opentui/react": "^0.4.3",
+    "@cueloop/daemon": "0.1.0-alpha.50",
+    "@cueloop/extension-api": "0.1.0-alpha.50",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.50",
+    "@cueloop/schema": "0.1.0-alpha.50",
+    "@opentui/core": "^0.5.2",
+    "@opentui/keymap": "0.5.2",
+    "@opentui/react": "^0.5.2",
+    "@opentui/ssh": "0.5.2",
     "@pierre/diffs": "^1.3.5",
-    "react": "^19.2.0",
-    "@opentui/ssh": "0.4.5"
+    "diff": "^8",
+    "puppeteer-core": "^25.8.0",
+    "react": "^19.2.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.0",
-    "ssh2": "^1.17.0",
-    "@types/ssh2": "^1.15.5"
+    "@types/ssh2": "^1.15.5",
+    "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/App.autoclose.test.tsx

@@ -0,0 +1,137 @@
+/** Post-submit completion overlay: prompt, opt-in persistence, countdown, dismissal. Countdown seconds tick on an injected ManualClock, so tests advance time instead of waiting it out. */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { ManualClock } from "@opentui/core/testing";
+import { DaemonServer } from "@cueloop/daemon";
+import type { ReviewSession } from "@cueloop/schema";
+import { App } from "./App";
+import { isolateUserConfig, press, settle, waitForText } from "./test-support";
+
+const PLAN = "# Plan\n\nShip the thing.\n";
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+let configPath: string;
+let restoreUserConfig: () => void;
+let clock: ManualClock;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-close-"));
+  configPath = join(home, "config.toml");
+  restoreUserConfig = isolateUserConfig(home, "config.toml");
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN, meta: { title: "Plan" } },
+  });
+  clock = new ManualClock();
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp(onExit?: (code: number) => void) {
+  const setup = await testRender(
+    <App home={home} sessionId={session.id} onExit={onExit} clock={clock} />,
+    {
+      width: 120,
+      height: 30,
+    },
+  );
+  await waitForText(setup, "cueloop");
+  return setup;
+}
+
+type Setup = Awaited<ReturnType<typeof renderApp>>;
+
+async function submitApprove(setup: Setup): Promise<void> {
+  await press(setup, "enter"); // open submit (approve default: no pending items)
+  await press(setup, "enter"); // confirm
+  await waitForText(setup, "review approved");
+}
+
+describe("completion overlay", () => {
+  test("submit with auto-close off counts down from 5; ⏎ exits now", async () => {
+    // Arrange
+    let exited = -1;
+    const setup = await renderApp((code) => (exited = code));
+
+    // Act
+    await submitApprove(setup);
+
+    // Assert
+    const frame = await waitForText(setup, "closing in 5s");
+    expect(frame).toContain("review approved");
+    expect(frame).toContain("close [return]");
+    expect(frame).toContain("return to plan [esc]");
+
+    // Act
+    await press(setup, "enter");
+
+    // Assert
+    expect(exited).toBe(0);
+  });
+
+  test("a remembers the countdown as the persisted default", async () => {
+    // Arrange
+    const setup = await renderApp();
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 5s");
+
+    // Act
+    await press(setup, "a");
+
+    // Assert
+    expect(existsSync(configPath)).toBe(true);
+    expect(readFileSync(configPath, "utf8")).toContain("auto_close = 5");
+
+    // Act
+    // the countdown keeps running; each second is one manual-clock tick
+    clock.advance(1000);
+
+    // Assert
+    await waitForText(setup, "closing in 4s");
+  });
+
+  test("esc dismisses to the resolved read-only view", async () => {
+    // Arrange
+    const setup = await renderApp();
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 5s");
+
+    // Act
+    // a bare ESC sits in the input parser's escape-sequence disambiguation
+    // window before it is delivered - the frame wait absorbs it
+    await press(setup, "escape");
+
+    // Assert
+    const frame = await waitForText(setup, "resolved: approve");
+    expect(frame).not.toContain("closing in");
+  });
+
+  test("configured auto_close counts down and exits without interaction", async () => {
+    // Arrange
+    writeFileSync(configPath, "[ui]\nauto_close = 1\n");
+    let exited = -1;
+    const setup = await renderApp((code) => (exited = code));
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 1s");
+    expect(exited).toBe(-1);
+
+    // Act
+    clock.advance(1000);
+    await settle(setup);
+
+    // Assert
+    expect(exited).toBe(0);
+  });
+});