npm - @pi-chamber/web - Versions diffs - 0.2.2 → 0.3.1 - Mend

@pi-chamber/web 0.2.2 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

package/dist/mobile.html CHANGED Viewed

@@ -63,14 +63,14 @@
       })();
     </script>
-    <script type="module" crossorigin src="/assets/mobile-DBkrRt80.js"></script>
+    <script type="module" crossorigin src="/assets/mobile-B_CyfRAX.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-vite-runtime-DD1OZmLC.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-scheduler-7OC5HNn7.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-DYyjh7Q0.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-zustand-CnsBKjP5.js">
-    <link rel="modulepreload" crossorigin href="/assets/index-CH7o4-_q.js">
+    <link rel="modulepreload" crossorigin href="/assets/index-8TL2HlaR.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-katex-CHD9BdDO.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-o4Eea60G.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-riABQmQ_.css">
     <link rel="stylesheet" crossorigin href="/assets/vendor-katex-Cp579UoJ.css">
   </head>
   <body class="h-full bg-background text-foreground">

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@pi-chamber/web",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "private": false,
   "type": "module",
   "repository": {

package/server/lib/package-manager.js CHANGED Viewed

@@ -1,11 +1,8 @@
 import { spawnSync } from 'child_process';
-import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { resolvePiChamberDataDir, resolvePiChamberDataPath } from './pichamber-data-dir.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -40,34 +37,6 @@ function getConfiguredUpdateCheckUrl() {
   return override.length > 0 ? override : null;
 }
-function getPiChamberConfigDir() {
-  // Use the canonical resolver so PICHAMBER_DATA_DIR is honored everywhere.
-  return resolvePiChamberDataDir();
-}
-function sanitizeInstallScope(scope) {
-  if (scope === 'desktop-electron' || scope === 'web' || scope === 'mobile-capacitor') return scope;
-  return 'web';
-}
-function getOrCreateInstallId(scope = 'web') {
-  const configDir = getPiChamberConfigDir();
-  const normalizedScope = sanitizeInstallScope(scope);
-  const idPath = path.join(configDir, `install-id-${normalizedScope}`);
-  try {
-    const existing = fs.readFileSync(idPath, 'utf8').trim();
-    if (existing) return existing;
-  } catch {
-    // Generate new id.
-  }
-  const installId = crypto.randomUUID();
-  fs.mkdirSync(configDir, { recursive: true });
-  fs.writeFileSync(idPath, `${installId}\n`, { encoding: 'utf8', mode: 0o600 });
-  return installId;
-}
 function mapPlatform(value) {
   if (value === 'darwin') return 'macos';
   if (value === 'win32') return 'windows';
@@ -140,7 +109,6 @@ async function checkForUpdatesFromApi(currentVersion, options = {}) {
     const shouldTrustClientPlatform = appType === 'desktop-electron' || appType === 'mobile-capacitor';
     const platform = shouldTrustClientPlatform ? normalizePlatform(options.platform) : hostPlatform;
     const arch = shouldTrustClientPlatform ? normalizeArch(options.arch) : hostArch;
-    const reportUsage = options.reportUsage !== false;
     const payload = {
       appType,
       deviceClass: normalizeDeviceClass(options.deviceClass),
@@ -148,9 +116,7 @@ async function checkForUpdatesFromApi(currentVersion, options = {}) {
       arch,
       channel: 'stable',
       currentVersion,
-      installId: reportUsage ? (options.installId || getOrCreateInstallId(appType)) : undefined,
       instanceMode: options.instanceMode || 'unknown',
-      reportUsage,
     };
     const response = await fetch(updateCheckUrl, {

package/server/lib/pi/routes.js CHANGED Viewed

@@ -135,6 +135,32 @@ const projectUsage = (raw) => {
   };
 };
+const projectRetryInfo = (value) => {
+  if (!value || typeof value !== 'object') return null;
+  return {
+    ...(Number.isSafeInteger(value.attempt) && value.attempt > 0 ? { attempt: value.attempt } : {}),
+    ...(Number.isFinite(value.next) && value.next >= 0 ? { next: value.next } : {}),
+    ...(typeof value.message === 'string' ? { message: value.message } : {}),
+  };
+};
+const sanitizeNavigation = (value) => {
+  if (!value || typeof value !== 'object' || typeof value.targetEntryId !== 'string' || value.targetEntryId.length === 0) return null;
+  const previousLeafId = value.previousLeafId === null ? null : (typeof value.previousLeafId === 'string' ? value.previousLeafId : null);
+  const newLeafId = value.newLeafId === null ? null : (typeof value.newLeafId === 'string' ? value.newLeafId : null);
+  if (previousLeafId !== null && typeof previousLeafId !== 'string') return null;
+  if (newLeafId !== null && typeof newLeafId !== 'string') return null;
+  const editorText = typeof value.editorText === 'string' ? value.editorText : undefined;
+  // Limit editorText defensively; Pi prompts are bounded and we never persist this.
+  if (editorText !== undefined && editorText.length > 200_000) return null;
+  return {
+    targetEntryId: value.targetEntryId,
+    previousLeafId,
+    newLeafId,
+    ...(editorText !== undefined ? { editorText } : {}),
+  };
+};
 const projectSessionDetail = (value) => {
   if (!value || typeof value !== 'object' || !Array.isArray(value.messages) || !Number.isSafeInteger(value.lastSequence)) throw protocolMismatch();
   const messages = value.messages.map((item) => {
@@ -185,12 +211,14 @@ const projectSessionDetail = (value) => {
   const lifecycle = ['idle', 'busy', 'retry', 'error', 'interrupted'].includes(value.lifecycle)
     ? value.lifecycle
     : (isStreaming ? 'busy' : 'idle');
+  const retry = lifecycle === 'retry' ? projectRetryInfo(value.retry) : null;
   return {
     session: projectSession(value.session),
     messages,
     lastSequence: value.lastSequence,
     isStreaming,
     lifecycle,
+    ...(retry ? { retry } : {}),
   };
 };
@@ -341,9 +369,12 @@ const projectEventFrame = (frame) => {
   switch (frame.event) {
     case 'session.snapshot': {
       const snapshot = frame.payload;
+      const lifecycle = ['idle', 'busy', 'retry', 'error', 'interrupted'].includes(snapshot.lifecycle) ? snapshot.lifecycle : 'idle';
+      const retry = lifecycle === 'retry' ? projectRetryInfo(snapshot.retry) : null;
       return { ...common, payload: { snapshot: {
         sessionId, directory, isStreaming: snapshot.isStreaming === true,
-        lifecycle: ['idle', 'busy', 'retry', 'error', 'interrupted'].includes(snapshot.lifecycle) ? snapshot.lifecycle : 'idle',
+        lifecycle,
+        ...(retry ? { retry } : {}),
         queue: { steering: Number.isSafeInteger(snapshot.queue?.steering) ? snapshot.queue.steering : 0, followUp: Number.isSafeInteger(snapshot.queue?.followUp) ? snapshot.queue.followUp : 0 },
         ...(snapshot.model && typeof snapshot.model.providerId === 'string' && typeof snapshot.model.modelId === 'string' ? { model: { providerId: snapshot.model.providerId, modelId: snapshot.model.modelId } } : {}),
         ...(typeof snapshot.thinking === 'string' ? { thinking: snapshot.thinking } : {}),
@@ -352,7 +383,10 @@ const projectEventFrame = (frame) => {
         lastSequence: Number.isSafeInteger(snapshot.lastSequence) ? snapshot.lastSequence : frame.sequence,
       } } };
     }
-    case 'session.lifecycle': return { ...common, payload: { state: frame.payload.state } };
+    case 'session.lifecycle': {
+      const retry = frame.payload.state === 'retry' ? projectRetryInfo(frame.payload) : null;
+      return { ...common, payload: { state: frame.payload.state, ...(retry ?? {}) } };
+    }
     case 'session.updated': {
       if (typeof frame.payload.title !== 'string') return null;
       const title = frame.payload.title.trim();
@@ -369,6 +403,7 @@ const projectEventFrame = (frame) => {
         ...(typeof frame.payload.text === 'string' ? { text: frame.payload.text } : {}),
         ...(typeof frame.payload.thinking === 'string' ? { thinking: frame.payload.thinking } : {}),
         ...(Number.isFinite(frame.payload.durationMs) ? { durationMs: frame.payload.durationMs } : {}),
+        ...(frame.payload.continuing === true ? { continuing: true } : {}),
         ...(frame.payload.error && typeof frame.payload.error.code === 'string'
           ? {
               error: {
@@ -495,7 +530,6 @@ export const registerPiRuntimeRoutes = (app, {
         currentVersion: typeof req.query.currentVersion === 'string' ? req.query.currentVersion : undefined,
         appType: typeof req.query.appType === 'string' ? req.query.appType : undefined,
         platform: typeof req.query.platform === 'string' ? req.query.platform : undefined,
-        reportUsage: req.query.reportUsage === 'true',
       }));
     } catch {
       res.status(503).json({ error: 'Update check unavailable' });
@@ -567,6 +601,16 @@ export const registerPiRuntimeRoutes = (app, {
     }
   });
+  app.post('/api/pi/providers/refresh', async (req, res) => {
+    const directory = typeof req.body?.directory === 'string' && req.body.directory.length > 0 ? req.body.directory : undefined;
+    try {
+      const result = await getDaemonRuntime(getPiSessionDaemonRuntime).request('providers.refresh', directory ? { directory } : undefined);
+      res.json(projectProviders(result));
+    } catch (error) {
+      writeDaemonError(res, error);
+    }
+  });
   app.get('/api/pi/providers/:providerId/config', async (req, res) => {
     const providerId = req.params.providerId;
     if (typeof providerId !== 'string' || providerId.length === 0) {
@@ -891,7 +935,11 @@ export const registerPiRuntimeRoutes = (app, {
   app.post('/api/pi/sessions/:sessionId/navigate', async (req, res) => {
     const result = await requestSessionOperation(req, res, getPiSessionDaemonRuntime, 'sessions.navigate', { messageId: req.body?.messageId });
-    if (result !== undefined) res.json(projectSessionDetail(result));
+    if (result === undefined) return;
+    const detail = projectSessionDetail(result);
+    const navigation = sanitizeNavigation(result.navigation);
+    if (navigation) detail.navigation = navigation;
+    res.json(detail);
   });
   for (const [suffix, command] of [['fork', 'sessions.fork'], ['clone', 'sessions.clone']]) {

package/server/lib/pi/routes.test.js CHANGED Viewed

@@ -443,6 +443,9 @@ describe('Pi runtime route', () => {
         parts: [{ type: 'text', id: 'entry-1:0', index: 0, text: 'hello', privatePath: '/private' }],
       }],
       lastSequence: 9,
+      isStreaming: true,
+      lifecycle: 'retry',
+      retry: { attempt: 2, next: 5_000, message: 'provider request timed out' },
     };
     const runtime = {
       health: async () => ({ state: 'ready', protocolVersion: 1, capabilities: [] }),
@@ -467,8 +470,9 @@ describe('Pi runtime route', () => {
         parts: [{ type: 'text', id: 'entry-1:0', index: 0, text: 'hello' }],
       }],
       lastSequence: 9,
-      isStreaming: false,
-      lifecycle: 'idle',
+      isStreaming: true,
+      lifecycle: 'retry',
+      retry: { attempt: 2, next: 5_000, message: 'provider request timed out' },
     });
     const promptResponse = await fetch(`http://127.0.0.1:${server.address().port}/api/pi/sessions/pi-session-4/prompt`, {
       method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'other', text: 'hello' }),
@@ -539,10 +543,11 @@ describe('Pi runtime route', () => {
     const runtime = {
       health: async () => ({ state: 'ready', protocolVersion: 1, capabilities: [] }),
       subscribe: async ({ onEvent }) => {
-        onEvent({ protocolVersion: 1, kind: 'event', event: 'session.snapshot', sequence: 4, payload: { sessionId: 'pi-session-5', directory: '/workspace', isStreaming: false, lifecycle: 'idle', queue: { steering: 0, followUp: 0 }, lastSequence: 4, endpoint: '/private/socket' } });
+        onEvent({ protocolVersion: 1, kind: 'event', event: 'session.snapshot', sequence: 4, payload: { sessionId: 'pi-session-5', directory: '/workspace', isStreaming: true, lifecycle: 'retry', retry: { attempt: 1, next: 4_000, message: 'provider request timed out' }, queue: { steering: 0, followUp: 0 }, lastSequence: 4, endpoint: '/private/socket' } });
         onEvent({ protocolVersion: 1, kind: 'event', event: 'assistant.message.start', sequence: 5, payload: { sessionId: 'pi-session-5', directory: '/workspace', messageId: 'assistant-1', parentId: 'user-1', role: 'assistant', startedAt: 1 } });
-        onEvent({ protocolVersion: 1, kind: 'event', event: 'assistant.message.end', sequence: 6, payload: { sessionId: 'pi-session-5', directory: '/workspace', messageId: 'assistant-1', durationMs: 42, error: { code: 'ASSISTANT_ERROR', message: 'provider request timed out' } } });
-        onEvent({ protocolVersion: 1, kind: 'event', event: 'session.error', sequence: 7, payload: { sessionId: 'pi-session-5', directory: '/workspace', code: 'ASSISTANT_ERROR', message: 'provider request timed out' } });
+        onEvent({ protocolVersion: 1, kind: 'event', event: 'assistant.message.end', sequence: 6, payload: { sessionId: 'pi-session-5', directory: '/workspace', messageId: 'assistant-1', durationMs: 42, continuing: true, error: { code: 'ASSISTANT_ERROR', message: 'provider request timed out' } } });
+        onEvent({ protocolVersion: 1, kind: 'event', event: 'session.lifecycle', sequence: 7, payload: { sessionId: 'pi-session-5', directory: '/workspace', state: 'retry', attempt: 2, next: 8_000, message: 'provider request timed out' } });
+        onEvent({ protocolVersion: 1, kind: 'event', event: 'session.error', sequence: 8, payload: { sessionId: 'pi-session-5', directory: '/workspace', code: 'ASSISTANT_ERROR', message: 'provider request timed out' } });
         return () => {};
       },
     };
@@ -553,7 +558,7 @@ describe('Pi runtime route', () => {
     const reader = response.body.getReader();
     const first = await reader.read();
     let text = new TextDecoder().decode(first.value);
-    while (!text.includes('"message":"provider request timed out"')) {
+    while (!text.includes('"state":"retry"')) {
       const next = await reader.read();
       if (next.done) break;
       text += new TextDecoder().decode(next.value);
@@ -561,8 +566,11 @@ describe('Pi runtime route', () => {
     await reader.cancel();
     expect(text).toContain('"name":"session.snapshot"');
     expect(text).toContain('"lastSequence":4');
+    expect(text).toContain('"retry":{"attempt":1,"next":4000,"message":"provider request timed out"}');
     expect(text).toContain('"parentId":"user-1"');
     expect(text).toContain('"durationMs":42');
+    expect(text).toContain('"continuing":true');
+    expect(text).toContain('"state":"retry","attempt":2,"next":8000,"message":"provider request timed out"');
     expect(text).toContain('"message":"provider request timed out"');
     expect(text).not.toContain('/private/socket');
   });

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

@@ -25,13 +25,14 @@ This module is the Pi-owned session-daemon foundation. A detached local daemon p
 - 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` 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.
+- 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 and every retry/compaction continuation remain attached to the latest user turn until `agent_settled` closes the run. 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.
+- Live `message_start` events use daemon-generated browser message IDs because Pi has not appended the corresponding session entry yet. Pi agent-core emits streaming assistant starts as shallow copies, not as the finalized object it later persists. At `message_end`, `message-entry-aliases.js` therefore rebinds the synthetic ID to the finalized event object, then maps that object by identity to Pi's appended entry in a microtask. `sessions.navigate` and `sessions.fork` resolve the mapping after stripping any part suffix. Alias keys include cwd and session ID, survive idle runtime disposal, and clear only on explicit session deletion or daemon shutdown. Hydrated message projections continue to use the Pi entry ID directly.
 - 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.
+- 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. Pi retryable provider failures remain live: an `agent_end` with `willRetry` does not publish terminal `session.error`, and `auto_retry_start` projects Pi's attempt, next-attempt time, and redacted error text through `session.lifecycle: retry`. Retry metadata is retained in reconnect and `getSession` snapshots until the next `agent_start` begins the attempt. `agent_settled` remains the authoritative idle boundary after retry success, exhaustion, or cancellation and clears the run's user/assistant ownership.
 - 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`.
+- After a forced crash, the next health, request, or subscription probe re-runs supervised startup. Each private health probe uses the supervisor's five-second operation budget; it must not inherit the general 30-second command timeout and hold every browser request until the browser aborts. Daemon readiness has its own 15-second bounded budget, separate from the shorter probe, 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.

package/server/lib/pi/session-daemon/message-entry-aliases.js ADDED Viewed

@@ -0,0 +1,100 @@
+const scopeKey = (cwd, sessionId) => JSON.stringify([cwd, sessionId]);
+const stripPartSuffix = (messageId) => {
+  const suffixIndex = messageId.indexOf(':');
+  return suffixIndex === -1 ? messageId : messageId.slice(0, suffixIndex);
+};
+const findPersistedMessageEntry = (sessionManager, message) => {
+  const entries = sessionManager?.getEntries?.();
+  if (!Array.isArray(entries)) return undefined;
+  return entries.find((entry) => entry?.type === 'message' && entry.message === message);
+};
+/**
+ * Keeps daemon-published live message ids resolvable after Pi persists those
+ * messages under its own session-entry ids.
+ */
+export function createMessageEntryAliases({ scheduleMicrotask = queueMicrotask } = {}) {
+  const aliasesByScope = new Map();
+  const pendingByMessage = new WeakMap();
+  const getScope = (cwd, sessionId, create = false) => {
+    const key = scopeKey(cwd, sessionId);
+    let scope = aliasesByScope.get(key);
+    if (!scope && create) {
+      scope = new Map();
+      aliasesByScope.set(key, scope);
+    }
+    return scope;
+  };
+  const retain = ({ cwd, sessionId, syntheticMessageId, message }) => {
+    if (typeof cwd !== 'string' || typeof sessionId !== 'string' || typeof syntheticMessageId !== 'string'
+      || !message || typeof message !== 'object') return;
+    const alias = { message };
+    getScope(cwd, sessionId, true).set(syntheticMessageId, alias);
+    pendingByMessage.set(message, { alias });
+  };
+  const releasePersisted = (pending, sessionManager) => {
+    const entry = findPersistedMessageEntry(sessionManager, pending.alias.message);
+    if (!entry || typeof entry.id !== 'string' || entry.id.length === 0) return undefined;
+    pending.alias.entryId = entry.id;
+    delete pending.alias.message;
+    pendingByMessage.delete(entry.message);
+    return entry.id;
+  };
+  return {
+    retain,
+    observeMessageEnd({ cwd, sessionId, syntheticMessageId, message, sessionManager }) {
+      if (typeof syntheticMessageId !== 'string' || !message || typeof message !== 'object') return;
+      const alias = getScope(cwd, sessionId)?.get(syntheticMessageId);
+      if (!alias) return;
+      if (alias.message && alias.message !== message) pendingByMessage.delete(alias.message);
+      alias.message = message;
+      const pending = { alias };
+      pendingByMessage.set(message, pending);
+      scheduleMicrotask(() => {
+        releasePersisted(pending, sessionManager);
+      });
+    },
+    resolve({ cwd, sessionId, requestedId, sessionManager }) {
+      if (typeof requestedId !== 'string' || requestedId.length === 0) return requestedId;
+      const entryId = stripPartSuffix(requestedId);
+      if (sessionManager?.getEntry?.(entryId)) return entryId;
+      const alias = getScope(cwd, sessionId)?.get(entryId);
+      if (!alias) return entryId;
+      if (typeof alias.entryId === 'string' && alias.entryId.length > 0) return alias.entryId;
+      if (alias.message) {
+        const pending = pendingByMessage.get(alias.message);
+        const persistedEntryId = pending ? releasePersisted(pending, sessionManager) : undefined;
+        if (persistedEntryId) return persistedEntryId;
+      }
+      return entryId;
+    },
+    clearSession({ cwd, sessionId }) {
+      const key = scopeKey(cwd, sessionId);
+      const scope = aliasesByScope.get(key);
+      if (!scope) return;
+      for (const alias of scope.values()) {
+        if (alias.message) pendingByMessage.delete(alias.message);
+      }
+      aliasesByScope.delete(key);
+    },
+    clear() {
+      for (const scope of aliasesByScope.values()) {
+        for (const alias of scope.values()) {
+          if (alias.message) pendingByMessage.delete(alias.message);
+        }
+      }
+      aliasesByScope.clear();
+    },
+  };
+}

package/server/lib/pi/session-daemon/runtime-registry.js CHANGED Viewed

@@ -140,6 +140,9 @@ export function createSessionRuntimeRegistry({ onSessionEvent = () => {} } = {})
     register,
     dispose,
     disposeAll,
+    listAll() {
+      return [...recordsByKey.values()].map((record) => record.runtime);
+    },
     get size() {
       return recordsByKey.size;
     },