@standardagents/code 0.13.7 → 0.13.9

package/README.md

@@ -67,8 +67,13 @@ we're letting new folks in every week.
   Work continues on that machine after you close the terminal, and a machine without a daemon
   still runs the full CLI as a watcher of sessions executing elsewhere.
 - **Permission-aware by design.** A single auto-accept level (1–5) controls what runs unattended;
-  anything riskier prompts you first. A catastrophic-command guard blocks dangerous shell calls
-  at *every* level, so you can't accidentally `rm -rf` your way into a bad day.
+  higher-risk calls prompt you first. Operations explicitly marked as requiring permission prompt
+  regardless of their numeric risk unless you previously granted that exact tool. Accepting a risk
+  tier raises the shared thread level so every client displays and enforces the same policy. A
+  catastrophic-command guard blocks dangerous shell calls at *every* level.
+- **Real project containment.** File destinations and background-process working directories are
+  checked through filesystem symlinks; any path that resolves outside the project always requires
+  a fresh human approval.
 - **Durable, resumable sessions.** Long-running and permission-gated calls *park* and resume over
   HTTP — a slow approval or a dropped socket can't kill your turn. Resume the same session from
   any machine.
@@ -110,6 +115,169 @@ pnpm code <dir>     # run against a project directory (defaults to cwd)
 pnpm code --endpoint http://localhost:5178 <dir>
 ```
 
+The parallel Rust TUI preview signs in, loads the shared machine → project →
+session projection, and attaches through the same version-matched network
+core. It owns the terminal's alternate screen and does not open native HTTP or
+WebSocket connections. Terminals at least 100 columns wide keep the session
+tree available as a full-height left column; Tab or its clickable divider
+collapses it to a one-column rail with a vertically stacked `Tab` hint. A
+one-column gutter separates that rail from the conversation while the
+transcript, composer, and chat controls expand into the reclaimed space.
+Narrower terminals show the session tree full-screen when focused and omit the
+sidebar collapse control. An authenticated launch with no attached session uses
+that same shell. A normal launch registers or refreshes the current directory
+as a project and highlights its row without creating a thread. `--browse`
+opens the account-wide picker without a project target. The sidebar remains
+available while the right column presents a session-selection empty state.
+Machine and project headings sit on the same left edge, sessions use one
+shallow indentation step, and a blank row separates machines. A one-cell `⣿`
+texture marks machine headings and continues through their divider. Machine
+rows have no disclosure glyph; a collapsed machine instead shows its known
+thread count, such as `(13)`; offline machines show that retained count too.
+Collapsed projects likewise append their known thread count.
+Each machine's green/red presence dot precedes its name. The leading texture
+cell takes the branch accent only while that machine is active, hovered, or
+keyboard-highlighted; inactive machine texture remains structural gray.
+Machines receive stable colors from DMUX's eight-accent palette, so color
+belongs to a branch rather than to global selection. Machine color is limited
+to its texture/divider while the active machine name stays white. Project
+headings and dividers remain structural gray at every state. Unrelated
+hierarchy recedes to dark gray.
+The attached project and thread use typography without persistent row fills;
+the thread title inherits its machine accent. Hover or keyboard navigation uses
+the same brighter row background for machines, projects, and threads;
+navigated threads also add a `›` marker. Every thread has a status cell: hollow gray is idle, solid
+blue is unread, and a green animated texture is working. Unread state uses the
+shared core's account-scoped, message-recency watermark; opening a thread
+advances that shared state, and background activity timestamps never create a
+false unread dot.
+Click a heading or select its name and press Enter to collapse it. Right moves
+keyboard focus to the heading's complete `[+]` button; Enter activates it,
+Left returns to the name, and Right again returns to an attached conversation.
+The button is hidden until its row is hovered or keyboard-highlighted; while
+hidden, the heading divider fills those final three cells instead of reserving
+an empty control gap.
+The project `[+]` opens a prospective session composer. The machine `[+]`
+opens its structure-only directory picker and registers the chosen project
+before opening that composer. The canonical thread is created when its first
+message is submitted, so closing an untouched composer leaves no empty thread.
+The composer takes keyboard focus and explains that the first message creates
+the session.
+An offline machine has no disclosure/collapse action and hides its retained
+project/session branch. Its machine row keeps the last known thread count and
+can still receive keyboard or mouse highlight, but its foreground remains gray
+and activation does nothing. Creation controls are absent while that machine is
+offline, and presence is checked again before a core request is sent.
+Those actions use the shared core's `project.open`, `session.start`, and
+`machines.fsBrowse` operations. The Rust face receives filesystem data and
+canonical session metadata from the core.
+Press Tab to reveal and focus sessions, use ↑/↓ or j/k and Enter to activate,
+and press Esc or Tab to return to the composer. Clicking anywhere in the
+expanded sidebar also transfers keyboard focus there, beginning on the clicked
+row when there is one. Left from an empty composer
+also reveals and focuses the sidebar; Left retains normal cursor movement when
+the composer contains text. Activating a prospective or existing chat returns
+keyboard focus to the conversation. Switching saves the current shared draft
+before detaching, and never stops the session's remote work. While the selected
+conversation loads, the full-height session tree stays mounted and only the
+right chat column enters its loading state. Session rows also switch on one
+click. Passive mouse motion gives clickable session rows a high-contrast
+surface, highlights the sidebar toggle rail, Markdown
+links, and the jump-to-latest pill, and asks supporting terminals such as
+Ghostty for a pointer cursor. Redraws are coalesced until the semantic hover
+target really changes. The transcript owns pane-local click-drag selection, so it copies
+semantic Markdown text without Shift and never sweeps through the sidebar.
+White is reserved for user text and high-value accents. Assistant prose and
+tool, system, reasoning, and structural rows use sampled cool-gray tiers;
+semantic states and Markdown keep muted accent colors. Live thought and answer blocks grow from a stable prefix,
+so streamed chunks extend visible text without deleting and reflowing its
+beginning. Running subagents retain a bounded list of their reads, searches,
+edits, and other tool actions beneath the current activity phrase.
+Settled reads and searches roll up under `Explored` while preserving every
+action. Successful commands use one compact highlighted row. Failures retain
+their complete output as a quiet gray block beneath the highlighted command,
+and prose-like tool results share the transcript's word wrapper. Known
+arguments and results receive muted semantic syntax colors. Consecutive edits
+roll up under `Edited N files`; their complete red and green hunks fill the
+available conversation width.
+Thinking appears in an expandable block with an animated Braille texture while
+the trace is active. Active traces start collapsed, and completed traces retain
+a one-line disclosure. Click any thinking row to toggle its trace, or press Ctrl+T
+to toggle the newest trace.
+Releasing the button clears the highlight and shows `Copied text` in the status
+row. Clicking anywhere in the active conversation column returns keyboard
+focus to its composer without disrupting drag selection. Prose wraps at word
+boundaries; long unbroken tokens and code still
+hard-wrap to the pane. The complete loaded transcript remains scrollable with
+the mouse wheel or Page Up/Page Down. Ctrl+Home jumps to the beginning and
+Ctrl+End resumes bottom-follow; output that arrives while scrolled up leaves
+the viewport anchored and shows a one-click “Jump to latest” pill at the bottom
+of the conversation. The pill calls out new output when it arrives. Wheel bursts
+accumulate between frames, preserving responsive trackpad motion instead of dropping input.
+While a turn runs, an animated amber/coral/violet Braille status row stays
+directly above the composer, after the optional `Session todos` card.
+The composer and submitted user messages share one quiet filled rectangular
+surface with a chevron gutter. One empty surface row sits above the editable
+rows and one below, so the empty composer is three terminal rows; it grows
+from one to eight content rows, wraps prose on word boundaries,
+preserves hard newlines from Shift+Enter and multiline paste, and then scrolls
+internally without displacing more of the transcript. Short conversations use
+natural document flow: the composer and telemetry follow the final transcript
+row, leaving unused space below. Once the transcript consumes the available
+viewport, the composer stays pinned at the bottom and the transcript scrolls
+above it. The mouse
+wheel follows the pane under the pointer, so a capped composer scrolls without
+moving the conversation; the next edit resumes caret-follow. Pastes over 1,000
+characters render as an atomic cyan `[Pasted Content N chars]` element while
+their exact text remains in the shared draft and submitted message. Backspace
+or Delete at that element removes the complete paste. Enter sends or queues,
+while Ctrl+Enter steers. Up/Down moves through visual editor
+rows before recalling the core-backed per-thread sent history at the top or
+bottom edge.
+Structured session todos appear in a collapsible card above the composer. One
+blank row separates the neutral teal-gray card from the transcript. Todo
+descriptions and steps wrap to show their complete content. Escape promotes the
+oldest queued message through the shared core. During active work with an empty
+queue, Escape stops execution and releases the composer for a new message.
+An offline runner does not make its cloud conversation disappear: the session
+still opens for review, but the composer pauses instead of letting new work
+silently wait for a missing executor. There is no separate offline banner; the
+composer becomes a hollow, unfilled surface carrying the state inline. If work
+is already waiting, it says `Waiting for <machine> — Esc stops`. Pushed machine-presence events unlock
+the composer and restore the retained sidebar branch as soon as the daemon
+reconnects; there is no presence poll or session relist.
+The line beneath the composer is session telemetry rather than a persistent
+keyboard cheat sheet: it shows the attached thread's agent, runner machine,
+current working directory, running background-process count, and
+compaction-scaled context usage. The muted path gets priority over the literal
+`context` label. Full agent names stay visible at comfortable widths; only a
+narrow footer abbreviates them (`Unlimited One` → `U1`, `Sama One` → `S1`)
+before squeezing the deepest complete path breadcrumbs further.
+The row ends with the old terminal face's five colored permission dots, so the
+current effective auto-accept ceiling remains visible without adding another
+row. Accepted risk grants raise the dots immediately and reconcile from the
+persisted approval state. Approval requests show the tool summary, stated
+reason, execution machine, five-dot risk level, and fully labeled decisions in
+a bordered card. These
+values come from the shared roster, session tree,
+approvals, process registry, and context projections in the network core.
+Headings, emphasis, links, lists, tables, quotes, and fenced code use
+the same progressive parser contract as the TypeScript UI. PNG attachments use
+Kitty Unicode placeholders in verified Kitty/Ghostty/WezTerm environments,
+including configured tmux; other terminals keep the same layout and show a
+text fallback:
+
+```bash
+pnpm tui:rust
+# Open the account-wide project picker:
+pnpm tui:rust -- --browse
+# Optional direct-attach fast path:
+pnpm tui:rust -- --thread <thread-id>
+```
+
+This preview is additive; the TypeScript CLI remains the normal entry point
+while the Rust face is brought to feature parity.
+
 Installed from npm:
 
 ```bash
@@ -149,9 +317,29 @@ The first time you choose this machine, the CLI offers to install its daemon in
 here. Declining leaves local execution unavailable; remote machines and watching stay available,
 and the command sets it up any time.
 
+Manage the local daemon from any shell:
+
+```bash
+standardcode daemon status
+standardcode daemon restart
+standardcode daemon update
+standardcode daemon add-project /absolute/path/to/project
+standardcode daemon uninstall
+```
+
+`restart` immediately reloads the installed launchd or systemd service. `update` lets active tool
+calls finish, installs the latest Standard Code package, and restarts the daemon.
+
 Use `--endpoint [url]` or `-e [url]` to point a single CLI run at a different Standard Agents
 instance (local dev, self-hosted). If you omit the URL, the CLI prompts for it. Tokens are
 remembered per endpoint, but this override does not change the saved default endpoint.
+Endpoints without a scheme default to `https://`; using plaintext local development requires an
+explicit URL such as `http://localhost:5178`.
+
+For HTTPS on a loopback, private, `.local`, or `.localhost` endpoint, the CLI can relax certificate
+verification for its own instance connections. That process-local setting is stripped from every
+browser, shell, background process, package-manager, git, clipboard, and ripgrep child so local
+development never disables TLS verification in unrelated commands.
 
 ### Requirements
 
@@ -166,8 +354,10 @@ remembered per endpoint, but this override does not change the saved default end
 
 - **Forwarded tools** executed by the session's machine daemon: read/write/edit files, list,
   grep, glob, bash, delete.
-- **Permissions**: a single auto-accept level 1–5 (shift-tab cycles it); risky calls prompt;
-  a catastrophic-command guard blocks dangerous shell commands at every level.
+- **Permissions**: a shared auto-accept level 1–5 (shift-tab cycles it); accepting a risk tier
+  raises the stored thread level across clients; server-marked permission requests cannot be
+  downgraded by a model-supplied risk. A catastrophic-command guard blocks dangerous shell commands
+  at every level.
 - **Durable, resumable** long-running/permission-gated tool calls (park & resume over HTTP).
 - **Background processes** tracked in the thread (survive resume from any machine).
 - **Subagent delegation** and non-blocking web research.
@@ -181,7 +371,8 @@ remembered per endpoint, but this override does not change the saved default end
 ## Tests
 
 ```bash
-pnpm test           # version lockstep + typecheck + every declared no-backend test
+pnpm test           # TypeScript checks/tests plus Rust unit and PTY tests
+pnpm check:rust     # rustfmt and clippy with warnings denied
 ```
 
 `scripts/run-tests.mjs` owns the explicit no-backend test manifest, prints each
@@ -203,10 +394,16 @@ test layout, and contributor conventions.
 - Two version-locked packages: `@standardagents/code` and its shared
   `@standardagents/code-network` client. Both use Node built-ins and
   web-platform APIs without third-party runtime packages.
-- `src/progressive-markdown.ts` is the canonical structured streaming parser shared with the web
-  and native heads. Run `pnpm markdown:sync` after changing it and `pnpm markdown:check` in CI.
-- The hosted instance's generated `src/session-state.ts` owns live-draft accumulation as well as
-  busy/tool/message reconciliation; a changed chunk ID is an alias, never permission to erase text.
+- `src/progressive-markdown.ts` is the canonical structured streaming parser used by every face.
+  The Node face-core sends its versioned documents to Rust, which handles
+  terminal layout and paint. Web receives an exact source copy, and macOS runs
+  the generated JavaScriptCore bundle. Shared vectors cover parser output and
+  Rust transport-schema compatibility.
+  Run `pnpm markdown:sync` after changing the authored TypeScript parser and
+  `pnpm markdown:check` in CI.
+- The hosted instance authors the session-state reducer published through
+  `@standardagents/code-network`. It owns live-draft accumulation and busy/tool/message
+  reconciliation; a changed chunk ID is an alias, never permission to erase text.
 - Commit messages use Conventional Commits, scope `cli` (e.g. `feat(cli): …`).
 
 ---