local-commander-agent 0.3.13-launcher.1 → 0.3.14-cli.1

package/README.md

@@ -4,7 +4,7 @@
 
 > **Requires the Local Commander service at https://localcmd.app.** This npm package is its Windows companion, not a standalone MCP server, an offline AI assistant, or a JavaScript SDK. Installing the package alone is not enough: you need a Local Commander account, an approved device pairing, a running agent, an internet connection, and an authorized MCP connection from your AI client. Local management commands such as status and stop do not require the service to be online.
 
-[Website and sign-in](https://localcmd.app) · [Support](https://localcmd.app/support) · [Privacy](https://localcmd.app/privacy)
+[Website and sign-in](https://localcmd.app) ┬╖ [Support](https://localcmd.app/support) ┬╖ [Privacy](https://localcmd.app/privacy)
 
 ## Before you start
 
@@ -34,9 +34,9 @@ Use **Windows 11 x64** and a currently supported Node.js LTS version meeting the
 
 You can close the installation terminal. The agent runs in the background and starts when this Windows user signs in. The PC must be awake and online for remote AI tasks. As a first test, ask the connected assistant to list the files in a folder you approved.
 
-Installation and update also add `localcommander` to your Windows **user PATH** and create a Start menu entry named **Local Commander Monitor** that opens the live connections/tasks view in its own window. Open a new CMD/terminal window, then run `localcommander status`, `localcommander monitor --watch`, or `localcommander logs --follow` from any folder. No global npm installation is needed. The launcher uses your required Node.js installation and an installed copy of the CLI, so clearing npm's cache does not remove the command or the shortcut. Fetch newer releases with `npx local-commander-agent@latest update`. Uninstall removes Local Commander's PATH entry, launcher and shortcut while preserving your other entries; an unrelated shortcut with the same name is never replaced.
+Installation and update also add `localcommander` to your Windows **user PATH**. Open a new CMD/terminal window, then run `localcommander status`, `localcommander monitor --watch`, or `localcommander logs --follow` from any folder. No global npm installation is needed. The launcher uses your required Node.js installation and an installed copy of the CLI, so clearing npm's cache does not remove the command. Fetch newer releases with `npx local-commander-agent@latest update`. Uninstall removes Local Commander's PATH entry and launcher while preserving your other entries.
 
-## What “all connected drives” means
+## What тАЬall connected drivesтАЭ means
 
 It expands the **filesystem scope** to the drive letters shown at the moment you consent. It includes available local fixed and removable drives. Mapped network drives and `subst` letters are not included. New drive letters, unavailable drives and unmounted volumes are not automatically added; run `configure-access` again after making the desired drive available. Grants are path/drive-letter based, not tied to a particular removable disk's hardware identity: reusing an approved letter gives access under that letter.
 
@@ -90,6 +90,32 @@ npx local-commander-agent@latest deny-localhost <workspaceGrantId> 3000
 
 `allow-command` associates an exact executable with the name the assistant uses; it does not accept a shell command string. Capability changes are local owner actions, not MCP settings the assistant can silently widen. The all-drives decision always requires the local dialog; there is no `--yes` or environment flag to approve it.
 
+### Approve Git from CMD or PowerShell
+
+When giving an owner Windows commands, identify the shell before using shell-specific syntax and label the example. Prefer explicit workspace IDs and quoted absolute executable paths that work in both CMD and PowerShell; do not assume a standard installation path.
+
+Use the example for the shell you are running. A prompt such as `C:\project>` is normally **Command Prompt (CMD)**; `PS C:\project>` is normally **PowerShell**. Windows Terminal can host either shell.
+
+First run `npx local-commander-agent@latest workspaces` and copy the intended workspace's grant ID.
+
+**CMD:** run `where git.exe`. If it lists several paths, choose the Git executable you intend to approve. Replace `WORKSPACE_ID` and the example path below with those actual values; keep the path in double quotes.
+
+```cmd
+where git.exe
+npx local-commander-agent@latest allow-command WORKSPACE_ID git "C:\Path To Git\git.exe"
+```
+
+**PowerShell:** replace `WORKSPACE_ID` with the grant ID. This selects the first Git executable found on PATH and passes its path as one argument. Inspect the other matches with `Get-Command git.exe -CommandType Application` if you intend to approve a different installation. `npx.cmd` explicitly selects npm's batch launcher.
+
+```powershell
+$gitExe = @(Get-Command git.exe -CommandType Application -ErrorAction Stop)[0].Source
+npx.cmd local-commander-agent@latest allow-command WORKSPACE_ID git "$gitExe"
+```
+
+Do not paste `(Get-Command git).Source` into CMD: CMD passes it literally instead of resolving an executable. Local Commander accepts a path, never evaluates a shell expression, and still requires the local owner confirmation. If lookup finds no Git executable, stop and locate the installed program before approving it.
+
+`allow-command --help` shows these instructions without requiring an installed agent or opening a permission dialog. Malformed arguments keep the `ARGUMENT_INVALID` error and nonzero exit status, followed by usage and shell-specific guidance. Diagnostic output does not repeat the supplied arguments. These diagnostics require a release containing this fix; editing the documentation does not update an installed CLI.
+
 Under full access, `deny-command` and `deny-localhost` exclude the named command or port while other commands/ports remain available. Native `.exe`/`.com` commands receive argument arrays directly. `.cmd`/`.bat` launchers use a hidden PowerShell wrapper and reject cmd metacharacters in arguments; use an explicit interpreter for more complex scripts. Allowing a general interpreter is not containment against it launching a denied program.
 
 Full access does not include Windows shells, script hosts or administration binaries (`cmd`, `powershell`, `pwsh`, `wscript`, `cscript`, `mshta`, `rundll32`, `regsvr32`, `certutil`, `bitsadmin`, `msiexec`, `wmic`, `reg`, `schtasks`, `sc`, `net`, `netsh`, `icacls`, `takeown`, `runas`, `psexec`, `wsl`, `bash`, `sh`, `dism`, `winrm` and similar). An assistant request for one of these, by bare name or absolute path, fails with `COMMAND_NOT_ALLOWED` until you register that exact executable yourself with `allow-command <workspace-id> <name> <absolute .exe path>` and confirm the native dialog; it then runs only under the registered name or that exact path. Ordinary developer tools (`node`, `git`, `npm`, `python`, `dotnet`, ...) continue to resolve from your absolute `PATH` entries.
@@ -107,8 +133,8 @@ The MCP discovery sequence is `workspace_list`, `diagnostics`, `execution_sessio
 | `STATE_CHANGED` | Local account/policy/permissions changed while the dialog was open. Review current state and reopen the dialog. |
 | `WORKSPACE_INVALID` | Choose an existing ordinary folder, not a link or protected state directory. Use the all-drives choice for drive roots. |
 | `LOCAL_PERMISSION_REQUIRED` | Inspect `workspaces`; enable only the exact write/command/localhost capability needed. |
+| `ARGUMENT_INVALID` from `allow-command` | Supply the workspace ID, command name and one quoted absolute executable path. Use `where git.exe` in CMD or `Get-Command git.exe` in PowerShell; see the shell-specific examples above and `allow-command --help`. |
 | `PATH_NOT_ALLOWED` | The target is outside the grant, resolves elsewhere through a link, or is protected. Do not bypass the boundary with another tool. |
-| The Start menu entry is missing, or opens and closes immediately | Run `localcommander monitor --watch` in a new terminal. The entry runs a local PowerShell wrapper; an organization policy that blocks local scripts, or a same-name shortcut created by something else, prevents it. Rerun `npx local-commander-agent@latest update` to recreate it. |
 | Paired and running, but the AI cannot reach the PC | Check that the PC is awake/online and that the AI client's remote MCP connection is authorized to the same account. Check service status/support. |
 
 For help, use [Local Commander support](https://localcmd.app/support) or email [peter.mamrukov@localcmd.app](mailto:peter.mamrukov@localcmd.app). Share error codes and the installed version, not keys, tokens, pairing codes, private state files or unredacted logs.
@@ -140,7 +166,7 @@ From the development checkout, `npm run monitor` opens this live view using the
 
 The live view also reads registered runtime presence from the current project's `.local-commander/agents.json` and native workers from the configured agent state's `.local-commander/fabric/mailbox.json`. It observes live local `codex`, `claude` and `cursor-agent` processes through hidden bounded Windows process metadata reads. It shows registered agents and observed hosts even while they have no active Local Commander command. Host display IDs are stable eight-character hashes of computer/name/PID/start time; they are process observations, not server-issued AI identities. CPU activity describes measured local CPU use; waiting on a provider or thinking is not inferred.
 
-Reported task activity, confirmed worker model attribution and confirmed execution IDs are used when available. Linked commands appear beneath their agents; only measured savings from those exact linked executions contribute to an agent row. Unlinked host model/savings remain unavailable. A `+` on an agent savings figure marks partial retained execution coverage. The last finished command remains visible with its completion time, so short commands do not disappear between refreshes. `--json` includes all bounded agent/host rows, including those omitted for screen size. A missing/denied/corrupt presence source is isolated and reported as unavailable; the monitor never initializes or mutates those registries and never reads capabilities, credentials, command arguments or private chat histories.
+Reported task activity, confirmed worker model attribution and confirmed execution IDs are used when available. Linked commands appear beneath their agents; only measured savings from those exact linked executions contribute to an agent row. Unlinked host model/savings remain unavailable. A `+` on an agent savings figure marks partial retained execution coverage. The last finished command remains visible with its completion time, so short commands do not disappear between refreshes. `--json` includes all bounded agent/host rows, including those omitted for screen size. A missing/denied/corrupt presence source is isolated and reported as unavailable; the monitor never initializes or mutates those registries and never reads capabilities, credentials or private chat histories. Current commands use bounded redacted previews emitted by the tool runtime.
 
 The navy/cyan ASCII view groups requested/prepared/accepted/running processes beneath each computer. Each row shows its eight-character work ID (the execution ID prefix), actual child PID when available, command summary, declared model and estimated tokens saved. Connected idle computers show READY. The fixed footer reports Raw/Sent/Saved token estimates and savings percentage from measured output bytes for this run; partial totals are marked when some companions have older snapshots. Completed, rejected, unknown, stale and stopped executions stay out of this screen. Freshness follows authenticated transport activity when the relay advertises monitorHeartbeatV1; three missed negotiated heartbeat intervals mark it stale. Fresh local writes cannot renew transport proof. Older peers/snapshots retain the ten-second rule. Work IDs identify executions; sessions are not AI instance identities. Only computers with snapshots available locally can appear.
 
@@ -152,7 +178,7 @@ Savings use the existing output-compaction ledger: original/sent bytes are measu
 
 The runtime reuses its last 64 shaped terminal results for later completed output reads, so repeated reads match the counted compacted result. The encrypted journal retains the original output. After restart or result-cache eviction, reads fall back to that original output; no historical model attribution or extra savings is invented.
 
-Each instance retains its last 64 observed executions, 100 events, 32 sessions and up to 32 model groups in `%LOCALAPPDATA%\LocalCommander\Monitor`. Known command classes such as `node --test`, `git status` and `npm run build` are shown; arbitrary arguments, paths, inline scripts, headers, credentials, request bodies and tool output are never retained. Child PIDs are runtime notifications; the companion PID is identified separately.
+Each instance retains its last 64 observed executions, 100 events, 32 sessions and up to 32 model groups in `%LOCALAPPDATA%\LocalCommander\Monitor`. Legacy command classes remain compatible; optional previews show actual executable and simple arguments (24 arguments, 240 characters maximum). Inline scripts, credential flags/paths, headers, message bodies and other payload arguments are redacted. Execution result code, timeout, elapsed time and sanitized working directory provide context without retaining tool output. Child PIDs are runtime notifications; the companion PID is identified separately.
 
 `logs` shows recent events, model/command classifications and measured compaction or passthrough sizes. Its initial review lists the five largest remaining outputs and suggests focused file reads/searches, lower command verbosity or less polling when the observed counts justify it. These are advisory review candidates, not proven avoidable tokens, automatic command changes or caching. `logs --follow` reports overwritten-history gaps. Last snapshots remain inspectable after a stop, and a new run replaces that state directory's snapshot. `monitor --json` includes all bounded observations, including finished work omitted from the live screen.
 
@@ -161,11 +187,17 @@ An older installed agent produces no monitoring snapshot even if it is running;
 
 ### Meaningful MCP activity
 
-The terminal also reads the personal MCP server's bounded `.local-commander/activity/*.json` snapshots. It shows actual scheduled/queued calls, command classes, managed background processes through exit, recent failures and message-event metadata. The protected audit log and message bodies are not scanned. Snapshots coalesce changes for250ms; there is no heartbeat daemon, AI parsing or network polling. `localcommander logs --follow` prints bounded completion history and updates deterministic optimization hints every five completions: largest response/output sources, repeated polling, calls/errors, tool-plus-queue duration and measured stdout savings. Hints propose review, not unproven extra savings; command status, failures, warnings and required detail must stay intact.
+The terminal also reads the personal MCP server's bounded `.local-commander/activity/*.json` snapshots. It shows actual scheduled/queued calls, command classes, managed background processes through exit, recent failures and message-event metadata. The protected audit log and message bodies are not scanned. Snapshots coalesce changes for250ms. The health row uses the existing loopback health endpoint, cached for30seconds with an800ms timeout; idle activity snapshots are not a failed health check. Relay connection/freshness, queue, diagnostic write errors and dropped events are separate facts; no AI parsing. `localcommander logs --follow` prints bounded completion history and updates deterministic optimization hints every five completions: largest response/output sources, repeated polling, calls/errors, tool-plus-queue duration and measured stdout savings. Hints propose review, not unproven extra savings; command status, failures, warnings and required detail must stay intact.
 
 `agent_presence` allocates a stable alias of at most eight ASCII characters from eighty Jewish, Russian, Arabic, Hindi and Chinese transliterations. The random server-issued runtime UUID selects the pool locally (for example `Yael48` or `Priyabf`); collision resolution is bounded. Labels are optional. Reuse the existing `runtimeId`/`runtimeKey` pair on presence refresh and pass `agent: { runtimeId, runtimeKey }` on ordinary tools, or the same pair in request `_meta.localCommander`. The key stays private and is not retained in monitor snapshots. No second identity/name handshake occurs. `agent_message.to` accepts an active alias as well as existing runtime/role addresses. Names are display/routing hints; UUID/key authentication and ordinary permission checks remain authoritative.
 
-Presence can declare `model`, `project`, `taskId`, `activity` and `phase` (`working`, `analysis`, `message`, `idle`). Model and analysis are labeled reports; the monitor does not read private thoughts or infer them from CPU. Calls without a binding remain visible as **unbound**. Observed CLI hosts get stable short display aliases but remain host observations; their task/model is unavailable without a reporter. Task-log filenames and PR-bearing directory/worktree names are parsed with bounded regex; inferred PRs are marked `(path)`. Sanitized directory context appears beneath current work, and credentials, inline scripts and arbitrary arguments never appear.
+Presence can declare `model`, `project`, `taskId`, `activity` and `phase` (`working`, `analysis`, `message`, `idle`). Model and analysis are labeled reports; the monitor does not read private thoughts or infer them from CPU. Calls without a binding remain visible as **unbound**. Observed CLI hosts get stable short display aliases but remain host observations; their task/model is unavailable without a reporter. Task-log filenames and PR-bearing directory/worktree names are parsed with bounded regex; inferred PRs are marked `(path)`. Sanitized directory context appears beneath current work; bounded simple command arguments appear in redacted previews, while credentials, inline scripts and payloads stay hidden.
+
+The INVESTIGATION panel follows the selected PC: task/project/PR, working directory, current action, then recent outcomes with elapsed time and exit/error codes. Space freezes/resumes the view, Tab focuses the next PC, A shows all PCs and L expands/collapses history. These keys control the investigation view; command dispatch/cancellation still uses the existing authorized MCP tools. Missing model labels say not reported; client presence or explicit batch metadata must declare a known model.
+
+Initial agent_presence and native project_snapshot startup context return a small per-PC memory: Windows/OS, architecture, Node, approved executable availability, eight worked commands and eight recent failures. Facts cache for60seconds;32 outcome signatures persist for30days in protected state. Refresh presence with includeHostMemory:true after a failure or environment change; routine refreshes omit it. Only fully completed exit0 counts as worked. Memory is advice and never widens permission. Package versions are not inferred.
+
+Successful complete stdout can reuse the existing TAP compactor or a lossless JSON whitespace compactor. It preserves duplicate keys, number/string lexemes, stderr and result status; executed commands never change. The optional operator capture runs once for600seconds only with LCMCP_TRAFFIC_CAPTURE_SECONDS=600, retaining bounded pseudonymous authenticated MCP/device-relay metadata rather than raw bodies. Production capture is now off; its observed JSON outputs were already compact, so no extra production JSON savings were measured.
 
 Response bytes count the JSON tool text once (batch child responses are delivered inside the parent). Output bytes and saved stdout bytes have separate counters; tokens are estimates at bytes/4. Runtime/model groups retain their original model declaration, so changing a reported model cannot reattribute earlier savings. Limits:256 in-flight calls,64 agent/model groups and managed process projections,100 completion events,32 source files,1MiB per snapshot. Dropped observations and diagnostic write failures are reported in log insights. Snapshot write failure cannot fail a tool.
 

package/bin/localcommander.mjs

@@ -411,6 +411,24 @@ async function uninstall(purgeState) {
   }
   process.stdout.write(purgeState ? "Local Commander removed, including local enrollment state.\n" : "Local Commander removed. Protected enrollment state was preserved.\n");
 }
+function allowCommandHelp() {
+  return [
+    "Usage: npx local-commander-agent@latest allow-command <workspaceGrantId> <name> <absolute-executable-path>",
+    "Exactly three arguments are required. Quote executable paths containing spaces.",
+    "Find the workspace ID with: npx local-commander-agent@latest workspaces",
+    "",
+    "CMD: find Git with where git.exe, then copy the intended full path:",
+    '  npx local-commander-agent@latest allow-command WORKSPACE_ID git "C:\\Path To Git\\git.exe"',
+    "Replace WORKSPACE_ID and the example path with your actual values.",
+    "",
+    "PowerShell only:",
+    "  $gitExe = @(Get-Command git.exe -CommandType Application -ErrorAction Stop)[0].Source",
+    '  npx.cmd local-commander-agent@latest allow-command WORKSPACE_ID git "$gitExe"',
+    "CMD does not evaluate (Get-Command ...).Source. Local Commander never evaluates shell expressions.",
+    "A valid command still requires local owner approval.",
+    ""
+  ].join("\n");
+}
 function help() {
   return [
     "Local Commander agent " + VERSION,
@@ -433,6 +451,7 @@ function help() {
     "  localcommander fabric-worker                restricted worker request through private stdin",
     "  npx local-commander-agent@latest allow-write <workspaceGrantId>",
     "  npx local-commander-agent@latest allow-command <workspaceGrantId> <name> <absolute-executable-path>",
+    "  npx local-commander-agent@latest allow-command --help  CMD and PowerShell examples",
     "  npx local-commander-agent@latest allow-localhost <workspaceGrantId> <port>",
     "  npx local-commander-agent@latest deny-write|deny-command|deny-localhost ...",
     "  npx local-commander-agent@latest uninstall [--purge-state]",
@@ -448,6 +467,14 @@ async function main() {
     process.stdout.write(help());
     return;
   }
+  if (command === "allow-command") {
+    if (args.length === 1 && ["--help", "-h"].includes(args[0])) {
+      process.stdout.write(allowCommandHelp());
+      return;
+    }
+    // Reject shell fragments before reading installed state or opening owner consent.
+    if (args.length !== PERMISSION_COMMANDS[command] || !path.win32.isAbsolute(args[2])) fail("ARGUMENT_INVALID");
+  }
   if (command === "bootstrap" || command === "install") {
     if (args.length) fail("ARGUMENT_INVALID");
     await bootstrap();
@@ -530,5 +557,6 @@ async function main() {
 void main().catch(error => {
   const code = error && typeof error.message === "string" && /^[A-Z0-9_]{1,80}$/u.test(error.message) ? error.message : "LOCAL_COMMANDER_FAILED";
   process.stderr.write(code + "\n");
+  if (code === "ARGUMENT_INVALID" && process.argv[2] === "allow-command") process.stderr.write(allowCommandHelp());
   process.exitCode = 1;
 });

package/bin/monitor-context.d.mts

@@ -3,3 +3,5 @@ export function agentName(id: string): string;
 export interface MonitorContext { project: string | null; directory: string | null; taskId: string | null; pr: number | null; inferred: boolean }
 export function contextSummary(meta?: Record<string, unknown>): MonitorContext;
 export function commandSummary(tool: string, meta?: Record<string, unknown>): string;
+
+export function commandPreview(tool: string, meta?: Record<string, unknown>): string;

package/bin/monitor-context.mjs

@@ -43,3 +43,22 @@ export function commandSummary(tool, meta = {}) {
   if (name === "npm" && args[0] === "run" && ["test", "build", "typecheck", "lint", "dev", "start"].includes(args[1])) return "npm run " + args[1];
   return name + (args.length ? " [args]" : "");
 }
+
+/** Diagnostic preview only. Never used to construct or execute a command. */
+export function commandPreview(tool, meta = {}) {
+  if (!["command_run", "process_start"].includes(tool)) return commandSummary(tool, meta);
+  const name = typeof meta.command === "string" && /^[A-Za-z0-9_.-]{1,40}$/.test(meta.command) ? meta.command : "command";
+  const args = Array.isArray(meta.args) ? meta.args.slice(0, 24) : [];
+  let hideNext = false, inline = false;
+  const safe = args.map(arg => {
+    if (inline || hideNext) { hideNext = false; return "[redacted]"; }
+    if (typeof arg !== "string") return "[value]";
+    if (/^(?:-e|--eval|-p|--print|-c|-command|--command|-encodedcommand|\/c|\/k)$/i.test(arg) &&
+        /^(?:node|python|bash|sh|powershell|pwsh|cmd)(?:\.[a-z]+)?$/i.test(name)) inline = true;
+    if (/^(?:[-/]+(?:.*(?:token|password|passwd|secret|credential|authorization|api[-_]?key)|auth|key|header|env|config|data|data-raw|data-binary|message|prompt)|-[uHpmd])$/i.test(arg)) hideNext = true;
+    if (/(?:token|password|passwd|secret|credential|authorization|api[-_]?key)\s*[=:]|(?:^|[/\\])(?:\.env(?:\.|$)|credentials|\.npmrc)|:\/\/|[\x00-\x1f\x7f]|[A-Za-z0-9+/_=-]{40,}/i.test(arg)) return "[redacted]";
+    // ponytail: printable simple argv only; embedded scripts and complex values stay private.
+    return arg.length <= 96 && /^[A-Za-z0-9 _./\\:@()+=-]+$/.test(arg) ? (arg.includes(" ") ? JSON.stringify(arg) : arg) : "[value]";
+  });
+  return [name, ...safe, ...(Array.isArray(meta.args) && meta.args.length > 24 ? ["…"] : [])].join(" ").slice(0, 240);
+}

package/bin/monitor-mcp.mjs

@@ -9,6 +9,13 @@ const nullable = (value, test) => value === null || test(value);
 const tool = value => typeof value === "string" && /^[a-z_]{1,64}$/.test(value);
 const model = value => text(value, 80) && /^[A-Za-z0-9][A-Za-z0-9._:/+-]{0,79}$/.test(value);
 const name = value => text(value, 8) && /^[A-Za-z][A-Za-z0-9]{0,7}$/.test(value);
+const preview = row => {
+  if (row.preview === undefined) return row.command;
+  if (!text(row.preview, 240)) throw Error("MCP_MONITOR_INVALID");
+  return row.preview;
+};
+const optionalModel = row => row.model === undefined || row.model === null ? null : model(row.model) ? row.model : invalid();
+const optionalExit = row => row.exitCode === undefined || row.exitCode === null ? null : Number.isInteger(row.exitCode) && Math.abs(row.exitCode) <= 2147483648 ? row.exitCode : invalid();
 const invalid = () => { throw Error("MCP_MONITOR_INVALID"); };
 function agentView(a) {
   if (a === null) return null;
@@ -36,7 +43,7 @@ export function mcpView(raw, alive = pid => { try { process.kill(pid, 0); return
   const calls = raw.calls.map(row => {
     if (!count(row.id) || !["accepted", "queued", "running"].includes(row.state) || !Number.isSafeInteger(row.at) || row.at < 1 || row.at > Date.now() + 5000) invalid();
     const agent = agentView(row.agent);
-    return { id: row.id, tool: row.tool, command: command(row), state: row.state, at: row.at, agent, context: contextView(row.context) };
+    return { id: row.id, tool: row.tool, command: command(row), preview: preview(row), state: row.state, at: row.at, agent, context: contextView(row.context) };
   });
   const metrics = raw.metrics.map(row => {
     if (!tool(row.tool) || ![row.calls, row.errors, row.sentBytes, row.savedBytes, row.outputBytes, row.durationMs].every(count) || row.errors > row.calls) invalid();
@@ -51,17 +58,24 @@ export function mcpView(raw, alive = pid => { try { process.kill(pid, 0); return
   if (raw.processes !== undefined && (!Array.isArray(raw.processes) || raw.processes.length > 64)) invalid();
   const processes = (raw.processes ?? []).map(row => {
     if (!id(row.id) || !count(row.pid) || !row.pid) invalid();
-    return { id: row.id, pid: row.pid, command: command({ tool: "process_start", command: row.command }), context: contextView(row.context), agent: agentView(row.agent) };
+    return { id: row.id, pid: row.pid, command: command({ tool: "process_start", command: row.command }), preview: preview(row), context: contextView(row.context), agent: agentView(row.agent) };
   });
   const events = raw.events.map(row => {
     if (!count(row.id) || typeof row.at !== "string" || !Number.isFinite(Date.parse(row.at)) || !["failed", "finished"].includes(row.state) ||
         !nullable(row.agent, id) || !nullable(row.name, name) ||
         !nullable(row.code, value => /^[A-Z][A-Z0-9_]{0,63}$/.test(value)) || ![row.durationMs, row.sentBytes, row.savedBytes].every(count)) invalid();
-    return { id: row.id, at: row.at, tool: row.tool, command: command(row), state: row.state, agent: row.agent, name: row.name,
-      context: contextView(row.context), code: row.code, durationMs: row.durationMs, sentBytes: row.sentBytes, savedBytes: row.savedBytes };
+    return { id: row.id, at: row.at, tool: row.tool, command: command(row), preview: preview(row), state: row.state, agent: row.agent, name: row.name,
+      context: contextView(row.context), model: optionalModel(row), exitCode: optionalExit(row), timedOut: row.timedOut === true, code: row.code, durationMs: row.durationMs, sentBytes: row.sentBytes, savedBytes: row.savedBytes };
+  });
+  if (raw.transitions !== undefined && (!Array.isArray(raw.transitions) || raw.transitions.length > 100)) invalid();
+  const transitions = (raw.transitions ?? []).map(row => {
+    if (!count(row.seq) || !count(row.id) || row.state !== "running" || !tool(row.tool) ||
+        typeof row.at !== "string" || !Number.isFinite(Date.parse(row.at)) || !nullable(row.name, name) || !text(row.preview, 240)) invalid();
+    return { seq: row.seq, id: row.id, at: row.at, tool: row.tool, preview: row.preview, state: row.state,
+      context: contextView(row.context), name: row.name, model: optionalModel(row) };
   });
   return { instanceId: raw.instanceId, pid: raw.pid, computer: raw.computer, updatedAt: raw.updatedAt, running: alive(raw.pid), queue: raw.queue,
-    calls, processes, agents, metrics, events, dropped: raw.dropped, writeErrors: raw.writeErrors, writes: raw.writes };
+    calls, processes, agents, metrics, events, transitions, dropped: raw.dropped, writeErrors: raw.writeErrors, writes: raw.writes };
 }
 export async function readMcpActivity(projectRoot = process.cwd()) {
   const directory = path.join(presenceDirectory(projectRoot), "activity");
@@ -78,3 +92,45 @@ export async function readMcpActivity(projectRoot = process.cwd()) {
   }
   return { instances: instances.sort((a, b) => a.instanceId.localeCompare(b.instanceId)), unavailable };
 }
+
+let healthCache;
+/** Probe only the existing loopback health route, once per 30s; idle activity age is not health. */
+export async function readMcpHealth(projectRoot = process.cwd()) {
+  if (healthCache && Date.now() - healthCache.time < 30_000) return healthCache.result;
+  let endpoint = "http://127.0.0.1:17321/health", configured = false;
+  try {
+    const file = path.resolve(projectRoot, process.env.LCMCP_CONFIG?.trim() || "local-commander.config.json");
+    const stat = await lstat(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 65_536) throw Error("CONFIG_INVALID");
+    const config = await readState(file);
+    const host = config.server?.host ?? "127.0.0.1", port = config.server?.port ?? 17321;
+    if (!["localhost", "127.0.0.1", "::1"].includes(host) || !Number.isInteger(port) || port < 1 || port > 65535) throw Error("HEALTH_NOT_LOOPBACK");
+    endpoint = "http://" + (host === "::1" ? "[::1]" : host) + ":" + port + "/health";
+    configured = true;
+  } catch (error) {
+    if (error.code !== "ENOENT") return { state: "unavailable", status: null, at: new Date().toISOString(), latencyMs: null };
+  }
+  const start = Date.now();
+  let result;
+  try {
+    const response = await fetch(endpoint, { signal: AbortSignal.timeout(800), redirect: "error" });
+    const reader = response.body?.getReader();
+    let body = "", bytes = 0;
+    if (reader) {
+      try {
+        while (true) {
+          const chunk = await reader.read();
+          if (chunk.done) break;
+          bytes += chunk.value.byteLength;
+          if (bytes > 2048) throw Error("HEALTH_RESPONSE_LIMIT");
+          body += Buffer.from(chunk.value).toString("utf8");
+        }
+      } finally { void reader.cancel().catch(() => {}); }
+    }
+    const value = JSON.parse(body);
+    result = { state: response.ok && value.status === "ok" ? "healthy" : "failed", status: response.status,
+      at: new Date().toISOString(), latencyMs: Date.now() - start };
+  } catch { result = { state: configured ? "unreachable" : "not observed", status: null, at: new Date().toISOString(), latencyMs: Date.now() - start }; }
+  healthCache = { time: Date.now(), result };
+  return result;
+}

package/bin/monitor.mjs

@@ -2,7 +2,7 @@ import { lstat, open, readdir } from "node:fs/promises";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { readAgentActivity } from "./monitor-agents.mjs";
-import { readMcpActivity, contextView } from "./monitor-mcp.mjs";
+import { readMcpActivity, readMcpHealth, contextView } from "./monitor-mcp.mjs";
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const STATES = new Set(["starting", "connecting", "connected", "disconnected", "stopped", "failed"]);
@@ -87,11 +87,14 @@ export function monitorView(raw, now = Date.now(), alive = pidAlive) {
     const measured = execution.originalBytes !== null;
     if (measured ? execution.sentBytes === null || execution.savedBytes === null || execution.sentBytes > execution.originalBytes ||
         execution.savedBytes !== execution.originalBytes - execution.sentBytes : execution.sentBytes !== null || execution.savedBytes !== null) invalid();
+    if (execution.preview !== undefined && (typeof execution.preview !== "string" || execution.preview.length > 240 || /[\u0000-\u001f\u007f-\u009f]/u.test(execution.preview))) invalid();
+    for (const field of ["startedAt", "endedAt"]) if (execution[field] !== undefined && execution[field] !== null && (!Number.isSafeInteger(execution[field]) || execution[field] < 0 || execution[field] > now + 5000)) invalid();
+    if (execution.exitCode !== undefined && execution.exitCode !== null && (!Number.isInteger(execution.exitCode) || Math.abs(execution.exitCode) > 2147483648)) invalid();
     const profile = profileView(execution.profile);
     const active = ["requested", "prepared", "accepted", "running"].includes(execution.state);
     const state = active && connection !== "connected" ? connection === "stale" ? "stale" : "unknown" : execution.state;
-    return { executionId: execution.executionId, sessionId: execution.sessionId, name: execution.name, command: execution.command,
-      state, pid: execution.pid, profile, context: execution.context === undefined ? null : contextView(execution.context), originalBytes: execution.originalBytes, sentBytes: execution.sentBytes,
+    return { executionId: execution.executionId, sessionId: execution.sessionId, name: execution.name, command: execution.command, preview: execution.preview ?? execution.command,
+      startedAt: execution.startedAt ?? null, endedAt: execution.endedAt ?? null, exitCode: execution.exitCode ?? null, timedOut: execution.timedOut === true, state, pid: execution.pid, profile, context: execution.context === undefined ? null : contextView(execution.context), originalBytes: execution.originalBytes, sentBytes: execution.sentBytes,
       savedBytes: execution.savedBytes, reason: execution.reason, estimatedSavedTokens: measured ? Math.round(execution.savedBytes / 4) : null };
   });
   return { instanceId: raw.instanceId, pid: raw.pid, agentVersion: raw.agentVersion, updatedAt: raw.updatedAt,
@@ -134,11 +137,15 @@ export async function readMonitors(directory) {
 function logLine(instance, event) {
   const execution = instance.executions.find(row => row.executionId === event.executionId);
   return [event.at, "pc=" + (instance.computer ?? "unknown"), "pid=" + instance.pid, event.event, event.tool, event.code,
-    execution && "cmd=" + execution.command,
+    execution && "cmd=" + (execution.preview ?? execution.command),
     execution?.profile && "model=" + execution.profile.model,
     execution && ["compacted", "passthrough"].includes(event.event) && "saved=~" + compact(execution.estimatedSavedTokens) +
       "tok sent=" + execution.sentBytes + "B reason=" + execution.reason,
-    event.sessionId && "session=" + event.sessionId, event.executionId && "execution=" + event.executionId].filter(Boolean).join(" ");
+    execution?.exitCode !== null && execution?.exitCode !== undefined && "exit=" + execution.exitCode,
+    execution?.timedOut && "timeout=true",
+    execution?.endedAt && execution.startedAt && "elapsed=" + (execution.endedAt - execution.startedAt) + "ms",
+    execution?.context?.directory && "dir=" + execution.context.directory, execution?.context?.taskId && "task=" + execution.context.taskId,
+    event.sessionId && "session=" + event.sessionId.slice(0, 8), event.executionId && "execution=" + event.executionId.slice(0, 8)].filter(Boolean).join(" ");
 }
 
 const compact = value => value === null ? "n/a" : value >= 1e6 ? (value / 1e6).toFixed(1) + "M" : value >= 1000 ? (value / 1000).toFixed(1) + "k" : String(value);
@@ -146,6 +153,33 @@ const fit = (value, width) => {
   const text = String(value);
   return (text.length > width ? width < 4 ? text.slice(0, width) : text.slice(0, width - 3) + "..." : text).padEnd(width);
 };
+
+function storyLines(result, computer) {
+  const personal = (result.mcp?.instances ?? []).filter(i => i.running && (!computer || i.computer === computer));
+  const native = result.instances.filter(i => i.running && (!computer || i.computer === computer));
+  const current = personal.flatMap(i => i.calls).find(c => c.state === "running") ?? personal.flatMap(i => i.calls)[0];
+  const history = [
+    ...personal.flatMap(i => [...(i.transitions ?? []), ...i.events].map(e => ({ ...e, computer: i.computer }))),
+    ...native.flatMap(i => i.events.filter(e => ["execute", "finished", "failed", "cancelled", "unknown"].includes(e.event)).map(e => {
+      const work = i.executions.find(x => x.executionId === e.executionId);
+      return { ...e, computer: i.computer, state: e.event, preview: work?.preview ?? work?.command ?? e.tool,
+        name: work?.executionId.slice(0, 8), context: work?.context, durationMs: work?.endedAt && work.startedAt ? work.endedAt - work.startedAt : null };
+    }))
+  ].sort((a,b) => a.at.localeCompare(b.at));
+  const latest = history.at(-1), context = current?.context ?? latest?.context;
+  const lines = [
+    "INVESTIGATION  " + (computer ?? "all PCs") + (result.paused ? "  [VIEW FROZEN; work continues]" : "  [LIVE]"),
+    "  Task: " + (context?.taskId ?? context?.project ?? "not reported") + (context?.pr ? " | PR #" + context.pr : "") +
+      " | Where: " + (context?.directory ?? "not reported"),
+    "  " + (current ? "Now: " + (current.agent?.name ?? "unbound caller") + " " + (current.preview ?? current.command) + " [" + current.state + "]" :
+      latest ? "Latest: " + (latest.name ?? "unbound caller") + " " + (latest.preview ?? latest.command ?? latest.state) + " [" + latest.state + "]" : "Waiting for the first reported operation.")
+  ];
+  for (const event of history.slice(-(result.storyDepth ?? 2))) lines.push("  " + event.at.slice(11,19) + "Z  " +
+    (event.name ?? "unbound") + " > " + (event.preview ?? event.command ?? event.state) + " > " + event.state.toUpperCase() +
+    (event.durationMs != null ? " (" + event.durationMs + "ms)" : "") + (event.code ? " " + event.code : ""));
+  return lines;
+}
+
 export function formatMonitor(result, columns = process.stdout.columns ?? 120, height = 40, color = false) {
   const width = Math.max(1, Math.min(160, Number.isFinite(columns) ? Math.floor(columns) : 120));
   height = Math.max(1, Number.isFinite(height) ? Math.floor(height) : 40);
@@ -156,7 +190,7 @@ export function formatMonitor(result, columns = process.stdout.columns ?? 120, h
   const mcpCalls = mcp.flatMap(instance => instance.calls);
   const queued = mcp.reduce((sum, instance) => sum + (instance.queue ?? 0), 0);
   const errors = mcpMetrics.reduce((sum, item) => sum + item.errors, 0);
-  for (const instance of [...live].sort((a, b) => a.instanceId.localeCompare(b.instanceId))) {
+  for (const instance of result.instances.filter(item => item.running && (item.computer || item.connection !== "stale")).sort((a, b) => a.instanceId.localeCompare(b.instanceId))) {
     const name = instance.computer ?? "unknown";
     if (!pcs.has(name)) pcs.set(name, []);
     pcs.get(name).push(instance);
@@ -178,7 +212,7 @@ export function formatMonitor(result, columns = process.stdout.columns ?? 120, h
   const pair = (left, right) => fit(left, Math.max(0, width - right.length - 1)) + " " + right;
   const lines = [pair("LC >_  Local Commander MCP", "LIVE MONITOR"), "-".repeat(width), "> fleet status", ""];
   const connected = [...pcs].filter(([name, instances]) => instances.some(instance => instance.connection === "connected") || mcp.some(instance => instance.computer === name)).length;
-  if (height >= 26 && width >= 60) lines.push(
+  if (height >= 36 && width >= 60) lines.push(
     "+-------------+   " + connected + " PCs reporting",
     "| >_ " + fit(jobs ? "RUNNING" : agents.length ? "OBSERVING" : connected ? "READY" : "WAITING", 9) + "|   " + jobs + " active commands",
     "| LC >_       |   " + agentSummary + " | " + hostSummary,
@@ -196,16 +230,17 @@ export function formatMonitor(result, columns = process.stdout.columns ?? 120, h
       "Raw: n/a   Sent: n/a   Saved: n/a",
     mcp.length ? "MCP this run: " + mcpMetrics.reduce((sum, row) => sum + row.calls, 0) + " calls | response " + compact(mcpMetrics.reduce((sum, row) => sum + row.sentBytes, 0)) +
       "B | saved stdout " + tokens(mcpMetrics.reduce((sum, row) => sum + row.savedBytes, 0)) + " tok | errors " + errors :
-      "~ Tokens: bytes / 4, this run | model: reported or unavailable",
+      "~ Tokens: bytes / 4, this run | model: declared or not reported",
     mcpMetrics.length ? "Review: " + [...mcpMetrics].sort((a, b) => b.sentBytes - a.sentBytes).slice(0, 2)
       .map(row => row.tool + " " + compact(row.sentBytes) + "B / " + row.calls + " calls / " + Math.round(row.durationMs / Math.max(1, row.calls)) + "ms avg").join(" | ") :
       "Server: " + ([...new Set(live.map(instance => instance.origin).filter(Boolean))].join(", ") || "not connected"),
-    "Ctrl+C exits | logs --follow: history + optimization | --json: all observations" +
+    "Space freeze/resume | Tab focus PC | A all PCs | L timeline | Ctrl+C exit" +
       (result.mcp?.unavailable ? " | MCP snapshots unavailable: " + result.mcp.unavailable : "") +
       (result.activity?.unavailable.length ? " | unavailable: " + result.activity.unavailable.join(",") : "")
   ];
+  if (height >= 30 && width >= 60) footer.unshift(...storyLines(result, result.focusComputer));
   const capacity = Math.max(0, height - lines.length - footer.length - 1);
-  for (const [name, instances] of [...pcs].sort(([a], [b]) => a.localeCompare(b))) {
+  for (const [name, instances] of [...pcs].filter(([name]) => !result.focusComputer || name === result.focusComputer).sort(([a], [b]) => a.localeCompare(b))) {
     const pcStats = instances.map(instance => instance.efficiency).filter(Boolean);
     const pcMcp = mcp.filter(instance => instance.computer === name);
     const pcSaved = pcStats.length || pcMcp.length ? tokens(pcStats.reduce((sum, item) => sum + item.savedBytes, 0) + pcMcp.flatMap(instance => instance.metrics).reduce((sum, row) => sum + row.savedBytes, 0)) : "n/a";
@@ -223,9 +258,13 @@ export function formatMonitor(result, columns = process.stdout.columns ?? 120, h
     const mcpError = pcMcp.flatMap(instance => instance.events).filter(event => event.state === "failed").sort((a, b) => b.at.localeCompare(a.at))[0];
     const mcpMessage = pcMcp.flatMap(instance => instance.events).filter(event => event.tool === "agent_message").sort((a, b) => b.at.localeCompare(a.at))[0];
     const statusLines = [
-      ...(recent ? ["  Last: " + latest.at.slice(11, 19) + "Z " + recent.executionId.slice(0, 8) + " " + recent.command + " " + recent.state.toUpperCase()] : []),
-      ...(mcpRecent ? ["  MCP last: " + mcpRecent.at.slice(11, 19) + "Z " + (mcpRecent.name ?? "unbound") + " " + mcpRecent.command + " " + mcpRecent.state.toUpperCase()] : []),
-      ...(mcpError ? ["  Error: " + mcpError.at.slice(11, 19) + "Z " + mcpError.command + " " + mcpError.code] : []),
+      "  Health: " + (instances.map(i => "relay " + i.connection.toUpperCase()).join(", ") || "relay not observed") +
+        (result.health ? " | MCP " + result.health.state + (result.health.status ? " HTTP " + result.health.status : "") + " @ " + result.health.at.slice(11, 19) + "Z" : " | MCP probe not run"),
+      ...(pcMcp.length ? ["  Diagnostics: queue " + pcMcp.reduce((s,i) => s + (i.queue ?? 0), 0) + " | write errors " +
+        pcMcp.reduce((s,i) => s + i.writeErrors, 0) + " | dropped " + pcMcp.reduce((s,i) => s + i.dropped, 0)] : []),
+      ...(recent ? ["  Last: " + latest.at.slice(11, 19) + "Z " + recent.executionId.slice(0, 8) + " " + (recent.preview ?? recent.command) + " " + recent.state.toUpperCase()] : []),
+      ...(mcpRecent ? ["  MCP last: " + mcpRecent.at.slice(11, 19) + "Z " + (mcpRecent.name ?? "unbound") + " " + (mcpRecent.preview ?? mcpRecent.command) + " " + mcpRecent.state.toUpperCase()] : []),
+      ...(mcpError ? [ "  Last error: " + mcpError.at.slice(11, 19) + "Z " + (mcpError.preview ?? mcpError.command) + " " + mcpError.code] : []),
       ...(mcpMessage && mcpMessage !== mcpRecent ? ["  Message: " + (mcpMessage.name ?? "unbound") + " " + mcpMessage.command + " | task " + (mcpMessage.context.taskId ?? "unreported")] : [])
     ];
     const rowCapacity = capacity - statusLines.length;
@@ -233,10 +272,10 @@ export function formatMonitor(result, columns = process.stdout.columns ?? 120, h
     const rows = [
       ...pcMcp.flatMap(instance => instance.processes.map(row => ({ executionId: "process:" + row.id,
         displayId: row.agent?.name ?? row.id.slice(0, 8), kind: "call", pid: row.pid, order: "0:process:" + row.id,
-        command: row.command, context: row.context, state: "running", profile: row.agent?.model ? { model: row.agent.model } : null, estimatedSavedTokens: null }))),
+        command: row.preview ?? row.command, context: row.context, state: "running", profile: row.agent?.model ? { model: row.agent.model } : null, estimatedSavedTokens: null }))),
       ...pcMcp.flatMap(instance => instance.calls.map(call => ({ executionId: "mcp:" + instance.instanceId + ":" + call.id,
         displayId: call.agent?.name ?? ("mcp" + call.id).slice(0, 8).padEnd(8), kind: "call", pid: instance.pid,
-        order: "0:" + String(call.id).padStart(12, "0"), command: (call.agent ? "" : "unbound: ") + call.command,
+        order: "0:" + String(call.id).padStart(12, "0"), command: (call.agent ? "" : "unbound: ") + (call.preview ?? call.command),
         state: call.state, profile: call.agent?.model ? { model: call.agent.model } : null, estimatedSavedTokens: call.agent ? savingsFor(call.agent.runtimeId) : null,
         detail: [call.context.taskId && "task " + call.context.taskId, call.context.pr && "PR #" + call.context.pr + (call.context.inferred ? " (path)" : ""),
           call.context.project && "project " + call.context.project, call.agent?.phase === "analysis" && "analysis (reported)",
@@ -257,12 +296,12 @@ export function formatMonitor(result, columns = process.stdout.columns ?? 120, h
           estimatedSavedTokens: measured.length || usage.length ? Math.round((measured.reduce((sum, row) => sum + row.savedBytes, 0) + usage.reduce((sum, row) => sum + row.savedBytes, 0)) / 4) : null,
           partial: measured.length > 0 && measured.length < agent.executionIds.length },
           ...linked.filter(row => ["requested", "prepared", "accepted", "running"].includes(row.state))
-            .map(row => ({ ...row, command: "-> " + row.command, order: "1:" + agent.id + ":work:" + row.executionId }))];
+            .map(row => ({ ...row, command: "-> " + (row.preview ?? row.command), order: "1:" + agent.id + ":work:" + row.executionId }))];
       }),
-      ...instances.flatMap(active).filter(row => !pcAgents.some(agent => agent.executionIds.includes(row.executionId)))
+      ...instances.flatMap(active).filter(row => !pcAgents.some(agent => agent.executionIds.includes(row.executionId))).map(row => ({ ...row, command: row.preview ?? row.command }))
     ];
     const state = instances.some(instance => active(instance).length) || pcMcp.some(instance => instance.calls.length) ? "RUNNING" : pcAgents.length || pcMcp.length ? "OBSERVING" :
-      instances.some(instance => instance.connection === "connected") ? "READY" : "CONNECTING";
+      instances.some(instance => instance.connection === "connected") ? "READY" : instances[0]?.connection.toUpperCase() ?? "OBSERVING";
     // Keep each process with its PC heading, including in a short terminal.
     if (rowCapacity - body.length < (rows.length ? width < 60 ? 5 : 4 : 3)) break;
     body.push(pair("PC " + name + "  |  saved " + pcSaved + " tokens", state));
@@ -271,7 +310,7 @@ export function formatMonitor(result, columns = process.stdout.columns ?? 120, h
       if (width >= 100) body.push("  " + fit("ID", 8) + "  " + fit("PID", 7) + "  " + fit("AGENT / HOST / DOING", width - 71) +
         "  " + fit("MODEL", 24) + "  " + fit("SAVED TOK", 10) + "  STATE");
       for (const row of rows.sort((a, b) => (a.order ?? "1:" + a.executionId).localeCompare(b.order ?? "1:" + b.executionId))) {
-        const id = row.displayId ?? row.executionId.slice(0, 8), model = row.profile?.model ?? "unavailable";
+        const id = row.displayId ?? row.executionId.slice(0, 8), model = row.profile?.model ?? (row.kind === "host" ? "process only" : "not reported");
         const saving = row.estimatedSavedTokens === null ? "n/a" : "~" + compact(row.estimatedSavedTokens) + (row.partial ? "+" : "");
         const entry = width >= 100 ? ["  " + fit(id, 8) + "  " + fit(row.pid ?? "-", 7) + "  " + fit(row.command, width - 71) +
           "  " + fit(model, 24) + "  " + fit(saving, 10) + "  " + row.state.toUpperCase()] : [
@@ -292,7 +331,7 @@ export function formatMonitor(result, columns = process.stdout.columns ?? 120, h
     for (const line of statusLines) if (body.length + 2 <= capacity) body.push(line);
     body.push("");
   }
-  if (!pcs.size) body.push(result.instances.length ? "No active work. Stopped, stale and completed work is hidden." :
+  if (!pcs.size) body.push(result.instances.length ? "No live PC reported. See logs for completed work and connection history." :
     "No monitoring snapshots. Update/start a monitoring-capable agent.");
   lines.push(...body.slice(0, capacity));
   while (lines.length < height - footer.length - 1) lines.push("");
@@ -364,34 +403,63 @@ export async function runMonitor(directory, command, args) {
   const previousHosts = new Map();
   const fixedScreen = command === "monitor" && repeat && process.stdout.isTTY && !args.includes("--json");
   let previous = "", previousSize = "", initial = true, insightCheckpoint = "";
+  let paused = false, latestResult, focusComputer = null, storyDepth = 2;
+  const interactive = fixedScreen && process.stdin.isTTY && typeof process.stdin.setRawMode === "function";
+  const wasRaw = process.stdin.isRaw, wasPaused = process.stdin.isPaused();
+  const input = chunk => {
+    const key = chunk.toString().toLowerCase();
+    if (key === "\u0003" || key === "q") stop.abort();
+    else if (key === " ") paused = !paused;
+    else if (key === "a") focusComputer = null;
+    else if (key === "l") storyDepth = storyDepth === 2 ? 5 : 2;
+    else if (key === "\t" && latestResult) {
+      const computers = [...new Set([...latestResult.instances.map(i => i.computer),
+        ...latestResult.mcp.instances.map(i => i.computer), ...(latestResult.activity?.rows ?? []).map(i => i.computer)].filter(Boolean))].sort();
+      focusComputer = computers[(computers.indexOf(focusComputer) + 1) % computers.length] ?? null;
+    }
+  };
+  if (interactive) { process.stdin.setRawMode(true); process.stdin.on("data", input); process.stdin.resume(); }
   if (fixedScreen) process.stdout.write("\x1b[?1049h\x1b[?25l");
   try {
     do {
-      const result = await readMonitors(directory);
-      result.mcp = await readMcpActivity();
-      if (command === "monitor") result.activity = await readAgentActivity(directory, { previousHosts, signal: stop.signal });
+      const result = paused && latestResult ? latestResult : await readMonitors(directory);
+      if (!(paused && latestResult)) {
+        result.mcp = await readMcpActivity();
+        result.health = await readMcpHealth();
+        if (command === "monitor") result.activity = await readAgentActivity(directory, { previousHosts, signal: stop.signal });
+        latestResult = result;
+      }
+      result.paused = paused; result.focusComputer = focusComputer; result.storyDepth = storyDepth;
       if (command === "logs" && (result.instances.length || result.mcp.instances.length)) {
         const checkpoint = result.mcp.instances.map(instance => instance.instanceId + ":" + Math.floor(instance.metrics.reduce((sum, row) => sum + row.calls, 0) / 5)).join(",");
         if (initial || checkpoint !== insightCheckpoint) { process.stdout.write(formatInsights(result)); insightCheckpoint = checkpoint; }
         for (const instance of result.instances) {
           const after = seen.get(instance.instanceId) ?? 0;
           if (after && instance.events[0]?.seq > after + 1) process.stdout.write("Earlier events were overwritten in the 100-event buffer.\n");
-          for (const event of instance.events) if (event.seq > after) process.stdout.write(logLine(instance, event) + "\n");
+          for (const event of instance.events) if (event.seq > after && !["status", "output"].includes(event.event)) process.stdout.write(logLine(instance, event) + "\n");
           seen.set(instance.instanceId, instance.events.at(-1)?.seq ?? after);
         }
         for (const instance of result.mcp.instances) {
           const key = "mcp:" + instance.instanceId;
-          const after = seen.get(key) ?? 0;
+          const transitionsKey = key + ":starts";
+          const afterStart = seen.get(transitionsKey) ?? 0;
+          for (const event of instance.transitions ?? []) if (event.seq > afterStart) {
+            process.stdout.write([event.at, "pc=" + instance.computer, "agent=" + (event.name ?? "unbound"), event.preview, "RUNNING",
+              "model=" + (event.model ?? "not_reported"), event.context.directory && "dir=" + event.context.directory,
+              event.context.taskId && "task=" + event.context.taskId].filter(Boolean).join(" ") + "\n");
+          }
+          seen.set(transitionsKey, instance.transitions?.at(-1)?.seq ?? afterStart);
           // Request IDs finish out of order: a per-event key tracks actual completions, not numeric high-water IDs.
           for (const event of instance.events) {
             const eventKey = key + ":" + event.id;
             if (seen.has(eventKey)) continue;
-            process.stdout.write([event.at, "pc=" + instance.computer, "agent=" + (event.name ?? "unbound"), event.command, event.state,
+            process.stdout.write([event.at, "pc=" + instance.computer, "agent=" + (event.name ?? "unbound"), event.preview ?? event.command, event.state, "model=" + (event.model ?? "not_reported"),
+              "elapsed=" + event.durationMs + "ms", event.exitCode !== null && "exit=" + event.exitCode, event.timedOut && "timeout=true",
               event.code, event.context.directory && "dir=" + event.context.directory, event.context.taskId && "task=" + event.context.taskId,
               event.context.pr && "PR=" + event.context.pr, "sent=" + event.sentBytes + "B", "saved=~" + Math.round(event.savedBytes / 4) + "tok"].filter(Boolean).join(" ") + "\n");
             seen.set(eventKey, 1);
           }
-          for (const seenKey of seen.keys()) if (seenKey.startsWith(key + ":") && !instance.events.some(event => seenKey === key + ":" + event.id)) seen.delete(seenKey);
+          for (const seenKey of seen.keys()) if (seenKey.startsWith(key + ":") && seenKey !== transitionsKey && !instance.events.some(event => seenKey === key + ":" + event.id)) seen.delete(seenKey);
         }
         for (const key of seen.keys()) if (!result.instances.some(instance => instance.instanceId === key) &&
           !result.mcp.instances.some(instance => key.startsWith("mcp:" + instance.instanceId + ":"))) seen.delete(key);
@@ -413,6 +481,7 @@ export async function runMonitor(directory, command, args) {
       if (repeat) await delay(2000, undefined, { signal: stop.signal }).catch(error => { if (error.name !== "AbortError") throw error; });
     } while (repeat && !stop.signal.aborted);
   } finally {
+    if (interactive) { process.stdin.removeListener("data", input); process.stdin.setRawMode(!!wasRaw); if (wasPaused) process.stdin.pause(); }
     if (fixedScreen) process.stdout.write("\x1b[0m\x1b[?25h\x1b[?1049l");
     process.removeListener("SIGINT", abort);
     process.removeListener("SIGTERM", abort);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-commander-agent",
-  "version": "0.3.13-launcher.1",
+  "version": "0.3.14-cli.1",
   "description": "Windows companion for Local Commander: connect AI clients to local files, approved commands and localhost. Requires https://localcmd.app.",
   "type": "module",
   "bin": {