@pi-chamber/web 0.2.0 → 0.2.1

package/server/lib/pi/session-daemon/DOCUMENTATION.md

@@ -7,13 +7,13 @@ This module is the Pi-owned session-daemon foundation. A detached local daemon p
 ## Entrypoints
 
 - `session-daemon.js`
-  - `createPiSessionRuntime({ cwd, agentDir })` creates a persistent Pi runtime using the selected server-side cwd and Pi agent directory. It uses Pi's normal settings, credentials, models, sessions, skills, prompts, and context discovery, with native extensions explicitly disabled for the core milestone. Sessions created outside PiChamber (Pi CLI or any other writer of the cwd-scoped JSONL directory) are the same records: `sessions.list`/`open` hydrate from `getEntries()`, and a later prompt must overlay live turns onto that log rather than replace it.
+  - `createPiSessionRuntime({ cwd, agentDir })` creates a persistent Pi runtime using the selected server-side cwd and Pi agent directory. It uses Pi's normal settings, credentials, models, sessions, skills, prompts, and context discovery, with native extensions explicitly disabled for the core milestone. Sessions created outside PiChamber (Pi CLI or any other writer of the cwd-scoped JSONL directory) are the same records: `sessions.list`/`open` hydrate from `getEntries()`, then overlay the live `session.messages` / `state.streamingMessage` turn while `isStreaming` is true, including an unpersisted user prompt that has not flushed to JSONL yet. A later prompt must overlay live turns onto that log rather than replace it. An unmatched `toolCall` projects as `running` only while `isStreaming` is authoritative; the same unmatched call in an idle persisted turn projects as a timestamped interruption error instead of malformed `completed` state. `getSession` also reports `isStreaming` and `lifecycle` so a restarted UI can restore the working/tooling state without waiting for the next token.
   - `createSessionDaemon(options)` starts/stops the authenticated local socket daemon and validates its endpoint and setup inputs.
 - `daemon-process.js` is the detached private-process entrypoint. It reads the daemon credential from its owner-only sidecar, starts the socket, writes non-secret identity state only after readiness, and removes only its own state on signal shutdown.
 - `ipc-client.js` is the server-only authenticated request client. It owns JSONL framing and never exposes endpoint or credential values to callers.
 - `runtime-registry.js` owns active runtime identities and session-local subscriptions. It rebinds the subscription after an SDK session replacement, rejects identity conflicts rather than displacing another runtime, and attempts every tracked disposal even when another disposal fails.
-- `session-jsonl.js` validates the cwd-scoped Pi JSONL directory before session discovery. Pi's SDK deliberately skips malformed discovery entries; this boundary maps malformed, missing, and unreadable candidates to stable explicit failures instead of an empty result. Directory names match Pi's SessionManager encoding, including Windows drive letters and Git Bash/MSYS/Cygwin/WSL `/c/...` paths so PiChamber and the Pi CLI share the same JSONL sessions.
-- `supervisor.js` resolves server-only overrides, creates the credential, serializes start/reuse/stop through an owner-only lock, validates daemon identity through `runtime.health`, forwards server-owned commands only after that identity check, and starts or stops the detached process. When the parent is Electron, the child is spawned with `ELECTRON_RUN_AS_NODE=1` so packaged Windows/macOS/Linux apps run the daemon as Node instead of a hidden second Electron GUI process.
+- `session-jsonl.js` validates cwd-scoped Pi JSONL before discovery. List, create, and daemon startup require a valid session header per file; they do not read whole transcripts. `sessions.list` uses `listPiSessionJsonlDirectory` (header, first user prompt, latest rename from the file tail). Full-file validation remains on open of a specific session so a malformed body still fails that chat. Pi's SDK list is not the production list path because it scans every line of every log. Directory names match Pi's SessionManager encoding, including Windows drive letters and Git Bash/MSYS/Cygwin/WSL `/c/...` paths so PiChamber and the Pi CLI share the same JSONL sessions.
+- `supervisor.js` resolves server-only overrides, creates the credential, serializes start/reuse/stop through an owner-only lock, validates daemon identity through `runtime.health`, forwards server-owned commands only after that identity check, and starts or stops the detached process. Reuse requires the ready-state sidecar `entrypoint` to match this checkout's `daemon-process.js`; a healthy daemon from another install (or an older daemon that never recorded an entrypoint) is stopped and replaced so local `bun run dev` cannot keep answering `getSession` without the live-turn overlay. When the parent is Electron, the child is spawned with `ELECTRON_RUN_AS_NODE=1` so packaged Windows/macOS/Linux apps run the daemon as Node instead of a hidden second Electron GUI process.
 - `../routes.js` registers authenticated public adapters before the generic proxy. It exposes only whitelisted runtime, project, session, provider-auth/configuration, settings, resource, and SSE event shapes; no browser response contains daemon paths, credentials, PIDs, headers, or socket framing. Session actions are path-selected, so an identity supplied in a request body cannot redirect a mutation. `archive-store.js` persists PiChamber-only opaque session archive metadata atomically beneath the PiChamber data root and never edits Pi JSONL. `settings-store.js` keeps PiChamber new-session defaults separate from Pi settings.json. `GET /api/pi/settings` copies leftover UI/desktop `defaultModel` / small / walkthrough strings into that sidecar when those sidecar fields are unset, then Sessions settings is the only editor. Sidecar `defaultThinkingByModel` is the per-model thinking map (`provider/model` keys). A stored global `defaultThinking` with a default model is copied onto that map key and dropped; global thinking without a default model remains a clamp-only fallback. `ui-settings-store.js` atomically owns shared PiChamber UI preferences at the data-root `settings.json`; it is exposed as `/api/pi/ui-settings`, not through removed `/api/config/*` aliases. `session-folders-store.js` validates and atomically persists the restored sidebar's folder snapshot at `/api/pi/session-folders`; a missing snapshot is distinct from an empty one. `custom-themes.js` serves validated custom-theme candidates from `/api/pi/themes` with per-file partial-failure isolation. `model-config-store.js` atomically updates Pi's credential-blind `models.json`; literal keys continue through Pi auth and headers are write-only. `providers.config.get` returns `config: null` for a provider that is not in `models.json` (built-in catalog entries) and fails only when that file is present but malformed.
 - `*.test.js` uses temporary cwd, agent, data, and runtime directories; it never loads a developer's Pi home, credentials, or sessions. On Windows the private endpoint is a named pipe, not a `.sock` file, and POSIX mode-bit assertions are skipped.
 
@@ -21,17 +21,18 @@ This module is the Pi-owned session-daemon foundation. A detached local daemon p
 
 - The endpoint is a Unix domain socket on POSIX or a Windows named pipe. TCP endpoints are rejected. Listeners and clients connect with IPC `path` options so Windows `\\.\pipe\pichamber-pi-session-daemon-<owner-key>` works the same as a POSIX socket path.
 - POSIX socket parent directories are mode `0700`; the socket is created mode `0600`. An existing endpoint fails startup rather than being unlinked without daemon-identity verification. Windows named-pipe ACLs are not yet equivalent owner-only OS permissions; credential authentication remains mandatory.
-- The daemon credential and non-secret state sidecars are mode `0600`; their PiChamber parent directory and the operation lock serialize start/reuse/stop. Exclusive lock create writes the owner pid in the same step. A leftover empty or malformed lock, a dead owner pid, or Windows `EPERM`/`EACCES` on exclusive create is retried and stolen after a short freshness window instead of failing as `DAEMON_LOCK_UNAVAILABLE`. Sidecar `chmod` failures on Windows are ignored after the file exists so readiness is still recorded. Health identity includes the daemon PID and must match the state sidecar before the supervisor reuses or signals a process.
+- The daemon credential and non-secret state sidecars are mode `0600`; their PiChamber parent directory and the operation lock serialize start/reuse/stop. Exclusive lock create writes the owner pid in the same step. A leftover empty or malformed lock, a dead owner pid, or Windows `EPERM`/`EACCES` on exclusive create is retried and stolen after a short freshness window instead of failing as `DAEMON_LOCK_UNAVAILABLE`. Sidecar `chmod` failures on Windows are ignored after the file exists so readiness is still recorded. Health identity includes the daemon PID and must match the state sidecar before the supervisor reuses or signals a process. Reuse also requires the ready-state `entrypoint` to equal this host's `daemon-process.js`; a missing or different path is not identity-compatible and is replaced.
 - The public health route deliberately whitelists its response fields. It never returns a daemon endpoint, credential, PID, cwd, agent directory, or transcript data. Public transcript and event projections preserve daemon-redacted assistant error messages so the UI can distinguish provider/runtime failures instead of reducing every failure to `ASSISTANT_ERROR`.
 - A client must send an `authenticate` frame carrying the host-private daemon credential before it can issue a request. Credentials are never logged or returned.
 - Frames are LF-delimited JSON. They have a 1 MiB maximum buffered size. A malformed, oversized, unauthenticated, or invalid request closes the connection.
-- The private core commands are `runtime.health`, `projects.list/select`, `providers.list/config.get/models.set/status/login/login.respond/login.status/logout`, `settings.get/set`, `resources.list/update/prompts.create/prompts.delete`, and session list/create/open/rename/delete/tree/navigate/fork/clone/prompt/steer/followUp/abort/model/thinking/compact operations. Resource lists use opaque IDs and never disclose server paths. Only top-level Pi prompt templates and applicable AGENTS.md sources are editable; package/path resources and skills are browse-only. Resource writes are rejected while a session streams, use an atomic replace, then recreate the idle runtime. Project trust changes are persisted in Pi trust.json and likewise recreate an idle runtime; extensions remain disabled regardless of trust. Provider login submits API keys only across authenticated private IPC or brokers Pi's OAuth/device/manual-code interaction; public projections contain only opaque login IDs, prompts, URLs/device codes, model catalog/configuration, and stable states, never credentials or write-only headers. `providers.models.set` is rejected while a session streams, atomically persists Pi's `models.json`, then rehydrates the idle runtime so the catalog is authoritative immediately. `providers.list` projects only catalog and authentication-status metadata, including Pi-supported `thinkingLevels` (`null` map entries hidden, `xhigh`/`max` opt-in). Session thinking overrides are clamped to the live model's supported levels. `sessions.list` revalidates the selected cwd's JSONL directory before SDK discovery and returns no JSONL paths. The browser explicitly selects an existing user-chosen project directory before listing it; the daemon's startup cwd is an internal fallback, not a user-visible default project. Unnamed persisted sessions use their first prompt as a readable list title when available. `sessions.open` and `getSession` project the last assistant `provider`/`model`/`thinkingLevel` onto the session record so reopening a chat keeps that cache identity. Session selection validates a persisted JSONL path before Pi opens it; inactive mutations are never directed by a browser-supplied path. Attachment paths originate in the server-local upload map and cross only private IPC into Pi's tool context. Pi may persist or echo those paths in its authoritative JSONL transcript, so every public projection redacts them recursively: session titles/previews, user and assistant text/thinking, tool arguments, errors, snapshots, and live message events never expose the server-local path. The daemon maps Pi message lifecycle, deltas, tools, queue changes, model/thinking, compaction, interruption state, and session title updates (`session.updated` on create-with-title, first-prompt auto-title, and rename) to canonical events. Tool events carry redacted input arguments, cumulative partial-output snapshots, final output, error text, renderer metadata (edit diffs, truncation notes), and start/end timestamps. Persisted `toolResult` entries merge into their assistant `toolCall` parts as output/error/end time so hydrated sessions render complete tool cards; tool-result entries never surface as standalone messages. Assistant message projections and start events carry the owning user-message id so the restored turn renderer can group and display replies; all assistant entries in a tool loop remain attached to the latest user turn. Assistant message projections also pass through Pi's per-turn `Usage` (input, output, cacheRead, cacheWrite, totalTokens, and the same five numeric cost fields). The daemon sanitizes the raw payload through `projectUsage` before publication: every numeric must be finite and non-negative, the whole object is omitted when any field is missing or wrong type, and unknown keys are never copied. The `assistant.message.end` event carries the same sanitized usage so the last turn updates without waiting for a full `getSession` refetch. The public route whitelist re-applies the same sanitizer on each projection so a stale or malformed payload from a different daemon version cannot surface as `NaN` or `Infinity` in the reducer.
+- The private core commands are `runtime.health`, `projects.list/select`, `providers.list/config.get/models.set/status/login/login.respond/login.status/logout`, `settings.get/set`, `resources.list/update/prompts.create/prompts.delete`, and session list/create/open/rename/delete/tree/navigate/fork/clone/prompt/steer/followUp/abort/model/thinking/compact operations. Resource lists use opaque IDs and never disclose server paths. Only top-level Pi prompt templates and applicable AGENTS.md sources are editable; package/path resources and skills are browse-only. Resource writes are rejected while a session streams, use an atomic replace, then recreate the idle runtime. Project trust changes are persisted in Pi trust.json and likewise recreate an idle runtime; extensions remain disabled regardless of trust. Provider login submits API keys only across authenticated private IPC or brokers Pi's OAuth/device/manual-code interaction; public projections contain only opaque login IDs, prompts, URLs/device codes, model catalog/configuration, and stable states, never credentials or write-only headers. `providers.models.set` is rejected while a session streams, atomically persists Pi's `models.json`, then rehydrates the idle runtime so the catalog is authoritative immediately. `providers.list` projects only catalog and authentication-status metadata, including Pi-supported `thinkingLevels` (`null` map entries hidden, `xhigh`/`max` opt-in). Session thinking overrides are clamped to the live model's supported levels. `sessions.list` checks each cwd JSONL header (not the full transcript) so a project with large session logs cannot spend tens of seconds on startup. SDK `SessionManager.list` is not used for that path; `listPiSessionJsonlDirectory` reads a header, a bounded prefix for the first user prompt, and a tail for the latest rename. Concurrent lists of the same directory share one in-flight result. Concurrent `sessions.open` of the same id share one in-flight runtime create; a duplicate that finishes later disposes itself and returns the registered runtime instead of `SESSION_RUNTIME_CONFLICT`. Full-file JSONL validation stays on open of a chosen session. The browser explicitly selects an existing user-chosen project directory before listing it; the daemon's startup cwd is an internal fallback, not a user-visible default project. Unnamed persisted sessions use their first prompt as a readable list title when available. `sessions.open` and `getSession` project the last assistant `provider`/`model`/`thinkingLevel` onto the session record so reopening a chat keeps that cache identity. Session selection validates a persisted JSONL path before Pi opens it; inactive mutations are never directed by a browser-supplied path. `sessions.open` resolves an id by Pi's `timestamp_<id>.jsonl` filename first so a missing deep link 404s without listing or fully reading every transcript in every cwd; SDK list and header scan remain the fallback for non-standard names. Directory-wide JSONL checks on list/create/startup are header-only; full-file validation stays on open of a chosen transcript. Attachment paths originate in the server-local upload map and cross only private IPC into Pi's tool context. Pi may persist or echo those paths in its authoritative JSONL transcript, so every public projection redacts them recursively: session titles/previews, user and assistant text/thinking, tool arguments, errors, snapshots, and live message events never expose the server-local path. The daemon maps Pi message lifecycle, deltas, tools, queue changes, model/thinking, compaction, interruption state, and session title updates (`session.updated` on create-with-title, first-prompt auto-title, and rename) to canonical events. Tool events carry redacted input arguments, cumulative partial-output snapshots, final output, error text, renderer metadata (edit diffs, truncation notes), and start/end timestamps. Persisted `toolResult` entries merge into their assistant `toolCall` parts as output/error/end time so hydrated sessions render complete tool cards; tool-result entries never surface as standalone messages. Assistant message projections and start events carry the owning user-message id so the restored turn renderer can group and display replies; all assistant entries in a tool loop remain attached to the latest user turn. Assistant message projections also pass through Pi's per-turn `Usage` (input, output, cacheRead, cacheWrite, totalTokens, and the same five numeric cost fields). The daemon sanitizes the raw payload through `projectUsage` before publication: every numeric must be finite and non-negative, the whole object is omitted when any field is missing or wrong type, and unknown keys are never copied. The `assistant.message.end` event carries the same sanitized usage so the last turn updates without waiting for a full `getSession` refetch. The public route whitelist re-applies the same sanitizer on each projection so a stale or malformed payload from a different daemon version cannot surface as `NaN` or `Infinity` in the reducer.
 - Each event and reconnect snapshot has a monotonic sequence. A reconnect receives a bounded contiguous replay after its cursor when available, otherwise an authoritative `session.snapshot`; unavailable runtimes are not represented as empty sessions.
 - Prompt, steer, and follow-up requests acknowledge acceptance immediately after Pi accepts the call; the daemon owns the still-running send promise and publishes any asynchronous rejection as `session.error`. A later prompt on the same session invalidates that rejection so it cannot error the new turn. If the rejected send left Pi streaming, the daemon aborts it. Steer/follow-up against an idle session starts a new prompt instead of `SESSION_NOT_RUNNING`. Agent completion is never held behind the 30-second public/private request budgets.
 - Registry keys combine the SDK session ID with its cwd. A replacement subscription is rebound to the replacement session so old-session events cannot be published under the new identity. A collision is a visible error; it never replaces or disposes an unrelated runtime.
 - After `agent_settled`, the daemon disposes an idle runtime after five minutes (injectable for tests). Disposal never deletes Pi JSONL; the daemon remembers the selected session file and recreates that runtime on the next private prompt. A new agent start cancels a pending disposal.
 - A startup validation failure writes only a stable failure code to the owner-only non-secret state sidecar. It never records a transcript, session path, or credential. The supervisor surfaces that code as unavailable instead of claiming an empty or idle session.
 - After a forced crash, the next health, request, or subscription probe re-runs supervised startup. Daemon readiness has its own 15-second bounded budget, separate from the shorter lock and shutdown budget, because loading Pi settings and provider/model catalogs can legitimately exceed five seconds. The supervisor removes an existing POSIX socket only when its recorded daemon PID is dead, the endpoint is a socket, and authenticated IPC deterministically refuses or times out. An endpoint that responds, authenticates incorrectly, returns malformed protocol data, or cannot be classified remains `DAEMON_ENDPOINT_UNVERIFIED`.
+- The web server starts warming the supervisor immediately after HTTP listen without awaiting Pi provider/model initialization. A first request arriving during that warmup shares the supervisor's `startPromise`.
 - The daemon owns the runtime after clients disconnect. Disconnecting the web-server client cannot stop active Pi work.
 
 ## Deliberate limits

package/server/lib/pi/session-daemon/daemon-process.js

@@ -1,8 +1,10 @@
 import { readFile, chmod, rename, rm, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import { createSessionDaemon } from './session-daemon.js';
 
+const DAEMON_ENTRYPOINT = fileURLToPath(import.meta.url);
+
 const argument = (name) => {
   const index = process.argv.indexOf(name);
   return index === -1 ? undefined : process.argv[index + 1];
@@ -41,6 +43,7 @@ const writeReadyState = () => writeState({
   protocolVersion: 1,
   pid: process.pid,
   endpoint,
+  entrypoint: DAEMON_ENTRYPOINT,
   startedAt: new Date().toISOString(),
 });
 

package/server/lib/pi/session-daemon/session-daemon.js

@@ -19,7 +19,13 @@ import {
 import { createPiModelConfigStore } from '../model-config-store.js';
 import { clampThinkingLevel, getSupportedThinkingLevels, isPiThinkingLevel } from '../thinking-levels.js';
 import { createSessionRuntimeRegistry } from './runtime-registry.js';
-import { getPiSessionDirectory, validatePiSessionJsonlDirectory, validatePiSessionJsonlFile } from './session-jsonl.js';
+import {
+  findPiSessionJsonlById,
+  getPiSessionDirectory,
+  listPiSessionJsonlDirectory,
+  validatePiSessionJsonlDirectory,
+  validatePiSessionJsonlFile,
+} from './session-jsonl.js';
 
 const PROTOCOL_VERSION = 1;
 const MAX_FRAME_BYTES = 16 * 1024 * 1024;
@@ -80,10 +86,10 @@ export function createSessionDaemon({
   createRuntime = createPiSessionRuntime,
   healthMetadata = {},
   idleTimeoutMs = 5 * 60 * 1_000,
-  listSessions = ({ cwd: sessionCwd, agentDir: sessionAgentDir = agentDir }) => SessionManager.list(
-    sessionCwd,
-    getPiSessionDirectory({ cwd: sessionCwd, agentDir: sessionAgentDir }),
-  ),
+  listSessions = ({ cwd: sessionCwd, agentDir: sessionAgentDir = agentDir }) => listPiSessionJsonlDirectory({
+    cwd: sessionCwd,
+    agentDir: sessionAgentDir,
+  }),
   createSettingsManager = ({ cwd: settingsCwd, agentDir: settingsAgentDir = agentDir, projectTrusted }) => SettingsManager.create(
     settingsCwd,
     settingsAgentDir,
@@ -335,9 +341,8 @@ export function createSessionDaemon({
     idleDisposeTimers.set(sessionId, timer);
   };
 
-  const listSessionItems = async (requestedDirectory) => {
-    const targetDir = requestedDirectory ? await resolveDirectory(requestedDirectory) : (activeDirectory || cwd);
-    await validatePiSessionJsonlDirectory({ cwd: targetDir, agentDir });
+  const listInflightByDirectory = new Map();
+  const listSessionItemsUnshared = async (targetDir) => {
     const sessions = await listSessions({ cwd: targetDir, agentDir });
     if (!Array.isArray(sessions)) {
       throw new SessionDaemonProtocolError('INVALID_SESSION', 'Pi returned an invalid session collection.');
@@ -392,6 +397,17 @@ export function createSessionDaemon({
     });
   };
 
+  const listSessionItems = async (requestedDirectory) => {
+    const targetDir = requestedDirectory ? await resolveDirectory(requestedDirectory) : (activeDirectory || cwd);
+    const inflight = listInflightByDirectory.get(targetDir);
+    if (inflight) return inflight;
+    const pending = listSessionItemsUnshared(targetDir).finally(() => {
+      if (listInflightByDirectory.get(targetDir) === pending) listInflightByDirectory.delete(targetDir);
+    });
+    listInflightByDirectory.set(targetDir, pending);
+    return pending;
+  };
+
   const renameSession = async (payload) => {
     if (!payload || typeof payload !== 'object' || typeof payload.sessionId !== 'string' || payload.sessionId.length === 0
       || typeof payload.title !== 'string' || payload.title.trim().length === 0 || payload.title.length > 256) {
@@ -428,6 +444,21 @@ export function createSessionDaemon({
     if (typeof sessionId !== 'string' || sessionId.length === 0) {
       throw new SessionDaemonProtocolError('INVALID_SESSION', 'The Pi session does not exist.');
     }
+    // Filename identity is enough to 404 a missing id without listing or
+    // fully reading every transcript in every cwd. Deep-linking a stale
+    // `?session=` used to hang here while `validatePiSessionJsonlDirectory`
+    // scanned multi-megabyte JSONL files that cannot be the target.
+    try {
+      const named = await findPiSessionJsonlById({ sessionId, agentDir });
+      if (named?.path && named.cwd) {
+        await validatePiSessionJsonlFile(named.path);
+        const directory = await resolveDirectory(named.cwd);
+        knownDirectories.add(directory);
+        return { target: { id: sessionId, path: named.path }, directory };
+      }
+    } catch {
+      // Fall through to SDK list / header scan for non-standard filenames.
+    }
     const candidateDirs = new Set();
     if (requestedDirectory) {
       try {
@@ -440,7 +471,6 @@ export function createSessionDaemon({
 
     for (const dir of candidateDirs) {
       try {
-        await validatePiSessionJsonlDirectory({ cwd: dir, agentDir });
         const sessions = await listSessions({ cwd: dir, agentDir });
         const target = Array.isArray(sessions) ? sessions.find((session) => session?.id === sessionId) : undefined;
         if (target && typeof target.path === 'string' && target.path.length > 0) {
@@ -492,7 +522,8 @@ export function createSessionDaemon({
     throw new SessionDaemonProtocolError('INVALID_SESSION', 'The Pi session does not exist.');
   };
 
-  const activateSession = async (sessionId, requestedDirectory) => {
+  const activateInflightBySessionId = new Map();
+  const activateSessionUnshared = async (sessionId, requestedDirectory) => {
     if (!runtimeRegistry) {
       runtimeRegistry = createSessionRuntimeRegistry({
         onSessionEvent: ({ cwd: eventCwd, sessionId: eventSessionId }, event) => publishSessionEvent(eventSessionId, event, eventCwd),
@@ -521,16 +552,89 @@ export function createSessionDaemon({
     if (newRuntime.session?.sessionId !== sessionId && typeof newRuntime.switchSession === 'function') {
       await newRuntime.switchSession(target.path);
     }
-    runtimeRegistry.register(newRuntime, { cwd: directory });
+    const raced = runtimeRegistry.findBySessionId(sessionId);
+    if (raced) {
+      try { await newRuntime.dispose?.(); } catch { /* keep the winner */ }
+      runtime = raced;
+      if (raced.cwd) activeDirectory = raced.cwd;
+      return raced;
+    }
+    try {
+      runtimeRegistry.register(newRuntime, { cwd: directory });
+    } catch (error) {
+      if (error?.code === 'SESSION_RUNTIME_CONFLICT') {
+        try { await newRuntime.dispose?.(); } catch { /* keep the winner */ }
+        const winner = runtimeRegistry.findBySessionId(sessionId)
+          || runtimeRegistry.get({ cwd: directory, sessionId });
+        if (winner) {
+          runtime = winner;
+          if (winner.cwd) activeDirectory = winner.cwd;
+          return winner;
+        }
+      }
+      throw error;
+    }
     runtime = newRuntime;
     activeDirectory = directory;
     rememberRuntimeSession();
     return newRuntime;
   };
 
+  const activateSession = async (sessionId, requestedDirectory) => {
+    const inflight = activateInflightBySessionId.get(sessionId);
+    if (inflight) return inflight;
+    const pending = activateSessionUnshared(sessionId, requestedDirectory).finally(() => {
+      if (activateInflightBySessionId.get(sessionId) === pending) activateInflightBySessionId.delete(sessionId);
+    });
+    activateInflightBySessionId.set(sessionId, pending);
+    return pending;
+  };
+
+  const liveProjectionEntries = (session, persisted) => {
+    if (!session?.isStreaming) return persisted;
+    const liveMessages = [];
+    if (Array.isArray(session.messages)) liveMessages.push(...session.messages);
+    const streamingMessage = session.state?.streamingMessage;
+    if (streamingMessage && liveMessages[liveMessages.length - 1] !== streamingMessage) {
+      liveMessages.push(streamingMessage);
+    }
+    if (liveMessages.length === 0) return persisted;
+
+    const persistedKeys = new Set();
+    for (const entry of persisted) {
+      if (entry?.type !== 'message' || !entry.message) continue;
+      const timestamp = typeof entry.message.timestamp === 'number' ? entry.message.timestamp : Date.parse(entry.timestamp);
+      persistedKeys.add(`${entry.message.role}:${Number.isFinite(timestamp) ? timestamp : ''}`);
+    }
+
+    const entries = [...persisted];
+    let liveIndex = 0;
+    const liveAssistantId = streamingMessageIds.get(session.sessionId);
+    for (const message of liveMessages) {
+      if (!message || (message.role !== 'user' && message.role !== 'assistant' && message.role !== 'toolResult')) continue;
+      const timestamp = typeof message.timestamp === 'number' ? message.timestamp : undefined;
+      const key = `${message.role}:${timestamp ?? ''}`;
+      if (timestamp !== undefined && persistedKeys.has(key)) continue;
+      persistedKeys.add(key);
+      const id = message.role === 'assistant' && liveAssistantId
+        ? liveAssistantId
+        : `live-${session.sessionId}-${liveIndex}`;
+      liveIndex += 1;
+      entries.push({
+        type: 'message',
+        id,
+        timestamp: new Date(timestamp || Date.now()).toISOString(),
+        message,
+      });
+    }
+    return entries;
+  };
+
   const projectMessageEntries = (session, targetDir = activeDirectory || cwd) => {
-    const entries = session?.sessionManager?.getEntries?.();
-    if (!Array.isArray(entries)) return [];
+    const persisted = session?.sessionManager?.getEntries?.();
+    const entries = liveProjectionEntries(session, Array.isArray(persisted) ? persisted : []);
+    if (entries.length === 0) return [];
+    const streaming = session?.isStreaming === true;
     const toolResults = new Map();
     for (const entry of entries) {
       if (entry?.type !== 'message' || !entry.message || entry.message.role !== 'toolResult' || typeof entry.message.toolCallId !== 'string') continue;
@@ -563,6 +667,8 @@ export function createSessionDaemon({
         if (part?.type === 'thinking') return [{ type: 'thinking', id: `${entry.id}:thinking:${index}`, index, text: redactAttachmentPaths(part.thinking) }];
         if (part?.type === 'toolCall') {
           const result = toolResults.get(part.id);
+          const running = streaming && !result;
+          const interrupted = !running && !result;
           return [{
             type: 'tool',
             id: `${entry.id}:tool:${part.id}`,
@@ -570,12 +676,20 @@ export function createSessionDaemon({
             toolCallId: part.id,
             name: part.name,
             input: redactAttachmentValues(part.arguments),
-            state: result?.isError ? 'error' : 'completed',
+            state: result?.isError || interrupted ? 'error' : running ? 'running' : 'completed',
             ...(result?.output ? { output: result.output } : {}),
-            ...(result?.error ? { error: result.error } : {}),
-            ...(result?.isError ? { isError: true } : {}),
+            ...(result?.error
+              ? { error: result.error }
+              : interrupted
+                ? { error: 'Tool was interrupted before completion.' }
+                : {}),
+            ...(result?.isError || interrupted ? { isError: true } : {}),
             ...(result?.metadata ? { metadata: result.metadata } : {}),
-            ...(Number.isFinite(result?.endedAt) ? { endedAt: result.endedAt } : {}),
+            ...(Number.isFinite(result?.endedAt)
+              ? { endedAt: result.endedAt }
+              : interrupted
+                ? { endedAt: createdAt }
+                : {}),
           }];
         }
         return [];
@@ -608,6 +722,7 @@ export function createSessionDaemon({
     const sessionModel = lastAssistant?.model
       ?? (model?.provider && model?.id ? { providerId: model.provider, modelId: model.id } : undefined);
     const sessionThinking = lastAssistant?.thinkingLevel || session.thinkingLevel;
+    const isStreaming = session.isStreaming === true;
     return {
       session: {
         id: session.sessionId, directory: targetDir, createdAt, updatedAt: createdAt,
@@ -618,6 +733,8 @@ export function createSessionDaemon({
       },
       messages,
       lastSequence: sequence,
+      isStreaming,
+      lifecycle: isStreaming ? 'busy' : 'idle',
     };
   };
 
@@ -1378,17 +1495,18 @@ export function createSessionDaemon({
   const deleteSession = async (sessionId, requestedDirectory) => {
     const active = runtimeRegistry?.findBySessionId(sessionId);
     let targetDir = requestedDirectory ? await resolveDirectory(requestedDirectory) : active?.cwd || activeDirectory || cwd;
+    const activeSessionFile = active?.session?.sessionManager?.getSessionFile?.();
     if (active) {
       if (active.session?.isStreaming) await active.session.abort();
       await runtimeRegistry?.dispose(active);
       if (runtime === active) runtime = undefined;
     }
-    try {
+    if (active && typeof activeSessionFile === 'string' && activeSessionFile.length > 0) {
+      await rm(activeSessionFile, { force: true });
+    } else if (!active) {
       const { target, directory } = await findPersistedSession(sessionId, targetDir);
       targetDir = directory;
       await rm(target.path, { force: false });
-    } catch (error) {
-      if (!active || error?.code !== 'INVALID_SESSION') throw error;
     }
     publish('session.lifecycle', { state: 'idle', deleted: true }, sessionId, targetDir);
   };

package/server/lib/pi/session-daemon/session-daemon.test.js

@@ -390,6 +390,93 @@ describe('Pi session daemon spike', () => {
     await client.close();
   });
 
+  it('shares an in-flight sessions.list for the same directory', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-share-'));
+    const endpoint = testDaemonEndpoint(root);
+    const agentDir = join(root, 'agent');
+    await mkdir(agentDir, { recursive: true });
+    let calls = 0;
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: root,
+      agentDir,
+      createRuntime: async () => ({ session: new FakeSession(), async dispose() {} }),
+      listSessions: async () => {
+        calls += 1;
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        return [{
+          path: join(root, 'session.jsonl'),
+          id: 'pi-session-1',
+          cwd: root,
+          created: new Date('2026-01-01T00:00:00.000Z'),
+          modified: new Date('2026-01-02T00:00:00.000Z'),
+        }];
+      },
+    });
+    await daemon.start();
+
+    const first = connectClient(endpoint);
+    await first.authenticate();
+    const second = connectClient(endpoint);
+    await second.authenticate();
+    const [left, right] = await Promise.all([
+      first.request('sessions.list', { directory: root }),
+      second.request('sessions.list', { directory: root }),
+    ]);
+    expect(calls).toBe(1);
+    expect(left.result.sessions[0].session.id).toBe('pi-session-1');
+    expect(right.result.sessions[0].session.id).toBe('pi-session-1');
+    await first.close();
+    await second.close();
+  });
+
+  it('shares an in-flight sessions.open for the same session id', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-open-share-'));
+    const endpoint = testDaemonEndpoint(root);
+    const agentDir = join(root, 'agent');
+    await mkdir(agentDir, { recursive: true });
+    const sessionFile = join(root, 'session.jsonl');
+    await writeFile(sessionFile, `{"type":"session","id":"pi-session-1","cwd":${JSON.stringify(root)}}\n`);
+    let calls = 0;
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: root,
+      agentDir,
+      listSessions: async () => [{
+        path: sessionFile,
+        id: 'pi-session-1',
+        cwd: root,
+        created: new Date('2026-01-01T00:00:00.000Z'),
+        modified: new Date('2026-01-02T00:00:00.000Z'),
+      }],
+      createRuntime: async (options) => {
+        calls += 1;
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        return new FakeRuntime({
+          cwd: options.cwd,
+          session: new FakeSession('pi-session-1', options.sessionFile),
+        });
+      },
+    });
+    await daemon.start();
+
+    const first = connectClient(endpoint);
+    await first.authenticate();
+    const second = connectClient(endpoint);
+    await second.authenticate();
+    const [left, right] = await Promise.all([
+      first.request('sessions.open', { sessionId: 'pi-session-1', directory: root }),
+      second.request('sessions.open', { sessionId: 'pi-session-1', directory: root }),
+    ]);
+    expect(calls).toBe(1);
+    expect(left.result.session.id).toBe('pi-session-1');
+    expect(right.result.session.id).toBe('pi-session-1');
+    await first.close();
+    await second.close();
+  });
+
   it('does not include in-memory sessions from another directory when listing a newly selected project directory', async () => {
     const rootA = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-a-'));
     const rootB = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-b-'));
@@ -1198,6 +1285,127 @@ describe('Pi session daemon spike', () => {
     await client.close();
   });
 
+  it('projects unmatched tools as running only while the session is authoritative-busy', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-live-hydrate-'));
+    const endpoint = testDaemonEndpoint(root);
+    const projectDir = join(root, 'project');
+    const agentDir = join(root, 'agent');
+    await mkdir(projectDir, { recursive: true });
+    await mkdir(agentDir, { recursive: true });
+    const session = new FakeSession('pi-session-live');
+    session.isStreaming = true;
+    session.entries = [
+      {
+        type: 'message',
+        id: 'user-1',
+        timestamp: '2026-01-01T00:00:01.000Z',
+        message: { role: 'user', content: 'run it', timestamp: 1_000 },
+      },
+      {
+        type: 'message',
+        id: 'assistant-1',
+        timestamp: '2026-01-01T00:00:01.100Z',
+        message: {
+          role: 'assistant',
+          content: [
+            { type: 'text', text: 'calling bash' },
+            { type: 'toolCall', id: 'tool-live', name: 'bash', arguments: { command: 'ls' } },
+          ],
+          provider: 'test',
+          model: 'model',
+          timestamp: 1_100,
+        },
+      },
+    ];
+    session.messages = [
+      { role: 'user', content: 'run it', timestamp: 1_000 },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'calling bash' },
+          { type: 'toolCall', id: 'tool-live', name: 'bash', arguments: { command: 'ls' } },
+        ],
+        provider: 'test',
+        model: 'model',
+        timestamp: 1_100,
+      },
+    ];
+
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: projectDir,
+      agentDir,
+      createRuntime: async () => ({ session, async dispose() {} }),
+      listSessions: async () => [],
+    });
+    await daemon.start();
+
+    const client = connectClient(endpoint);
+    await client.authenticate();
+    const detail = await client.request('sessions.create', { cwd: projectDir });
+    expect(detail.result.isStreaming).toBe(true);
+    expect(detail.result.lifecycle).toBe('busy');
+    expect(detail.result.messages).toHaveLength(2);
+    expect(detail.result.messages[1].parts).toEqual(expect.arrayContaining([
+      expect.objectContaining({ type: 'text', text: 'calling bash' }),
+      expect.objectContaining({ type: 'tool', name: 'bash', state: 'running', toolCallId: 'tool-live' }),
+    ]));
+
+    session.isStreaming = false;
+    const settled = await client.request('sessions.open', { sessionId: session.sessionId, cwd: projectDir });
+    expect(settled.result.lifecycle).toBe('idle');
+    expect(settled.result.messages[1].parts).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'tool',
+        name: 'bash',
+        state: 'error',
+        toolCallId: 'tool-live',
+        isError: true,
+        error: 'Tool was interrupted before completion.',
+        endedAt: expect.any(Number),
+      }),
+    ]));
+    await client.close();
+  });
+
+  it('overlays an unpersisted live user prompt onto getSession while streaming', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-live-user-'));
+    const endpoint = testDaemonEndpoint(root);
+    const projectDir = join(root, 'project');
+    const agentDir = join(root, 'agent');
+    await mkdir(projectDir, { recursive: true });
+    await mkdir(agentDir, { recursive: true });
+    const session = new FakeSession('pi-session-live-user');
+    session.isStreaming = true;
+    session.entries = [];
+    session.messages = [
+      { role: 'user', content: 'just sent', timestamp: 2_000 },
+    ];
+
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: projectDir,
+      agentDir,
+      createRuntime: async () => ({ session, async dispose() {} }),
+      listSessions: async () => [],
+    });
+    await daemon.start();
+
+    const client = connectClient(endpoint);
+    await client.authenticate();
+    const detail = await client.request('sessions.create', { cwd: projectDir });
+    expect(detail.result.isStreaming).toBe(true);
+    expect(detail.result.lifecycle).toBe('busy');
+    expect(detail.result.messages).toEqual([
+      expect.objectContaining({
+        message: expect.objectContaining({ role: 'user', text: 'just sent' }),
+      }),
+    ]);
+    await client.close();
+  });
+
   it('projects Pi usage in getSession messages and message_end events, omitting malformed payloads', async () => {
     const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-usage-'));
     const endpoint = testDaemonEndpoint(root);