@standardagents/code 0.13.8 → 0.13.10

package/README.md

@@ -67,10 +67,10 @@ 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, and operations explicitly marked as requiring permission
-  prompt regardless of their numeric risk unless you previously granted that exact tool. 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.
@@ -115,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
@@ -154,6 +317,19 @@ 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.
@@ -178,9 +354,10 @@ development never disables TLS verification in unrelated commands.
 
 - **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;
-  server-marked permission requests cannot be downgraded by a model-supplied risk; 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.
@@ -194,7 +371,8 @@ development never disables TLS verification in unrelated commands.
 ## 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
@@ -216,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): …`).
 
 ---

package/dist/index.js

@@ -14,6 +14,7 @@ import * as approvals_star from '@standardagents/code-network/approvals';
 import net from 'net';
 import { setImmediate } from 'timers';
 import fs12 from 'fs';
+import { isTranscriptMetaTool } from '@standardagents/code-network/tool-activity';
 import { permissionKey, Bridge as Bridge$1 } from '@standardagents/code-network/bridge';
 import readline from 'readline';
 import * as types_star from '@standardagents/code-network/types';
@@ -687,7 +688,10 @@ var Bridge = class extends Bridge$1 {
         isCatastrophic: (command) => isCatastrophic(command),
         decide: (permKey, risk, requestPermission) => decide(perm, permKey, risk, requestPermission),
         grantAlways: (permKey) => void perm.alwaysAllow.add(permKey),
-        grantRisk: (risk) => void perm.allowRisk.add(risk),
+        grantRisk: (risk) => {
+          perm.level = Math.max(perm.level, risk);
+          perm.allowRisk.clear();
+        },
         persistApprovals: () => void (0, approvals_exports.saveApprovals)(api, threadId, perm)
       },
       {
@@ -798,7 +802,6 @@ function prettyAgentName(id) {
   if (!key) return "subagent";
   return AGENT_NAMES[key] || key.replace(/[_-]+/g, " ").replace(/\b\w/g, (ch) => ch.toUpperCase());
 }
-var META_TOOLS = /* @__PURE__ */ new Set(["set_goal", "update_goal_step", "reasoning"]);
 var APPROVAL_PENDING_MARKER = "Awaiting your approval";
 var ToolActivityFeed = class {
   calls = /* @__PURE__ */ new Map();
@@ -833,7 +836,7 @@ var ToolActivityFeed = class {
     const text = (0, session_state_exports.messageText)(message.content);
     if (text.includes(session_state_exports.WAITING_FOR_CLIENT_MARKER) || text.includes(APPROVAL_PENDING_MARKER)) return null;
     this.settled.add(callId);
-    if (META_TOOLS.has(req.tool)) return null;
+    if (isTranscriptMetaTool(req.tool)) return null;
     const summary = describe(req);
     if (toolResultFailed(message, text)) {
       return { line: `\u2717 ${summary} \u2014 ${text.trim() || "failed"}` };
@@ -4014,7 +4017,7 @@ function readVersion() {
     if (typeof pkg.version === "string" && pkg.version) return pkg.version;
   } catch {
   }
-  return "0.13.8" ;
+  return "0.13.10" ;
 }
 function isLocalHost(host) {
   return host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".local") || host.endsWith(".localhost") || /^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host);
@@ -6464,7 +6467,10 @@ var ThreadWorker = class {
               return { choice: "deny", reason: "The approval request timed out with no one to approve it." };
             }
             if (response.choice === "always") this.perm.alwaysAllow.add(permKey);
-            if (response.choice === "always_risk") this.perm.allowRisk.add(effectiveRisk);
+            if (response.choice === "always_risk") {
+              this.perm.level = Math.max(this.perm.level, effectiveRisk);
+              this.perm.allowRisk.clear();
+            }
             if (response.choice === "always" || response.choice === "always_risk") {
               (0, approvals_exports.saveApprovals)(api, threadId, this.perm);
             }
@@ -6976,6 +6982,15 @@ function run2(cmd, args) {
 var plistPath = () => path9.join(os6.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
 var unitPath = () => path9.join(os6.homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
 var xmlEscape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function restartServiceInvocation(platform, uid = 501) {
+  if (platform === "darwin") {
+    return { cmd: "launchctl", args: ["kickstart", "-k", `gui/${uid}/${SERVICE_LABEL}`] };
+  }
+  if (platform === "linux") {
+    return { cmd: "systemctl", args: ["--user", "restart", SYSTEMD_UNIT] };
+  }
+  return null;
+}
 function installService(command, endpoint) {
   if (process.platform === "darwin") return installLaunchd(command, endpoint);
   if (process.platform === "linux") return installSystemd(command, endpoint);
@@ -7086,6 +7101,39 @@ function uninstallService() {
   }
   return { ok: false, detail: `Unsupported platform: ${process.platform}` };
 }
+function restartService() {
+  if (process.platform === "darwin") {
+    if (!fs12.existsSync(plistPath())) {
+      return {
+        ok: false,
+        detail: "The daemon service is not installed. Run `standardcode daemon install` first."
+      };
+    }
+    const uid = typeof process.getuid === "function" ? process.getuid() : 501;
+    const invocation = restartServiceInvocation(process.platform, uid);
+    const restart = run2(invocation.cmd, invocation.args);
+    if (restart.ok) return { ok: true, detail: "LaunchAgent restarted" };
+    const boot = run2("launchctl", ["bootstrap", `gui/${uid}`, plistPath()]);
+    if (boot.ok) return { ok: true, detail: "LaunchAgent loaded and started" };
+    return {
+      ok: false,
+      detail: `launchctl failed: ${restart.output || boot.output}`,
+      manualHint: `Load it manually: launchctl bootstrap gui/${uid} ${plistPath()}`
+    };
+  }
+  if (process.platform === "linux") {
+    if (!fs12.existsSync(unitPath())) {
+      return {
+        ok: false,
+        detail: "The daemon service is not installed. Run `standardcode daemon install` first."
+      };
+    }
+    const invocation = restartServiceInvocation(process.platform);
+    const restart = run2(invocation.cmd, invocation.args);
+    return restart.ok ? { ok: true, detail: "systemd user service restarted" } : { ok: false, detail: `systemctl restart failed: ${restart.output}` };
+  }
+  return { ok: false, detail: `Unsupported platform: ${process.platform}` };
+}
 function serviceStatus() {
   if (process.platform === "darwin") {
     const installed = fs12.existsSync(plistPath());
@@ -7133,6 +7181,8 @@ function usage() {
       "                             e.g. when another app drives the install).",
       "  uninstall                  Stop and remove the service.",
       "  status                     Service + registry status for this machine.",
+      "  restart                    Restart the installed service immediately.",
+      "  update [--endpoint url]    Install the latest CLI, then restart the service.",
       "  run [--endpoint url]       Run the daemon in the foreground (what the service runs).",
       "  add-project <path>         Register a project directory for remote sessions.",
       "  remove-project <path>      Remove a registered project directory.",
@@ -7262,9 +7312,10 @@ async function installCommand(endpointFlag, opts = {}) {
     stdout.write(
       `${c3.green}\u2713${c3.reset} ${c3.bold}${displayName}${c3.reset} is online.
 
-Sessions started elsewhere can now run on this machine.
-${c3.dim}Projects register automatically when you run standardcode in a directory here,
-or add one now: standardcode daemon add-project <path>${c3.reset}
+Standard Code sessions can now edit files and run tools on this machine while you drive them from any device signed in to your account.
+${c3.dim}Projects are added automatically when you start Standard Code from their directory.
+To add a project manually, run:${c3.reset}
+  ${c3.bold}standardcode daemon add-project /absolute/path/to/project${c3.reset}
 `
     );
   } else {
@@ -7314,6 +7365,55 @@ async function statusCommand() {
   for (const p of projects.sort()) stdout.write(`  ${c3.dim}${p}${c3.reset}
 `);
 }
+async function updateDaemonCommand(endpointFlag) {
+  const status = serviceStatus();
+  if (!status.installed) {
+    stdout.write(
+      `${c3.red}\u2717${c3.reset} The daemon service is not installed. Run \`standardcode daemon install\` first.
+`
+    );
+    process.exit(1);
+  }
+  const endpoint = resolveEndpoint(endpointFlag);
+  const api = await ensureSignedIn(endpoint);
+  const identity = loadMachineIdentity();
+  const record = await loadMachine(api, identity.machine_id).catch(() => null);
+  if (status.running && record && daemonOnline(record)) {
+    await enqueueMachineCommand(api, identity.machine_id, "update");
+    stdout.write(
+      `${c3.green}\u2713${c3.reset} Update requested. The daemon will finish active tool calls, install the latest Standard Code, and restart.
+`
+    );
+    return;
+  }
+  const pm = detectPackageManager();
+  if (!pm) {
+    stdout.write(
+      `${c3.red}\u2717${c3.reset} This source checkout cannot update the installed CLI. Run \`standardcode daemon update\` through your global Standard Code command.
+`
+    );
+    process.exit(1);
+  }
+  const { display } = updateCommand(pm);
+  stdout.write(`${c3.dim}Running ${display}\u2026${c3.reset}
+`);
+  const result = await runUpdate(pm);
+  if (!result.ok) {
+    stdout.write(`${c3.red}\u2717${c3.reset} Update failed.
+`);
+    for (const line of result.output.trim().split("\n").slice(-6)) {
+      if (line) stdout.write(`${c3.dim}${line}${c3.reset}
+`);
+    }
+    process.exit(1);
+  }
+  const restarted = restartService();
+  stdout.write(
+    `${restarted.ok ? c3.green + "\u2713" : c3.red + "\u2717"}${c3.reset} ${restarted.ok ? "Standard Code updated. " : "Standard Code updated, but the daemon restart failed. "}${restarted.detail}
+`
+  );
+  if (!restarted.ok) process.exit(1);
+}
 async function projectCommand(action, target) {
   if (!target) {
     stdout.write(`${c3.red}\u2717${c3.reset} Expected a project path.
@@ -7369,6 +7469,18 @@ async function runDaemonCommand(argv) {
     case "status":
       await statusCommand();
       return;
+    case "restart": {
+      const result = restartService();
+      stdout.write(`${result.ok ? c3.green + "\u2713" : c3.red + "\u2717"}${c3.reset} ${result.detail}
+`);
+      if (result.manualHint) stdout.write(`${c3.dim}${result.manualHint}${c3.reset}
+`);
+      if (!result.ok) process.exit(1);
+      return;
+    }
+    case "update":
+      await updateDaemonCommand(endpoint);
+      return;
     case "add-project":
       await projectCommand("add", rest[0]);
       return;
@@ -8586,13 +8698,9 @@ async function runInteractive(tui, api, accountStream, threadId, projectDir, mac
   const pendingSent = /* @__PURE__ */ new Map();
   let lastSent = null;
   let upgradeInFlight = false;
-  let tokensIn = 0;
-  let tokensOut = 0;
   let liveOut = 0;
-  const countedLogs = /* @__PURE__ */ new Set();
   const activeSteps = /* @__PURE__ */ new Map();
   const refreshStatus = () => {
-    tui.setTokens(tokensIn, tokensOut + liveOut);
     let label = null;
     for (const v of activeSteps.values()) label = v;
     tui.setStep(label, liveOut);
@@ -9432,24 +9540,6 @@ ${c5.dim}runs on ${request.machine || runnerName}${c5.reset}`,
     refreshBgCount();
     void relayApprovals().catch(() => {
     });
-    try {
-      const logs = await api.getLogs(threadId, 100);
-      let landed = 0;
-      for (const l of logs) {
-        if (!l.is_complete) continue;
-        const id = l.id ?? `${l.created_at}:${l.total_tokens}`;
-        if (countedLogs.has(id)) continue;
-        countedLogs.add(id);
-        const inT = Number(l.input_tokens) || 0;
-        const outT = Number(l.output_tokens) || 0;
-        tokensIn += inT;
-        tokensOut += outT;
-        landed += outT;
-      }
-      if (landed > 0) liveOut = 0;
-      refreshStatus();
-    } catch {
-    }
     const COMPACTION_TRIGGER_FRACTION = 0.5;
     const COMPACTION_TRIGGER_CAP = 5e4;
     try {
@@ -9733,7 +9823,8 @@ function showDaemonInfo(tui, session) {
       `${c5.dim}The daemon is the executor on every machine: it runs the agent's tools, keeps working after you close the terminal, self-restarts, self-updates, and picks up sessions you start from anywhere.${c5.reset}`
     );
   } else {
-    tui.print(`${c5.dim}Manage it with standardcode daemon status | uninstall | add-project <path>.${c5.reset}`);
+    tui.print(`${c5.dim}Daemon commands: standardcode daemon status | restart | update | uninstall.${c5.reset}`);
+    tui.print(`${c5.dim}Add a project: standardcode daemon add-project /absolute/path/to/project${c5.reset}`);
   }
 }
 function showKeybindings(tui) {