frayui 0.1.0 → 0.1.2

package/README.md

@@ -1,186 +1,64 @@
-# fray-ui
-
-fray-ui is a workspace-scoped orchestration surface for [fray](https://github.com/colinhacks/fray): a localhost server plus a web
-client (opened as a normal tab in your default browser) that shows a sidebar of your repo's `.fray/`
-threads and, for the selected thread, a live embedded Claude Code terminal. You dispatch agents,
-watch them work, follow up, and clear the "awaiting you" queue — one server per repo. The UI itself
-has zero orchestration intelligence: all the judgment lives in the user-editable dispatch preamble
-(Settings) and in the [`cc-worker`](https://github.com/colinhacks/fray/tree/main/cc-worker) plugin that every dispatched agent loads.
+<p align="center">
+  <h1 align="center">🧵<br/><code>fray</code></h1>
+  <p align="center">A local dashboard for running many coding agents at once.
+    <br/>
+    by <a href="https://x.com/colinhacks">@colinhacks</a>
+  </p>
+</p>
+<br/>
+
+<p align="center">
+<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/fray" alt="License"></a>
+<a href="https://www.npmjs.com/package/frayui" rel="nofollow"><img src="https://img.shields.io/npm/dw/frayui.svg" alt="npm"></a>
+<a href="https://github.com/colinhacks/fray" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/fray" alt="stars"></a>
+</p>
+
+## What is fray?
+
+Run one agent and you babysit a terminal. Run ten and you lose track of which ones are working, which
+are stuck, and which are waiting on you.
+
+fray is a web UI that runs on your machine, scoped to one repo. You describe a task, fray dispatches a
+real [Claude Code](https://claude.com/claude-code) or [Codex](https://developers.openai.com/codex)
+session to drive it, and every session shows up as a thread you can watch, steer, answer, or drop into
+a live terminal. Threads that need you sort to the top; the rest get out of the way.
+
+There is no cloud, no account, and no agent of its own — fray is a window onto the CLIs you already
+have installed.
 
 ## Quickstart
 
-```bash
-cd /path/to/fray
-nub install
-nub run fray-dev:install          # one-time: writes ~/.local/bin/fray-dev → this checkout's CLI source
-```
-
-Then, from any Git repository:
+Requires **Node 26+**, `tmux`, and the [Claude Code](https://claude.com/claude-code) or
+[Codex](https://developers.openai.com/codex) CLI signed in.
 
-```bash
-cd /path/to/a/workspace
-fray-dev                        # foreground immutable server + default-browser request; Ctrl-C stops it
-fray-dev /path/to/other/repo    # explicitly select a repository
-fray-dev --app                  # opt in to the legacy dedicated app window
-fray-dev --no-app               # reuse/start and print its URL without opening a browser
-fray-dev --status               # workspace, source checkout, port, supervisor PID
-fray-dev --stop                 # stop only the UI server; agent tmux sessions survive
-fray-dev --foreground           # compatibility spelling; Fray already runs in the foreground
+```sh
+cd /path/to/your/repo
+npx frayui
 ```
 
-## Production npm launcher
-
-The development command above is deliberately source-backed. The intended production command is a
-separate registry package: `npx frayui` will run the npm-resolved `frayui` package and never follow
-this checkout. The current package metadata still uses the working name `fray`; migrating it to the
-single-file `frayui` bundle is a separate release-packaging slice. When a published release is
-available, **Update & Restart** will ask npm for a fresh immutable package execution cache, drain only
-Fray's disposable HTTP control plane, and start that cache with the
-same project identity, port, SQLite state, tmux socket, and provider sessions. It does not edit the
-currently executing `npx` cache or replace an arbitrary global installation.
-
-This repository has **not** published the package or verified ownership/availability of the unscoped
-`frayui` npm name. The current workspace dependencies still need a maintainer-selected release closure (publish the
-`@fray-ui/*` runtime packages, or build one audited bundled runtime tarball) before `npx frayui` can
-be released; the npm publisher account and that packaging decision require maintainer action.
-Until then, `fray-dev` is the supported command for this checkout.
-
-`fray-dev` is source-backed only at launch: the installed shim contains an absolute, shell-safe pointer
-to this checkout's `packages/cli/src/index.ts`, not a copied build. On each fresh launch after that
-workspace's Fray supervisor has stopped, it selects a verified immutable artifact matching the current
-source fingerprint, reuses an identical global artifact when one exists, or builds and promotes one
-automatically. No manual `build`/`promote` step or repeated shim install is required. The running server
-never watches this checkout and never runs HMR: edits made while it is running do nothing until you stop
-Fray and run `fray-dev` again. SQLite state, persisted port, lock, legacy app profile, and tmux socket
-are keyed by a stable checkout UUID. An ordinary/main worktree retains the repo's
-`git config --local fray.id`; each linked Git worktree keeps a different UUID in its private Git
-administrative directory. Canonical real paths make a checkout opened through a symlink reuse the
-same instance, while sibling worktrees remain isolated even when their paths contain spaces.
-Managed ordinary repositories use `tmux -L fray-repo-<full UUID>`; a durable migration record keeps
-an attributable historical `fray-<8 chars>` server pinned until its sessions are gone, then switches
-permanently without moving them. An explicit `FRAY_TMUX_SOCKET` is an unmanaged escape hatch and is
-used verbatim—Fray does not inspect, migrate, or add ownership markers to that server.
-
-`fray-dev` stays in the foreground while it serves its immutable snapshot; Ctrl-C stops only that
-workspace's UI server. A second `fray-dev` verifies `/health` has both this UUID and exact canonical
-worktree root, then asks the OS to open its URL in the configured default browser instead of starting
-a competitor. New workspaces serialize only port allocation/startup, then run concurrently on isolated
-ports and tmux sockets. `--port <n>` is an explicit new-launch request and fails clearly on a conflict.
-Broken live supervisors are never silently replaced; inspect `fray-dev --status`, fix source, or use
-`fray-dev --stop`.
-
-If `~/.local/bin` is not on `PATH`, the installer prints the exact export to add. Use
-`FRAY_BIN_DIR=/another/bin nub run fray-dev:install` to choose another directory; it refuses to overwrite
-an unrelated `fray-dev` executable unless passed `--force`. `nub run fray-dev:check` verifies the owned
-shim without changing it, and `nub run fray-dev:uninstall` removes only that owned shim. `fray-ui` remains
-a package-bin alias for compatibility, but `fray-dev` is the canonical source-checkout command.
-
-## Browser launch modes
-
-The default `fray-dev` launch makes one standard OS request to open its localhost URL in the configured
-default browser. The launcher waits for the OS handler to accept or reject that request; the browser
-decides which window or process receives it. In particular, macOS may choose among running browser
-instances that share one bundle identity. Fray does not scan, reuse, focus, or privately address
-browser tabs. External links use native safe new-tab navigation and internal links stay in the local
-browser context. `fray-dev --no-app` remains the print-only option.
-
-`fray-dev --app` preserves the legacy dedicated/chromeless window as an explicit compatibility opt-in.
-On macOS that window gets its **own Dock name ("Fray") and icon**. On the first opt-in app launch,
-the launcher silently installs the Fray PWA into the project's browser profile
-over the Chrome DevTools Protocol (`--remote-debugging-pipe` → `PWA.install` +
-`PWA.changeAppUserSettings(displayMode: standalone)`; windowless, ~3-4s, once per machine). Chrome
-then generates a real app-shim bundle at `~/Applications/Chrome Apps.localized/fray.app` — own
-`CFBundleName`, icon rasterized from our web-app manifest — and every launch goes through that shim
-(`open fray.app`), whose `app_mode_loader` hosts the window under its own bundle identity. Verified:
-`lsappinfo` shows `LSDisplayName="fray"`, `Arch=ARM64`, and the Dock shows fray's own tile.
-Subsequent launches detect the existing shim (~60ms) and skip the install.
-
-Why it works this way (all verified empirically on Chrome 150 / macOS):
-
-- A plain `--app=` window is owned by the Chrome browser process — the Dock shows "Google Chrome",
-  no launch flag changes it, and a hand-rolled `.app` that `exec`s Chrome loses its identity the
-  moment Chrome's Cocoa startup re-registers the process (and risks a Rosetta launch besides).
-  Chrome's generated app-shim is the only mechanism that yields an own Dock identity.
-- The CDP `PWA.*` domain is only exposed on `--remote-debugging-pipe` connections (port-based
-  websocket clients lack `AllowUnsafeOperations`), and a CDP install defaults the app to
-  open-in-a-tab — `changeAppUserSettings(displayMode: "standalone")` is the required second half;
-  without it the browser answers the shim `kSuccessAndDisconnect` and windows stay Chrome-branded.
-- Shim detection is stateless: the launcher scans shim `Info.plist`s for `CrAppModeShortcutURL` ==
-  the launch URL and `CrAppModeUserDataDir` under the project profile. (Chrome's generated app id is
-  not reproducible as a hash of the URL — don't try.)
-
-Failure at any opt-in app step (profile busy, install error, no shim found) falls back silently to
-the plain `--app` window. [`packages/web/public/favicon.svg`](https://github.com/colinhacks/fray/tree/main/packages/web/public/favicon.svg) is
-the canonical icon artwork; `nub scripts/generate-icons.mjs` regenerates its six tracked PNG
-derivatives, while `nub scripts/generate-icons.mjs --check` detects drift. On macOS,
-`nub scripts/generate-icons.mjs --refresh-app-icons` also refreshes the ICNS resource in idle,
-metadata-verified Fray PWA shims without launching Chrome; it stages and verifies each ad-hoc-signed
-bundle before swapping it into place. The manifest lives in
-[`packages/web/public/`](https://github.com/colinhacks/fray/tree/main/packages/web/public); the window title is set at runtime to
-`fray · <owner/repo>` from the board snapshot.
-
-*Windows/Linux follow-ups (not yet wired):* the launcher only brands the Dock on macOS. Windows would
-set an `AppUserModelID` (+ icon) on a generated `.lnk`; Linux (X11) would pass `--class=fray` and ship
-a `.desktop` file whose `StartupWMClass=fray` matches it. Both are documented TODOs.
-
-## Architecture (10 lines)
-
-1. Workspace-scoped: one server per repo, launched from the repo root, watching only that repo's `.fray/`.
-2. `.fray/` thread files are the source of truth for thread status — the server imports fray's own
-   board parser (`cc/scripts/fray/*.mjs`), never re-implements it.
-3. Session JSONL (`~/.claude/projects/<slug>/*.jsonl`) is telemetry only: liveness + previews, parsed defensively.
-4. Agents are top-level processes in detached tmux sessions on the workspace's private, UUID-keyed socket.
-5. The web terminal attaches per-viewer via node-pty (`tmux attach`); closing a tab kills only that attach client.
-6. A single `/events` SSE channel pushes full board snapshots (no diff protocol) plus `notify` events.
-7. RPC is a typed query/mutation layer over Hono at `/rpc`; the terminal is a WebSocket at `/term/:slug`.
-8. `web` is React 19 + Vite + Tailwind v4 + valtio + TanStack Query + xterm.js.
-9. UI state (unread, settings, session registry) lives in `~/.fray/projects/<id>/ui.db` (SQLite), never in `.fray/`.
-10. Packages: `shared` (zod contract), `rpc`, `server`, `web`, `cli`. Read `ARCHITECTURE.md` before touching any.
-
-## Settings & the dispatch preamble
-
-Everything the UI deliberately does NOT know lives in **Settings** (gear icon): the
-**dispatch preamble** is injected verbatim ahead of every dispatched agent's task, carrying the
-orchestration wisdom (sub-agent discipline, git hygiene, the stop criterion). It ships from
-[`DEFAULT_PREAMBLE.md`](https://github.com/colinhacks/fray/blob/main/packages/server/src/DEFAULT_PREAMBLE.md); edit it per project and use **Reset preamble to
-default** to clear your overrides back to the shipped defaults. Settings also carry the default
-model, effort, and a desktop-notifications toggle (which requests browser
-permission and only fires when the Fray tab or window is hidden).
+That's the whole setup. It opens a browser tab, and one server runs per repo.
 
-## `FRAY.md` — a repo's own worker norms
+## How it works
 
-The dispatch preamble is per-**operator** state that lives in the UI's database. For norms that should
-travel **with the repo** and be shared by the whole team, drop a **`FRAY.md`** at the project root.
-When present, its contents are injected into every dispatched worker's system prompt (dispatch, adopt,
-and resume, on both the Claude and Codex backends) under a header stating that they **override fray's
-built-in worker defaults** wherever they conflict. Fray's worker contract is deliberately
-defer-by-default: its engineering-process guidance (review depth, git/PR conventions, the quality bar)
-is a default for when the project is silent, and `FRAY.md` is how a project speaks. Use it to say
-things like "our gates are `pnpm check`", "skip the independent adversarial review on small UI diffs —
-implementer self-review plus a browser screenshot is enough", or "push to a branch + PR, never merge
-your own". The fray-mechanical contract (signal fences, scratchpad, the browser runtime gate) is not
-overridable. Keep it concise — it's read fresh on every spawn and bounded to stay within the
-system-prompt budget.
+- **One thread, one effort.** Each thread owns a single top-level agent session in a detached `tmux`
+  session, so closing the tab never kills the work. `tmux -L fray attach` is always there if you want
+  the raw terminal.
+- **Agents signal, they don't just stop.** A worker ends its turn with a fenced ` ```done `,
+  ` ```awaiting `, or ` ```question ` block. fray renders those as cards — a question becomes
+  answerable choices, an `awaiting pr-watch:` parks the thread and wakes it when the PR moves.
+- **Nothing is hidden in the app.** All the orchestration judgment lives in text you can edit: the
+  **dispatch preamble** in Settings, and a **`FRAY.md`** at your repo root whose contents are injected
+  into every worker and override fray's defaults.
+- **State stays out of your repo.** Unread counts, settings, and the session registry live in
+  `~/.fray/projects/<id>/ui.db`.
 
-## The cc-worker plugin
+## Docs
 
-Every agent fray-ui spawns loads the [`cc-worker`](https://github.com/colinhacks/fray/tree/main/cc-worker) Claude Code plugin
-(`--plugin-dir`), which supplies the single-thread worker contract and hooks. Its hooks gate on the
-`FRAY_UI_THREAD` env var, so passing it is harmless even in a non-fray repo. In the monorepo it is
-found automatically as a sibling of `cc/`; a standalone install points at it with
-`FRAY_WORKER_PLUGIN_DIR`.
+- [`ARCHITECTURE.md`](ARCHITECTURE.md) — the invariants, layout, and design decisions. Read it before
+  changing anything.
+- [`cc-worker/`](cc-worker) — the Claude Code plugin every dispatched agent loads.
+- [`board/`](board) — the zero-dep `.fray/` board parser the server shells out to.
 
-## Troubleshooting
+## License
 
-- **Terminal never attaches / `spawn-helper` errors.** node-pty prebuilds lose the exec bit when
-  npm/pnpm unpack them. The server package's `postinstall` re-chmods it; if it didn't run, do it
-  manually: `chmod +x node_modules/node-pty/prebuilds/*/spawn-helper`. PTY code cannot run inside a
-  sandboxed shell.
-- **Escape hatch into a stuck agent.** The sessions live on the workspace socket recorded in
-  `~/.fray/projects/<id>/project-launch.owner` (or `tmux-socket-migration.json` while stopped).
-  Attach with `tmux -L <socket> attach -t fray-<slug>` and detach with `Ctrl-b d`.
-- **Non-monorepo install** (fray-ui run against a repo outside this monorepo): set
-  `FRAY_SCRIPTS_DIR` to the installed plugin's `scripts/fray` directory (the board parser) and
-  `FRAY_WORKER_PLUGIN_DIR` to the `cc-worker` plugin directory.
-- **Port already in use.** Omit `--port` to let `fray-dev` allocate and persist an isolated port. An
-  explicit occupied port is rejected; `fray-dev --status` shows the workspace's current owner.
+MIT

package/dist/dev-child.js

@@ -6551,21 +6551,38 @@ function parseAgentMessage(text) {
 function wakeItemTail(item) {
   return `${item.at ? ` at ${item.at}` : ""}${item.url ? `: ${item.url}` : ""}`;
 }
+function wakeReviewReads({ ref, items }) {
+  const [repo, number] = ref.split("#");
+  const ids = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const id = /#pullrequestreview-(\d+)$/.exec(item.url ?? "")?.[1];
+    if (id) ids.add(id);
+  }
+  return [...ids].map((id) => `gh api --paginate repos/${repo}/pulls/${number}/reviews/${id}/comments`);
+}
+function wakeReviewTail(steer) {
+  const reads = wakeReviewReads(steer);
+  return reads.length ? `
+
+${WAKE_REVIEW_LEAD}
+${reads.join("\n")}` : "";
+}
 function formatGithubWakeSteer({ ref, items, omitted }) {
   const icon = items.some((i) => !i.bot) ? "\u{1F464}" : "\u{1F916}";
+  const reviewTail = wakeReviewTail({ ref, items, omitted });
   if (items.length === 1 && omitted === 0) {
     const item = items[0];
     const url = item.url ? `: ${item.url}` : ".";
-    return `${icon} New GitHub ${item.label} on ${ref} from @${item.actor}${item.at ? ` at ${item.at}` : ""}. Read that exact ${item.label} \u2014 ${WAKE_SCOPE} \u2014 and continue${url}`;
+    return `${icon} New GitHub ${item.label} on ${ref} from @${item.actor}${item.at ? ` at ${item.at}` : ""}. Read that exact ${item.label} \u2014 ${WAKE_SCOPE} \u2014 and continue${url}${reviewTail}`;
   }
   const more = omitted > 0 ? `
 - \u2026and ${omitted} more not listed \u2014 check ${ref} for the rest` : "";
   const lines = items.map((i) => `- ${i.bot ? "\u{1F916}" : "\u{1F464}"} ${i.label} from @${i.actor}${wakeItemTail(i)}`).join("\n");
   return `${icon} ${items.length + omitted} new GitHub items on ${ref}. Read exactly these \u2014 ${WAKE_SCOPE} \u2014 and continue:
 
-${lines}${more}`;
+${lines}${more}${reviewTail}`;
 }
-var ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrayStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, NativeInputRequired, AwaitingHint, AWAITING_TIMER_RE, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, ThreadFence, PlanView, LimitWindow, LimitPause, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AuthSnapshot, AccountLogoutInput, AccountLogoutResult, AccountLoginStartInput, AccountLoginStartResult, AccountLoginStatusInput, AccountLoginStatusResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, FollowUpInput, UnqueueFollowUpInput, UnqueueFollowUpResult, SetThreadSnoozeInput, ConfirmAwaitingInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, SetThreadProfileInput, SetThreadProfileResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, GITHUB_DISPATCH_UI_BOUNDARY, WAKE_DELIVERY_TOKEN_TAIL, AGENT_MESSAGE_WRAPPER, WAKE_SCOPE, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, GithubStatus, GithubItem, GithubListInput, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, THOUGHT_EVENT_PREFIX, TranscriptPart, TranscriptMessage, TranscriptPageCursor, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketClientMsg, DEFAULT_PORT, tmuxSessionName;
+var ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrayStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, NativeInputRequired, AwaitingHint, AWAITING_TIMER_RE, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, ThreadFence, PlanView, LimitWindow, LimitPause, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AuthSnapshot, AccountLogoutInput, AccountLogoutResult, AccountLoginStartInput, AccountLoginStartResult, AccountLoginStatusInput, AccountLoginStatusResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, FollowUpInput, UnqueueFollowUpInput, UnqueueFollowUpResult, SetThreadSnoozeInput, ConfirmAwaitingInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, SetThreadProfileInput, SetThreadProfileResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, GITHUB_DISPATCH_UI_BOUNDARY, WAKE_DELIVERY_TOKEN_TAIL, AGENT_MESSAGE_WRAPPER, WAKE_SCOPE, WAKE_REVIEW_LEAD, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, GithubStatus, GithubItem, GithubListInput, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, THOUGHT_EVENT_PREFIX, TranscriptPart, TranscriptMessage, TranscriptPageCursor, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketClientMsg, DEFAULT_PORT, tmuxSessionName;
 var init_src = __esm({
   "packages/shared/src/index.ts"() {
     "use strict";
@@ -7271,6 +7288,7 @@ ${DISPATCH_TASK_BANNER}
     WAKE_DELIVERY_TOKEN_TAIL = /\n*<!-- fray-wake:[A-Za-z0-9_-]+ -->\s*$/;
     AGENT_MESSAGE_WRAPPER = /^<agent-message from="([^"]*)">\n?([\s\S]*?)\n?<\/agent-message>\s*$/;
     WAKE_SCOPE = "ignore older activity you have already handled";
+    WAKE_REVIEW_LEAD = "A review's body is often empty because its substance is inline comments. Read them, one call each:";
     WAKE_REF = String.raw`[A-Za-z0-9][\w.-]*\/[A-Za-z0-9][\w.-]*#\d+`;
     WAKE_SINGLE = new RegExp(
       String.raw`^(👤|🤖) New GitHub (.+?) on (${WAKE_REF}) from @(\S+?)(?: at (\S+?))?\. Read that exact .+? — ` + WAKE_SCOPE + String.raw` — and continue(?::\s*(\S+)|\.)$`
@@ -13378,7 +13396,7 @@ import { basename as basename3, dirname as dirname5, join as join10, resolve as
 import { promisify as promisify4 } from "node:util";
 function frayScriptsDir() {
   if (process.env.FRAY_SCRIPTS_DIR) return process.env.FRAY_SCRIPTS_DIR;
-  return resolve5(import.meta.dirname, "..", "..", "..", "cc", "scripts", "fray");
+  return resolve5(import.meta.dirname, "..", "..", "..", "board");
 }
 function directFrayRoot(projectDir) {
   try {
@@ -13416,7 +13434,7 @@ async function readBoard(projectDir, scriptsDir = frayScriptsDir()) {
     threads: rawThreads.filter((thread) => ThreadSlug.safeParse(thread?.id).success),
     errors: [...Array.isArray(parsed.errors) ? parsed.errors : [], ...invalidErrors],
     warnings: Array.isArray(parsed.warnings) ? parsed.warnings : [],
-    // Additive: absent on a pre-update fray script (older cc/scripts) → [] (the board just loses the
+    // Additive: absent on a pre-update fray script (older board scripts) → [] (the board just loses the
     // repair affordance, never the plain error strings).
     errorItems: [...Array.isArray(parsed.errorItems) ? parsed.errorItems : [], ...invalidErrorItems]
   };
@@ -33978,6 +33996,7 @@ function isDirectHookExecution(argv1, moduleUrl) {
 }
 var init_bash_background = __esm({
   "cc-worker/hooks/bash-background.mjs"() {
+    "use strict";
     if (isDirectHookExecution(process.argv[1], import.meta.url)) {
       try {
         const env = process.argv.includes("--fray-ui-thread") ? { ...process.env, FRAY_UI_THREAD: process.env.FRAY_UI_THREAD || "codex-worker" } : process.env;

package/dist/frayui.js

@@ -7214,14 +7214,14 @@ var init_local_image = __esm({
   }
 });
 
-// packages/cli/src/production.ts
+// src/production.ts
 import { spawn as spawn2 } from "node:child_process";
 import { closeSync as closeSync4, openSync as openSync4 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { join as join7 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 
-// packages/cli/src/launcher.ts
+// src/launcher.ts
 init_project_identity();
 init_project_launch();
 init_tmux_socket();
@@ -7515,7 +7515,7 @@ async function waitForWorkspace(port, expected2, timeoutMs = LAUNCH_TIMEOUT_MS,
   }
 }
 
-// packages/cli/src/production.ts
+// src/production.ts
 init_project_launch();
 
 // packages/server/src/dev-supervisor.ts
@@ -7847,9 +7847,9 @@ function classifyDevChange(path, roots = defaultDevWatchRoots()) {
     return "launcher";
   }
   if (!SOURCE_EXTENSIONS.has(extname2(name))) return null;
+  if (parts[0] === "src") return "launcher";
   if (parts[0] !== "packages" || parts[2] !== "src") return null;
   const pkg = packageName;
-  if (pkg === "cli") return "launcher";
   if (pkg === "server") {
     if (name === "dev-supervisor.ts" || name === "dev.ts") return "launcher";
     return "child";
@@ -8446,7 +8446,7 @@ async function startDevSupervisor(opts) {
   return supervisor;
 }
 
-// packages/cli/src/production-update.ts
+// src/production-update.ts
 import { execFile, spawn } from "node:child_process";
 var PRODUCTION_REEXEC_FLAG = "--_fray-production-reexec";
 function compareReleaseVersions(a, b) {
@@ -8517,7 +8517,7 @@ var npmRegistryReleaseAdapter = {
   }
 };
 
-// packages/cli/src/preflight.ts
+// src/preflight.ts
 import { spawnSync } from "node:child_process";
 import { chmodSync, statSync as statSync5 } from "node:fs";
 import { createRequire } from "node:module";
@@ -8566,7 +8566,7 @@ function ensureNativeHelperPermissions(options2 = {}) {
   }
 }
 
-// packages/cli/src/production.ts
+// src/production.ts
 var ABANDON_GRACE_MS = 3e3;
 var PACKAGE_NAME = process.env.FRAY_REGISTRY_PACKAGE ?? "frayui";
 var PACKAGE_VERSION = process.env.npm_package_version ?? "0.0.1";
@@ -8651,7 +8651,7 @@ async function runSupervisor(port, token) {
   const env = projectLaunchEnvironment({ ...process.env, FRAY_PRODUCTION_SUPERVISOR: "1" }, target, owner.token);
   const webDist = join7(import.meta.dirname, "..", "web-dist");
   const runtimeDir = join7(import.meta.dirname, "..", "runtime");
-  const scriptsDir = join7(runtimeDir, "cc", "scripts", "fray");
+  const scriptsDir = join7(runtimeDir, "board");
   const workerPluginDir = join7(runtimeDir, "cc-worker");
   const childEntry = fileURLToPath2(new URL("./dev-child.js", import.meta.url));
   let plannedUpdate;

package/package.json

@@ -1,23 +1,23 @@
 {
   "name": "frayui",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
-  "description": "Local orchestration surface for Fray projects — a per-repo web UI over your .fray/ agent threads",
+  "description": "A local dashboard for running many coding agents at once",
   "keywords": [
     "fray",
-    "claude",
-    "claude-code",
     "agents",
+    "claude-code",
+    "codex",
     "orchestration",
-    "tui"
+    "dashboard",
+    "ai"
   ],
   "license": "MIT",
   "author": "Colin McDonnell",
   "homepage": "https://github.com/colinhacks/fray",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/colinhacks/fray.git",
-    "directory": "packages/cli"
+    "url": "git+https://github.com/colinhacks/fray.git"
   },
   "engines": {
     "node": ">=26"
@@ -32,6 +32,13 @@
     "runtime"
   ],
   "scripts": {
+    "dev": "nub packages/server/src/dev.ts",
+    "fray-dev:install": "nub scripts/install-global-cli.mjs",
+    "fray-dev:check": "nub scripts/install-global-cli.mjs --check",
+    "fray-dev:uninstall": "nub scripts/install-global-cli.mjs --uninstall",
+    "install:global": "nub scripts/install-global-cli.mjs",
+    "typecheck": "tsc -b packages/shared packages/rpc packages/server . && pnpm --filter @fray-ui/web typecheck",
+    "test": "nub --test --test-force-exit 'board/*.test.mjs' 'scripts/**/*.test.mjs' 'src/**/*.test.ts' 'packages/shared/src/**/*.test.ts' 'packages/server/src/**/*.test.ts' 'packages/web/src/**/*.test.ts'",
     "prepack": "node ./scripts/prepare-package.mjs && node ./scripts/build-package.mjs && node ./scripts/publish-manifest.mjs --strip",
     "postpack": "node ./scripts/publish-manifest.mjs --restore"
   },
@@ -41,6 +48,18 @@
     "node-pty": "^1.1"
   },
   "devDependencies": {
-    "esbuild": "^0.25.0"
+    "@types/node": "^24",
+    "esbuild": "^0.25.0",
+    "puppeteer": "^25.3.0",
+    "typescript": "^5.7"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3",
+      "node-pty",
+      "@parcel/watcher",
+      "esbuild",
+      "@fray-ui/server"
+    ]
   }
 }

package/runtime/cc-worker/DECISIONS.md

@@ -10,16 +10,16 @@ what was ported from the orchestrator `cc/` plugin, what was dropped, and why.
 ## Shared source, bundled runtime closure
 
 - **`scripts/fray/config.mjs` and `scripts/fray/agent-bindings.mjs` are THIN SHIMS** that
-  `export *` from `../../../cc/scripts/fray/*.mjs`. cc-worker never copies config/vocab/binding
+  `export *` from `../../../board/*.mjs`. cc-worker never copies config/vocab/binding
   logic — there is exactly one source of truth (cc's). This assumes cc is a sibling dir (`../../cc/`
   from the plugin root), the same assumption fray-ui's server makes (`ARCHITECTURE.md`: it imports
-  the board logic from `../../cc/scripts/fray/*.mjs`).
+  the board logic from `../../board/*.mjs`).
 - **`bin/fray` and `bin/fray-update`** are cc's exact shim pattern, resolving cc's real scripts at
-  `../../cc/scripts/fray/{index,thread-update}.mjs` relative to the bin file (cwd-independent). They
+  `../../board/{index,thread-update}.mjs` relative to the bin file (cwd-independent). They
   land on the worker's Bash PATH the way cc's do. `fray-update` is the worker's primary tool for
   owning its one thread file; `fray` lets it read/validate the board.
-- **Portable artifact rule:** `packages/cli/src/artifacts.ts` copies the exact sibling
-  `cc/scripts/fray/` module closure to `runtime/cc/scripts/fray/`, beside `runtime/cc-worker/`.
+- **Portable artifact rule:** `src/artifacts.ts` copies the exact sibling
+  `board/` module closure to `runtime/board/`, beside `runtime/cc-worker/`.
   The existing shims therefore resolve inside an immutable artifact when the source checkout is gone;
   both the worker and cc closure are hashed in `manifest.runtimeFiles` and required at read time.
 - **`agents/*.md`** are copied UNCHANGED from `cc/agents/` (16 profiles) — a worker dispatches its
@@ -77,7 +77,7 @@ what was ported from the orchestrator `cc/` plugin, what was dropped, and why.
 worker session starts in the same repo, do both plugins' hooks fire (double-hook)?
 
 **Finding — NO, not by default. cc is inert in a fresh worker session.** cc's every hook is gated on
-`frayActive(projectDir, sessionId)` (`cc/scripts/fray/config.mjs`). That gate is **opt-IN per
+`frayActive(projectDir, sessionId)` (`board/config.mjs`). That gate is **opt-IN per
 session**: it requires `.fray/` to exist AND a per-session sentinel at
 `.fray/.session-state/<session_id>` containing `on` (written by `fray on` / the orchestrator fray
 skill's Step 0). With no sentinel it returns **false** — the documented default:
@@ -144,7 +144,7 @@ fray-ui workers. What landed:
   derived from that skill's `:92-150`/`:242-317`/`:463` framing). Also added a status-field
   discipline section (later split into `activity` + `status_text` — see the follow-up) and an
   "awaiting your OWN sub-agent is NOT blocked" clarification.
-- **`ui/WORKER_PROMPT.md`** (fray-ui system prompt, not in this plugin) — carries the terse version
+- **`packages/server/src/workerPrompt.ts`** (fray-ui system prompt, not in this plugin) — carries the terse version
   of the same three: a "Status discipline" block, the model/effort doctrine in the Sub-agents
   section, and a "Thread types" section. This is the maintainer's explicit ask that the preset
   vocabulary ride in the SYSTEM prompt passed to every worker. No dispatch.ts change, so no fray-ui
@@ -168,9 +168,9 @@ Three maintainer refinements landed on top of the port:
 `activity` = the form-constrained LIVE label the UI renders beside the spinner (single line, ≤100
 chars, present-progressive gerund); `status_text` = the classic 1–2-sentence human gloss that also
 doubles as THE ask on a human-`blocked` thread (queue cards headline it; no gerund constraint). The
-gerund/≤100 discipline moved OFF `status_text` and ONTO `activity` in `ui/WORKER_PROMPT.md` +
+gerund/≤100 discipline moved OFF `status_text` and ONTO `activity` in `packages/server/src/workerPrompt.ts` +
 `skills/worker/SKILL.md`. (UI-side `activity` plumbing/rendering — board JSON → ThreadView → listing
-row — is a SIBLING agent's scope; not touched here beyond `ui/WORKER_PROMPT.md`.)
+row — is a SIBLING agent's scope; not touched here beyond `packages/server/src/workerPrompt.ts`.)
 
 **2. New PostToolUse validation hook — `hooks/thread-frontmatter-validate.mjs`** (matcher
 `Edit|Write|MultiEdit`, wired in `hooks/hooks.json`). Gated on FRAY_UI_THREAD + a top-level
@@ -193,7 +193,7 @@ files + their frontmatter from `fray-<model>-<effort>` to `<model>-<effort>` (ba
 dispatches read `fray:opus-high` etc. Renamed the worker skill dir + frontmatter `fray-worker` →
 `worker` (giving `fray:worker`, not the stutter `fray:fray-worker`). The plugin DIRECTORY stays
 `cc-worker/` (dispatch.ts points at that path — unchanged, no server restart). Every reference in
-`ui/WORKER_PROMPT.md`, both skills, the hooks, and this file was updated; a grep for the old prefix token is clean.
+`packages/server/src/workerPrompt.ts`, both skills, the hooks, and this file was updated; a grep for the old prefix token is clean.
 
 **Accepted name collision.** The old GLOBAL orchestrator plugin (`cc/`) is ALSO named `fray`. This is
 accepted as harmless: `cc/` is disabled in `~/.claude/settings.json` (`"fray@fray": false`) and, even
@@ -216,7 +216,7 @@ shell-out, so they take effect on the next board rebuild with NO server restart.
   machine field, which reads as needs-human via the inlined `effectiveStatus`) REQUIRES a
   `status_text` (hard BLOCK); a machine-`blocked` thread with no mechanism field is a WARN suggesting
   needs-human (not a block — legacy tolerance); >1 mechanism stays a block.
-- **`skills/worker/SKILL.md` + `ui/WORKER_PROMPT.md` + `hooks/session-seed.mjs`** — the worker status
+- **`skills/worker/SKILL.md` + `packages/server/src/workerPrompt.ts` + `hooks/session-seed.mjs`** — the worker status
   guidance rewritten to the new contract: an ask OR a result needing review → `status: needs-human`
   with a `status_text` ask ("Review: …"); `blocked` is machine-only; `done` means NOTHING is left for
   the human (Mark-as-done is the human's acknowledgment — never jump straight to `done` when review
@@ -331,7 +331,7 @@ TWO-SIDED DEFENSE:
   repair.
 
 MECHANISM:
-- `cc/scripts/fray/index.mjs` `--json` gains a parallel `errorItems: [{file, kind, message}]`
+- `board/index.mjs` `--json` gains a parallel `errorItems: [{file, kind, message}]`
   (`kind: 'no-frontmatter'` = repairable, else `'other'`). The parser classifies — it knows exactly
   why it rejected the file. The legacy `errors: string[]` array is emitted UNCHANGED alongside it.
 - `errorItems` flows through `readBoard`/`fray.ts` → `board.ts assemble()` → `BoardSnapshot` +
@@ -360,7 +360,7 @@ GONE: no thread files, no frontmatter, no `status`/`activity`/`status_text`, no
 `blocked` machine fields, no `hasPlan`/`## Plan`, no `fray-update`. Workers now SIGNAL through their
 FINAL MESSAGE and PERSIST through a SCRATCHPAD. This is the cc-worker-side realignment.
 
-**The new signal model (taught in `ui/WORKER_PROMPT.md` §"End-of-turn signals" + `skills/worker/SKILL.md`):**
+**The new signal model (taught in `packages/server/src/workerPrompt.ts` §"End-of-turn signals" + `skills/worker/SKILL.md`):**
 - **Bare rest is quiet** — a rested thread with no fence does NOT enter Needs-you and is not a human
   handoff. Human handoff is explicit via `question` (or a real process-level block).
 - **` ```done `** — work complete + stands; body = 1–4 lines of what shipped + where. Renders a
@@ -483,7 +483,7 @@ discoverable.
 ## 2026-07-12: runtime release gate — real CDP evidence plus independent review
 
 Major UI, server, and control-plane work may no longer reach `done` from unit/integration/mocked
-evidence alone. The canonical `ui/WORKER_PROMPT.md` contract now requires real Chrome CDP QA against
+evidence alone. The canonical `packages/server/src/workerPrompt.ts` contract now requires real Chrome CDP QA against
 a disposable full stack, relevant active/idle/error/restart coverage, desktop+narrow screenshots,
 console/network inspection, and an explicit correctness+aesthetics assessment. Chrome DevTools MCP is
 preferred when it is available to the current provider; `agent-browser` or the repository Puppeteer

package/runtime/cc-worker/bin/fray

@@ -3,15 +3,15 @@
 /**
  * fray — the board command, on the worker's Bash PATH while the fray-worker plugin is enabled.
  * A worker owns ONE thread but can still run `fray` (validate/read the board for its repo). This
- * shim execs cc's bundled board script directly (NOT a copy) — cc-worker never forks board logic.
+ * shim execs the repo board's bundled script directly (NOT a copy) — cc-worker never forks board logic.
  *
- * Resolving the board: this file is <plugin>/bin/fray, cc is a sibling of the plugin root, so the
- * board is at ../../cc/scripts/fray/index.mjs relative to THIS file — cwd-independent. Imported
+ * Resolving the board: this file is <plugin>/bin/fray, board/ is a sibling of the plugin root, so the
+ * board is at ../../board/index.mjs relative to THIS file — cwd-independent. Imported
  * via a file:// URL so argv/process.env (incl. CLAUDE_PROJECT_DIR) flow straight through.
  */
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join } from 'node:path';
 
 const here = dirname(fileURLToPath(import.meta.url));
-const board = join(here, '..', '..', 'cc', 'scripts', 'fray', 'index.mjs');
+const board = join(here, '..', '..', 'board', 'index.mjs');
 await import(pathToFileURL(board).href);

package/runtime/cc-worker/bin/fray-update

@@ -4,15 +4,15 @@
  * fray-update — the structured thread updater, on the worker's Bash PATH while the fray-worker
  * plugin is enabled. This is the worker's PRIMARY tool for owning its one thread file: it writes
  * `.fray/<slug>.md` through the same code path fray-ui uses (never hand-rolled markdown edits).
- * Execs cc's bundled updater directly (NOT a copy) — cc-worker never forks updater logic.
+ * Execs the repo board's bundled updater directly (NOT a copy) — cc-worker never forks updater logic.
  *
- * Resolving the script: this file is <plugin>/bin/fray-update, cc is a sibling of the plugin root,
- * so the updater is at ../../cc/scripts/fray/thread-update.mjs relative to THIS file. Imported via
+ * Resolving the script: this file is <plugin>/bin/fray-update, board/ is a sibling of the plugin root,
+ * so the updater is at ../../board/thread-update.mjs relative to THIS file. Imported via
  * a file:// URL so argv/process.env flow straight through.
  */
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join } from 'node:path';
 
 const here = dirname(fileURLToPath(import.meta.url));
-const updater = join(here, '..', '..', 'cc', 'scripts', 'fray', 'thread-update.mjs');
+const updater = join(here, '..', '..', 'board', 'thread-update.mjs');
 await import(pathToFileURL(updater).href);

package/runtime/cc-worker/hooks/session-seed.mjs

@@ -21,7 +21,7 @@
 // worker plugin, and cc's hooks/skills/agents are gone. But a machine can still carry a CACHED cc
 // install from before the retirement, whose hooks fire in every repo gated on cc's opt-IN sentinel.
 // A fresh worker never runs `fray on`, so such a cc is already dormant; we write cc's own per-session
-// `off` sentinel anyway via the shared config API (cc/scripts/fray survives as cc-worker's board
+// `off` sentinel anyway via the shared config API (board survives as cc-worker's board
 // implementation) so a stale install is guaranteed inert. Cheap belt-and-suspenders. See DECISIONS.md.
 import { readFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';