@pi-chamber/web 0.3.0 → 0.3.1

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

@@ -18,6 +18,7 @@ import {
 
 import { createPiModelConfigStore } from '../model-config-store.js';
 import { clampThinkingLevel, getSupportedThinkingLevels, isPiThinkingLevel } from '../thinking-levels.js';
+import { createMessageEntryAliases } from './message-entry-aliases.js';
 import { createSessionRuntimeRegistry } from './runtime-registry.js';
 import {
   findPiSessionJsonlById,
@@ -136,9 +137,11 @@ export function createSessionDaemon({
   const messageStartedAt = new Map();
   const toolStartedAt = new Map();
   const latestUserMessageIds = new Map();
+  const retryStateBySession = new Map();
   const sendGenerationBySession = new Map();
   const streamingRedactionBuffers = new Map();
   const loginAttempts = new Map();
+  const messageEntryAliases = createMessageEntryAliases();
   const MAX_REPLAY_EVENTS = 1_024;
 
   const validateDirectoryPath = async (dir) => {
@@ -238,6 +241,7 @@ export function createSessionDaemon({
       : getSessionState();
     if (requestedSessionId && requestedSessionId !== session.sessionId) return;
     const activeSession = targetRuntime?.session || runtime?.session;
+    const retry = session.sessionId ? retryStateBySession.get(session.sessionId) : undefined;
     const targetDirectory = targetRuntime?.cwd || activeDirectory || cwd;
     const messages = activeSession ? projectMessageEntries(activeSession, targetDirectory) : [];
     const lastAssistant = [...messages].reverse().find((entry) => entry.message.role === 'assistant')?.message;
@@ -252,7 +256,8 @@ export function createSessionDaemon({
         ...(session.sessionId ? { sessionId: session.sessionId } : {}),
         directory: targetDirectory,
         isStreaming: session.isStreaming ?? false,
-        lifecycle: session.isStreaming ? 'busy' : 'idle',
+        lifecycle: retry ? 'retry' : session.isStreaming ? 'busy' : 'idle',
+        ...(retry ? { retry } : {}),
         queue: activeSession ? {
           steering: activeSession.getSteeringMessages?.().length ?? 0,
           followUp: activeSession.getFollowUpMessages?.().length ?? 0,
@@ -727,6 +732,7 @@ export function createSessionDaemon({
       ?? (model?.provider && model?.id ? { providerId: model.provider, modelId: model.id } : undefined);
     const sessionThinking = lastAssistant?.thinkingLevel || session.thinkingLevel;
     const isStreaming = session.isStreaming === true;
+    const retry = retryStateBySession.get(session.sessionId);
     return {
       session: {
         id: session.sessionId, directory: targetDir, createdAt, updatedAt: createdAt,
@@ -738,7 +744,8 @@ export function createSessionDaemon({
       messages,
       lastSequence: sequence,
       isStreaming,
-      lifecycle: isStreaming ? 'busy' : 'idle',
+      lifecycle: retry ? 'retry' : isStreaming ? 'busy' : 'idle',
+      ...(retry ? { retry } : {}),
     };
   };
 
@@ -1602,6 +1609,10 @@ export function createSessionDaemon({
       targetDir = directory;
       await rm(target.path, { force: false });
     }
+    messageEntryAliases.clearSession({ cwd: active?.cwd || targetDir, sessionId });
+    retryStateBySession.delete(sessionId);
+    latestUserMessageIds.delete(sessionId);
+    latestAssistantMessageIds.delete(sessionId);
     publish('session.lifecycle', { state: 'idle', deleted: true }, sessionId, targetDir);
   };
 
@@ -1616,6 +1627,7 @@ export function createSessionDaemon({
               ? content.filter((part) => part?.type === 'text').map((part) => part.text).join('')
               : '');
           const messageId = `user-${sessionId}-${sequence + 1}`;
+          messageEntryAliases.retain({ cwd: directory, sessionId, syntheticMessageId: messageId, message: event.message });
           latestUserMessageIds.set(sessionId, messageId);
           publish('assistant.message.start', {
             messageId,
@@ -1625,6 +1637,7 @@ export function createSessionDaemon({
           }, sessionId, directory);
         } else if (event.message?.role === 'assistant') {
           const messageId = `assistant-${sessionId}-${sequence + 1}`;
+          messageEntryAliases.retain({ cwd: directory, sessionId, syntheticMessageId: messageId, message: event.message });
           clearStreamingRedactionBuffers(sessionId);
           streamingMessageIds.set(sessionId, messageId);
           latestAssistantMessageIds.set(sessionId, messageId);
@@ -1653,6 +1666,19 @@ export function createSessionDaemon({
         break;
       }
       case 'message_end': {
+        const eventRuntime = runtimeRegistry?.get({ cwd: directory, sessionId });
+        const syntheticMessageId = event.message?.role === 'assistant'
+          ? streamingMessageIds.get(sessionId) ?? latestAssistantMessageIds.get(sessionId)
+          : event.message?.role === 'user'
+            ? latestUserMessageIds.get(sessionId)
+            : undefined;
+        messageEntryAliases.observeMessageEnd({
+          cwd: directory,
+          sessionId,
+          syntheticMessageId,
+          message: event.message,
+          sessionManager: eventRuntime?.session?.sessionManager,
+        });
         if (event.message?.role === 'assistant') {
           const content = Array.isArray(event.message.content) ? event.message.content : [];
           const messageId = streamingMessageIds.get(sessionId) ?? latestAssistantMessageIds.get(sessionId) ?? `assistant-${sessionId}`;
@@ -1665,6 +1691,7 @@ export function createSessionDaemon({
             text: redactAttachmentPaths(content.filter((part) => part?.type === 'text').map((part) => part.text).join('')),
             thinking: redactAttachmentPaths(content.filter((part) => part?.type === 'thinking').map((part) => part.thinking).join('')),
             durationMs,
+            ...(content.some((part) => part?.type === 'toolCall') ? { continuing: true } : {}),
             ...(event.message.errorMessage ? { error: { code: 'ASSISTANT_ERROR', message: redactAttachmentPaths(event.message.errorMessage) } } : {}),
             ...(usage ? { usage } : {}),
           }, sessionId, directory);
@@ -1728,11 +1755,10 @@ export function createSessionDaemon({
         break;
       case 'agent_start':
         clearIdleDisposal(sessionId);
+        retryStateBySession.delete(sessionId);
         publish('session.lifecycle', { state: 'busy' }, sessionId, directory);
         break;
       case 'agent_end': {
-        latestUserMessageIds.delete(sessionId);
-        latestAssistantMessageIds.delete(sessionId);
         const finalMessage = event.messages?.at?.(-1);
         if (finalMessage?.role === 'assistant' && finalMessage.stopReason === 'aborted') {
           publish('session.interrupted', { reason: 'user-abort', streaming: false }, sessionId, directory);
@@ -1741,15 +1767,23 @@ export function createSessionDaemon({
         }
         break;
       }
-      case 'auto_retry_start':
-        publish('session.lifecycle', {
-          state: 'retry',
+      case 'auto_retry_start': {
+        const retry = {
           attempt: event.attempt,
           next: Date.now() + event.delayMs,
           message: redactAttachmentPaths(event.errorMessage),
-        }, sessionId, directory);
+        };
+        retryStateBySession.set(sessionId, retry);
+        publish('session.lifecycle', { state: 'retry', ...retry }, sessionId, directory);
+        break;
+      }
+      case 'auto_retry_end':
+        retryStateBySession.delete(sessionId);
         break;
       case 'agent_settled':
+        retryStateBySession.delete(sessionId);
+        latestUserMessageIds.delete(sessionId);
+        latestAssistantMessageIds.delete(sessionId);
         publish('session.lifecycle', { state: 'idle' }, sessionId, directory);
         scheduleIdleDisposal(sessionId);
         break;
@@ -1924,35 +1958,16 @@ export function createSessionDaemon({
       }
       case 'sessions.navigate': {
         const activeRuntime = await activateSession(message.payload?.sessionId, message.payload?.directory || message.payload?.cwd);
-        let messageId = message.payload?.messageId;
-        if (typeof messageId !== 'string' || messageId.length === 0) throw new SessionDaemonProtocolError('INVALID_ARGUMENT', 'The requested tree entry is invalid.');
-        // UI may pass a part id like "c865141a:text:1" (e.g. from a tool block).
-        // Pi only knows entry ids, so strip the suffix and retry the entry lookup.
-        const tryIds = [messageId];
-        if (messageId.includes(':')) {
-          const entryId = messageId.split(':')[0];
-          if (entryId && entryId !== messageId) tryIds.unshift(entryId);
-        }
+        const requestedId = message.payload?.messageId;
+        if (typeof requestedId !== 'string' || requestedId.length === 0) throw new SessionDaemonProtocolError('INVALID_ARGUMENT', 'The requested tree entry is invalid.');
+        const messageId = messageEntryAliases.resolve({
+          cwd: activeRuntime.cwd,
+          sessionId: message.payload.sessionId,
+          requestedId,
+          sessionManager: activeRuntime.session.sessionManager,
+        });
         const previousLeafId = activeRuntime.session.sessionManager?.getLeafId?.() ?? null;
-        let result;
-        let lastError;
-        for (const tryId of tryIds) {
-          try {
-            result = await activeRuntime.session.navigateTree(tryId);
-            messageId = tryId;
-            lastError = undefined;
-            break;
-          } catch (error) {
-            lastError = error;
-            // Only retry on "Entry not found" with a stripped id; otherwise surface immediately.
-            const isEntryNotFound = String(error?.message ?? '').includes('not found');
-            if (!isEntryNotFound || tryId === tryIds[tryIds.length - 1]) {
-              console.error(`[pi:navigate] target=${tryId} leaf=${previousLeafId} branch=${activeRuntime.session.sessionManager?.getBranch?.()?.map((e) => e.id).join(',') ?? 'unknown'} error=${error?.message ?? String(error)}`);
-              throw error;
-            }
-          }
-        }
-        if (lastError) throw lastError;
+        const result = await activeRuntime.session.navigateTree(messageId);
         if (result?.cancelled) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'Pi cancelled tree navigation.');
         const newLeafId = activeRuntime.session.sessionManager?.getLeafId?.() ?? null;
         const navigation = {
@@ -1967,8 +1982,16 @@ export function createSessionDaemon({
       case 'sessions.fork':
       case 'sessions.clone': {
         const activeRuntime = await activateSession(message.payload?.sessionId, message.payload?.directory || message.payload?.cwd);
-        const entryId = message.command === 'sessions.fork' ? message.payload?.messageId : activeRuntime.session.sessionManager?.getLeafId?.();
-        if (typeof entryId !== 'string' || entryId.length === 0) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'The Pi session has no fork point.');
+        const requestedId = message.command === 'sessions.fork' ? message.payload?.messageId : activeRuntime.session.sessionManager?.getLeafId?.();
+        if (typeof requestedId !== 'string' || requestedId.length === 0) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'The Pi session has no fork point.');
+        const entryId = message.command === 'sessions.fork'
+          ? messageEntryAliases.resolve({
+            cwd: activeRuntime.cwd,
+            sessionId: message.payload.sessionId,
+            requestedId,
+            sessionManager: activeRuntime.session.sessionManager,
+          })
+          : requestedId;
         const result = await activeRuntime.fork(entryId, { position: 'at' });
         if (result.cancelled) throw new SessionDaemonProtocolError('SESSION_CREATE_CANCELLED', 'Pi cancelled session creation.');
         rememberRuntimeSession();
@@ -2136,6 +2159,7 @@ export function createSessionDaemon({
         if (platform !== 'win32') await chmod(endpoint, 0o600);
         started = true;
       } catch (error) {
+        messageEntryAliases.clear();
         await disposeRuntime();
         server = undefined;
         throw error;
@@ -2149,8 +2173,12 @@ export function createSessionDaemon({
         clearTimeout(attempt.expiry);
       }
       loginAttempts.clear();
+      retryStateBySession.clear();
+      latestUserMessageIds.clear();
+      latestAssistantMessageIds.clear();
       for (const client of clients) client.destroy();
       clients.clear();
+      messageEntryAliases.clear();
       await new Promise((resolve, reject) => {
         server.close((error) => error ? reject(error) : resolve());
       });

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

@@ -6,6 +6,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
 
+import { createMessageEntryAliases } from './message-entry-aliases.js';
 import { createSessionDaemon, isLocalSessionDaemonEndpoint } from './session-daemon.js';
 
 const credential = 'a-private-daemon-credential';
@@ -42,6 +43,7 @@ class FakeSession {
       getSessionFile: () => sessionFile,
       getHeader: () => ({ timestamp: '2026-01-01T00:00:00.000Z' }),
       getEntries: () => this.entries,
+      getEntry: (id) => this.entries.find((entry) => entry.id === id),
       getLeafId: () => 'fake-entry',
       getTree: () => [{ entry: { id: 'fake-entry', parentId: undefined, timestamp: '2026-01-01T00:00:00.000Z' }, children: [] }],
       appendSessionInfo: (name) => this.names.push(name),
@@ -315,6 +317,59 @@ describe('Pi session daemon spike', () => {
     await stale.close();
   });
 
+  it('keeps existing and late-joining device streams independent during one turn', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-multi-client-'));
+    const endpoint = testDaemonEndpoint(root);
+    const session = new FakeSession();
+    session.isStreaming = true;
+    session.messages = [{
+      role: 'assistant',
+      content: [{ type: 'text', text: 'half' }],
+      provider: 'test',
+      model: 'model',
+      timestamp: 1_000,
+    }];
+    daemon = createSessionDaemon({ endpoint, credential, cwd: root, createRuntime: async () => ({ session, async dispose() {} }) });
+    await daemon.start();
+
+    const first = connectClient(endpoint);
+    await first.authenticate();
+    await first.request('sessions.create', { cwd: root });
+    const detail = await first.request('sessions.open', { sessionId: 'pi-session-1', cwd: root });
+    expect(detail.result).toMatchObject({
+      isStreaming: true,
+      lifecycle: 'busy',
+      lastSequence: expect.any(Number),
+      messages: [expect.objectContaining({ parts: [expect.objectContaining({ text: 'half' })] })],
+    });
+
+    const late = connectClient(endpoint);
+    await late.authenticate(credential, {
+      sessionId: 'pi-session-1',
+      fromSequence: detail.result.lastSequence,
+    });
+    const firstDelta = first.next((frame) => frame.event === 'assistant.message.delta');
+    const lateDelta = late.next((frame) => frame.event === 'assistant.message.delta');
+    session.emit({
+      type: 'message_update',
+      assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: ' plus the rest' },
+    });
+    const [firstDeltaFrame, lateDeltaFrame] = await Promise.all([firstDelta, lateDelta]);
+    expect(firstDeltaFrame.sequence).toBe(lateDeltaFrame.sequence);
+    expect(lateDeltaFrame.payload.delta).toBe(' plus the rest');
+
+    const firstIdle = first.next((frame) => frame.event === 'session.lifecycle' && frame.payload?.state === 'idle');
+    const lateIdle = late.next((frame) => frame.event === 'session.lifecycle' && frame.payload?.state === 'idle');
+    session.isStreaming = false;
+    session.emit({ type: 'agent_settled' });
+    const [firstIdleFrame, lateIdleFrame] = await Promise.all([firstIdle, lateIdle]);
+    expect(firstIdleFrame.sequence).toBe(lateIdleFrame.sequence);
+    expect(firstIdleFrame.sequence).toBeGreaterThan(firstDeltaFrame.sequence);
+
+    await late.close();
+    await first.close();
+  });
+
   it('lists only validated cwd-scoped sessions without exposing Pi JSONL paths', async () => {
     const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-'));
     const endpoint = testDaemonEndpoint(root);
@@ -611,6 +666,174 @@ describe('Pi session daemon spike', () => {
     await client.close();
   });
 
+  it('resolves live message ids to Pi entry ids for navigation and forking', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-message-alias-'));
+    const endpoint = testDaemonEndpoint(root);
+    const sessionFile = join(root, 'fixture.jsonl');
+    await writeFile(sessionFile, `${JSON.stringify({ type: 'session', id: 'fixture-session', cwd: root, timestamp: '2026-01-01T00:00:00.000Z' })}\n`);
+    const session = new FakeSession('fixture-session', sessionFile);
+    const hydratedMessage = { role: 'user', timestamp: 1, content: 'm3' };
+    session.entries.push({ type: 'message', id: 'm3-entry', parentId: null, timestamp: '2026-01-01T00:00:01.000Z', message: hydratedMessage });
+    const navigated = [];
+    session.navigateTree = async (entryId) => {
+      if (!session.sessionManager.getEntry(entryId)) throw new Error(`Entry ${entryId} not found`);
+      navigated.push(entryId);
+      return { cancelled: false };
+    };
+    const forked = [];
+    const runtime = new FakeRuntime({ cwd: root, session });
+    runtime.fork = async (entryId) => {
+      if (!session.sessionManager.getEntry(entryId)) throw new Error('Invalid entry ID for forking');
+      forked.push(entryId);
+      return { cancelled: false };
+    };
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: root,
+      createRuntime: async () => runtime,
+      listSessions: async () => [{ path: sessionFile, id: 'fixture-session', cwd: root }],
+    });
+    await daemon.start();
+
+    const client = connectClient(endpoint);
+    await client.authenticate();
+    await client.request('sessions.open', { sessionId: 'fixture-session', directory: root });
+
+    await expect(client.request('sessions.navigate', { sessionId: 'fixture-session', directory: root, messageId: 'm3-entry' })).resolves.toMatchObject({
+      result: { navigation: { targetEntryId: 'm3-entry' } },
+    });
+
+    const replacementUser = { role: 'user', timestamp: 2, content: 'm4 replacement' };
+    const userStartPromise = client.next((frame) => frame.event === 'assistant.message.start' && frame.payload?.role === 'user' && frame.payload?.text === 'm4 replacement');
+    session.emit({ type: 'message_start', message: replacementUser });
+    session.emit({ type: 'message_end', message: replacementUser });
+    session.entries.push({ type: 'message', id: 'm4-rev-entry', parentId: 'm3-entry', timestamp: '2026-01-01T00:00:02.000Z', message: replacementUser });
+    const publishedUserId = (await userStartPromise).payload.messageId;
+    await Promise.resolve();
+
+    await expect(client.request('sessions.navigate', { sessionId: 'fixture-session', directory: root, messageId: publishedUserId })).resolves.toMatchObject({
+      result: { navigation: { targetEntryId: 'm4-rev-entry' } },
+    });
+    await expect(client.request('sessions.fork', { sessionId: 'fixture-session', directory: root, messageId: publishedUserId })).resolves.toMatchObject({ result: expect.any(Object) });
+
+    // Pi agent-core shallow-copies the streaming start; message_end carries
+    // the distinct finalized object that SessionManager persists.
+    const assistantStartMessage = { role: 'assistant', timestamp: 3, provider: 'test', model: 'model', content: [] };
+    const replacementAssistant = { role: 'assistant', timestamp: 3, provider: 'test', model: 'model', content: [{ type: 'text', text: 'replacement answer' }] };
+    const assistantStartPromise = client.next((frame) => frame.event === 'assistant.message.start' && frame.payload?.role === 'assistant');
+    session.emit({ type: 'message_start', message: assistantStartMessage });
+    session.emit({ type: 'message_end', message: replacementAssistant });
+    session.entries.push({ type: 'message', id: 'm4-assistant-entry', parentId: 'm4-rev-entry', timestamp: '2026-01-01T00:00:03.000Z', message: replacementAssistant });
+    const publishedAssistantId = (await assistantStartPromise).payload.messageId;
+    await Promise.resolve();
+
+    await expect(client.request('sessions.navigate', {
+      sessionId: 'fixture-session',
+      directory: root,
+      messageId: `${publishedAssistantId}:text:0`,
+    })).resolves.toMatchObject({ result: { navigation: { targetEntryId: 'm4-assistant-entry' } } });
+    await expect(client.request('sessions.fork', {
+      sessionId: 'fixture-session',
+      directory: root,
+      messageId: `${publishedAssistantId}:text:0`,
+    })).resolves.toMatchObject({ result: expect.any(Object) });
+
+    expect(navigated).toEqual(['m3-entry', 'm4-rev-entry', 'm4-assistant-entry']);
+    expect(forked).toEqual(['m4-rev-entry', 'm4-assistant-entry']);
+    await expect(client.request('sessions.fork', {
+      sessionId: 'fixture-session',
+      directory: root,
+      messageId: 'user-fixture-session-unknown',
+    })).rejects.toThrow('Daemon connection closed');
+
+    const navigationClient = connectClient(endpoint);
+    await navigationClient.authenticate();
+    await expect(navigationClient.request('sessions.navigate', {
+      sessionId: 'fixture-session',
+      directory: root,
+      messageId: 'user-fixture-session-unknown',
+    })).rejects.toThrow('Daemon connection closed');
+  });
+
+  it('keeps live message aliases across idle disposal and runtime reopening', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-message-alias-idle-'));
+    const endpoint = testDaemonEndpoint(root);
+    const sessionFile = join(root, 'fixture.jsonl');
+    await writeFile(sessionFile, `${JSON.stringify({ type: 'session', id: 'fixture-session', cwd: root, timestamp: '2026-01-01T00:00:00.000Z' })}\n`);
+    const liveMessage = { role: 'user', timestamp: 1, content: 'persist me' };
+    const persistedEntry = { type: 'message', id: 'persisted-entry', parentId: null, timestamp: '2026-01-01T00:00:01.000Z', message: liveMessage };
+    const firstSession = new FakeSession('fixture-session', sessionFile);
+    const firstRuntime = new FakeRuntime({ cwd: root, session: firstSession });
+    const reopenedSession = new FakeSession('fixture-session', sessionFile);
+    reopenedSession.entries.push({ ...persistedEntry, message: { ...liveMessage } });
+    reopenedSession.navigateTree = async (entryId) => {
+      if (!reopenedSession.sessionManager.getEntry(entryId)) throw new Error(`Entry ${entryId} not found`);
+      reopenedSession.navigatedTo = entryId;
+      return { cancelled: false };
+    };
+    const reopenedRuntime = new FakeRuntime({ cwd: root, session: reopenedSession });
+    let runtimeCount = 0;
+    daemon = createSessionDaemon({
+      endpoint,
+      credential,
+      cwd: root,
+      idleTimeoutMs: 10,
+      listSessions: async () => [{ path: sessionFile, id: 'fixture-session', cwd: root }],
+      createRuntime: async () => (++runtimeCount === 1 ? firstRuntime : reopenedRuntime),
+    });
+    await daemon.start();
+
+    const client = connectClient(endpoint);
+    await client.authenticate();
+    await client.request('sessions.open', { sessionId: 'fixture-session', directory: root });
+    const userStartPromise = client.next((frame) => frame.event === 'assistant.message.start' && frame.payload?.role === 'user');
+    firstSession.emit({ type: 'message_start', message: liveMessage });
+    firstSession.emit({ type: 'message_end', message: liveMessage });
+    firstSession.entries.push(persistedEntry);
+    const publishedId = (await userStartPromise).payload.messageId;
+    await Promise.resolve();
+    firstSession.emit({ type: 'agent_settled' });
+    await new Promise((resolve) => setTimeout(resolve, 30));
+    expect(firstRuntime.disposed).toBe(true);
+
+    await expect(client.request('sessions.navigate', {
+      sessionId: 'fixture-session',
+      directory: root,
+      messageId: publishedId,
+    })).resolves.toMatchObject({ result: { navigation: { targetEntryId: 'persisted-entry' } } });
+    expect(reopenedSession.navigatedTo).toBe('persisted-entry');
+    await client.close();
+  });
+
+  it('scopes live message aliases by directory and session id', () => {
+    const aliases = createMessageEntryAliases({ scheduleMicrotask: (callback) => callback() });
+    const messageA = { role: 'user', content: 'same' };
+    const messageB = { role: 'user', content: 'same' };
+    const managerA = {
+      getEntry: () => undefined,
+      getEntries: () => [{ type: 'message', id: 'entry-a', message: messageA }],
+    };
+    const managerB = {
+      getEntry: () => undefined,
+      getEntries: () => [{ type: 'message', id: 'entry-b', message: messageB }],
+    };
+    aliases.retain({ cwd: '/project-a', sessionId: 'same-session', syntheticMessageId: 'user-same-session-1', message: messageA });
+    aliases.retain({ cwd: '/project-b', sessionId: 'same-session', syntheticMessageId: 'user-same-session-1', message: messageB });
+    aliases.observeMessageEnd({ cwd: '/project-a', sessionId: 'same-session', syntheticMessageId: 'user-same-session-1', message: messageA, sessionManager: managerA });
+    aliases.observeMessageEnd({ cwd: '/project-b', sessionId: 'same-session', syntheticMessageId: 'user-same-session-1', message: messageB, sessionManager: managerB });
+
+    expect(aliases.resolve({ cwd: '/project-a', sessionId: 'same-session', requestedId: 'user-same-session-1', sessionManager: managerA })).toBe('entry-a');
+    expect(aliases.resolve({ cwd: '/project-b', sessionId: 'same-session', requestedId: 'user-same-session-1:text:0', sessionManager: managerB })).toBe('entry-b');
+    expect(aliases.resolve({ cwd: '/project-a', sessionId: 'same-session', requestedId: 'user-same-session-unknown', sessionManager: managerA })).toBe('user-same-session-unknown');
+
+    aliases.clearSession({ cwd: '/project-a', sessionId: 'same-session' });
+    expect(aliases.resolve({ cwd: '/project-a', sessionId: 'same-session', requestedId: 'user-same-session-1', sessionManager: managerA })).toBe('user-same-session-1');
+    expect(aliases.resolve({ cwd: '/project-b', sessionId: 'same-session', requestedId: 'user-same-session-1', sessionManager: managerB })).toBe('entry-b');
+    aliases.clear();
+    expect(aliases.resolve({ cwd: '/project-b', sessionId: 'same-session', requestedId: 'user-same-session-1:text:0', sessionManager: managerB })).toBe('user-same-session-1');
+  });
+
   it('disposes an idle runtime without deleting its Pi JSONL and restores it on demand', async () => {
     const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-'));
     const endpoint = testDaemonEndpoint(root);
@@ -971,7 +1194,7 @@ describe('Pi session daemon spike', () => {
     await client.close();
   });
 
-  it('keeps retryable provider failures in retry lifecycle until Pi exhausts retry', async () => {
+  it('keeps retry attempts attached to the original user turn until Pi settles', async () => {
     const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-retry-'));
     const endpoint = testDaemonEndpoint(root);
     const session = new FakeSession('pi-session-retry');
@@ -981,6 +1204,15 @@ describe('Pi session daemon spike', () => {
     await client.authenticate();
     await client.request('sessions.create', { cwd: root });
 
+    const userStartPromise = client.next((frame) => frame.event === 'assistant.message.start' && frame.payload?.role === 'user');
+    session.emit({ type: 'message_start', message: { role: 'user', content: 'recover this turn', timestamp: 1_000 } });
+    const userStart = await userStartPromise;
+
+    const failedStartPromise = client.next((frame) => frame.event === 'assistant.message.start' && frame.payload?.role === 'assistant');
+    session.emit({ type: 'message_start', message: { role: 'assistant', content: [], timestamp: 1_100 } });
+    const failedStart = await failedStartPromise;
+    session.emit({ type: 'message_end', message: { role: 'assistant', content: [], stopReason: 'error', errorMessage: 'Rate limit exceeded' } });
+
     const retryLifecycle = client.next((frame) => frame.event === 'session.lifecycle' && frame.payload.state === 'retry');
     const prematureError = client.next((frame) => frame.event === 'session.error');
     session.emit({ type: 'agent_end', willRetry: true, messages: [{ role: 'assistant', stopReason: 'error', errorMessage: 'Rate limit exceeded' }] });
@@ -989,11 +1221,35 @@ describe('Pi session daemon spike', () => {
     await expect(retryLifecycle).resolves.toMatchObject({
       payload: { state: 'retry', attempt: 1, message: 'Rate limit exceeded' },
     });
+
+    const retryObserver = connectClient(endpoint);
+    const retrySnapshot = await retryObserver.authenticate();
+    expect(retrySnapshot.payload).toMatchObject({
+      lifecycle: 'retry',
+      retry: { attempt: 1, message: 'Rate limit exceeded' },
+    });
+
+    session.emit({ type: 'agent_start' });
+    const recoveredStartPromise = client.next((frame) => frame.event === 'assistant.message.start'
+      && frame.payload?.role === 'assistant'
+      && frame.payload.messageId !== failedStart.payload.messageId);
+    session.emit({ type: 'message_start', message: { role: 'assistant', content: [], timestamp: 1_200 } });
+    const recoveredStart = await recoveredStartPromise;
+    const recoveredDeltaPromise = client.next((frame) => frame.event === 'assistant.message.delta'
+      && frame.payload?.messageId === recoveredStart.payload.messageId);
+    session.emit({ type: 'message_update', assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: 'Recovered' } });
+
+    await expect(recoveredDeltaPromise).resolves.toMatchObject({ payload: { delta: 'Recovered' } });
+    expect(failedStart.payload.parentId).toBe(userStart.payload.messageId);
+    expect(recoveredStart.payload.parentId).toBe(userStart.payload.messageId);
     await expect(prematureError).rejects.toThrow(/Timed out/);
+
+    session.emit({ type: 'agent_settled' });
+    await retryObserver.close();
     await client.close();
   });
 
-  it('preserves assistant messageId for tool executions occurring after message_end', async () => {
+  it('keeps ordinary tool errors live and resumes the next assistant in the same user turn', async () => {
     const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-'));
     const endpoint = testDaemonEndpoint(root);
     const session = new FakeSession('pi-session-tool-seq');
@@ -1003,16 +1259,28 @@ describe('Pi session daemon spike', () => {
     await client.authenticate();
     await client.request('sessions.create', { cwd: root });
 
-    const messageStartPromise = client.next((frame) => frame.event === 'assistant.message.start');
+    const userStartPromise = client.next((frame) => frame.event === 'assistant.message.start' && frame.payload?.role === 'user');
+    const messageStartPromise = client.next((frame) => frame.event === 'assistant.message.start' && frame.payload?.role === 'assistant');
     const messageEndPromise = client.next((frame) => frame.event === 'assistant.message.end');
     const toolStartPromise = client.next((frame) => frame.event === 'session.tool.start');
     const toolEndPromise = client.next((frame) => frame.event === 'session.tool.end');
 
+    session.emit({ type: 'message_start', message: { role: 'user', content: 'run the command', timestamp: 0 } });
     session.emit({ type: 'message_start', message: { role: 'assistant', timestamp: 1 } });
-    session.emit({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: 'Calling tool' }] } });
+    session.emit({
+      type: 'message_end',
+      message: {
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'Calling tool' },
+          { type: 'toolCall', id: 'tool-call-1', name: 'bash', arguments: { command: 'echo hi' } },
+        ],
+      },
+    });
     session.emit({ type: 'tool_execution_start', toolCallId: 'tool-call-1', toolName: 'bash', args: { command: 'echo hi' } });
-    session.emit({ type: 'tool_execution_end', toolCallId: 'tool-call-1', toolName: 'bash', result: { content: [{ type: 'text', text: 'hi' }] }, isError: false });
+    session.emit({ type: 'tool_execution_end', toolCallId: 'tool-call-1', toolName: 'bash', result: { content: [{ type: 'text', text: 'command failed' }] }, isError: true });
 
+    const userStart = await userStartPromise;
     const messageStart = await messageStartPromise;
     const messageEnd = await messageEndPromise;
     const toolStart = await toolStartPromise;
@@ -1020,11 +1288,26 @@ describe('Pi session daemon spike', () => {
 
     expect(messageStart.payload.messageId).toMatch(/^assistant-pi-session-tool-seq-\d+$/);
     expect(messageEnd.payload.messageId).toBe(messageStart.payload.messageId);
+    expect(messageEnd.payload.continuing).toBe(true);
     expect(toolStart.payload.messageId).toBe(messageStart.payload.messageId);
     expect(toolStart.payload.partId).toBe(`${messageStart.payload.messageId}:tool:tool-call-1`);
     expect(toolEnd.payload.messageId).toBe(messageStart.payload.messageId);
     expect(toolEnd.payload.partId).toBe(`${messageStart.payload.messageId}:tool:tool-call-1`);
-
+    expect(toolEnd.payload).toMatchObject({ state: 'error', isError: true, error: 'command failed' });
+
+    const recoveredStartPromise = client.next((frame) => frame.event === 'assistant.message.start'
+      && frame.payload?.role === 'assistant'
+      && frame.payload.messageId !== messageStart.payload.messageId);
+    session.emit({ type: 'message_start', message: { role: 'assistant', timestamp: 2 } });
+    const recoveredStart = await recoveredStartPromise;
+    const recoveredDeltaPromise = client.next((frame) => frame.event === 'assistant.message.delta'
+      && frame.payload?.messageId === recoveredStart.payload.messageId);
+    session.emit({ type: 'message_update', assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: 'Recovered from tool failure' } });
+
+    await expect(recoveredDeltaPromise).resolves.toMatchObject({ payload: { delta: 'Recovered from tool failure' } });
+    expect(messageStart.payload.parentId).toBe(userStart.payload.messageId);
+    expect(recoveredStart.payload.parentId).toBe(userStart.payload.messageId);
+    session.emit({ type: 'agent_settled' });
     await client.close();
   });
 

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

@@ -24,6 +24,20 @@ class PiSessionDaemonUnavailableError extends Error {
 
 const delay = (milliseconds) => new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
 
+const rejectAfter = (promise, timeoutMs, code) => new Promise((resolvePromise, rejectPromise) => {
+  const timer = setTimeout(() => rejectPromise(new SessionDaemonClientError(code)), timeoutMs);
+  promise.then(
+    (value) => {
+      clearTimeout(timer);
+      resolvePromise(value);
+    },
+    (error) => {
+      clearTimeout(timer);
+      rejectPromise(error);
+    },
+  );
+});
+
 const getWindowsOwnerKey = () => {
   try {
     return createHash('sha256').update(userInfo().username).digest('hex').slice(0, 16);
@@ -253,7 +267,12 @@ export const createPiSessionDaemonSupervisor = ({
       throw new PiSessionDaemonUnavailableError('DAEMON_UNAVAILABLE');
     }
     try {
-      const health = await request({ endpoint: paths.endpoint, credential, command: 'runtime.health' });
+      const health = await rejectAfter(request({
+        endpoint: paths.endpoint,
+        credential,
+        command: 'runtime.health',
+        timeoutMs: startupTimeoutMs,
+      }), startupTimeoutMs, 'DAEMON_UNAVAILABLE');
       if (health?.state !== 'ready' || health.daemonPid !== state.pid) {
         throw new PiSessionDaemonUnavailableError('DAEMON_IDENTITY_MISMATCH');
       }