@pi-chamber/web 0.3.0 → 0.3.2

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

@@ -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/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,
@@ -26,6 +27,7 @@ import {
   validatePiSessionJsonlDirectory,
   validatePiSessionJsonlFile,
 } from './session-jsonl.js';
+import { resolvePiChamberDataDir } from '../pichamber-data-dir.js';
 
 const PROTOCOL_VERSION = 1;
 const MAX_FRAME_BYTES = 16 * 1024 * 1024;
@@ -136,9 +138,12 @@ export function createSessionDaemon({
   const messageStartedAt = new Map();
   const toolStartedAt = new Map();
   const latestUserMessageIds = new Map();
+  const retryStateBySession = new Map();
+  const activeRunStartedAt = 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 +243,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 +258,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,
@@ -261,6 +268,8 @@ export function createSessionDaemon({
         ...(activeSession?.thinkingLevel ? { thinking: activeSession.thinkingLevel } : {}),
         ...(typeof lastAssistant?.text === 'string' ? { lastText: lastAssistant.text } : {}),
         ...(typeof lastAssistant?.thinking === 'string' ? { lastThinking: lastAssistant.thinking } : {}),
+        ...(session.sessionId && activeRunStartedAt.has(session.sessionId) ? { runStartedAt: activeRunStartedAt.get(session.sessionId) } : {}),
+        serverNow: Date.now(),
         lastSequence: snapshotSequence,
       },
     });
@@ -727,6 +736,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,11 +748,18 @@ export function createSessionDaemon({
       messages,
       lastSequence: sequence,
       isStreaming,
-      lifecycle: isStreaming ? 'busy' : 'idle',
+      lifecycle: retry ? 'retry' : isStreaming ? 'busy' : 'idle',
+      ...(retry ? { retry } : {}),
+      ...(activeRunStartedAt.has(session.sessionId) ? { runStartedAt: activeRunStartedAt.get(session.sessionId) } : {}),
+      serverNow: Date.now(),
     };
   };
 
   const createSession = async (payload) => {
+    const explicitRetryLimit = payload && typeof payload === 'object' ? (payload.maxRetries ?? payload.retryLimit ?? payload.defaultRetryLimit) : undefined;
+    if (explicitRetryLimit !== undefined && (!Number.isInteger(explicitRetryLimit) || explicitRetryLimit < 0 || explicitRetryLimit > 10)) {
+      throw new SessionDaemonProtocolError('INVALID_ARGUMENT', 'The retry limit must be an integer between 0 and 10.');
+    }
     if (!payload || typeof payload !== 'object'
       || (payload.cwd !== undefined && (typeof payload.cwd !== 'string' || payload.cwd.length === 0))
       || (payload.title !== undefined && (typeof payload.title !== 'string' || payload.title.trim().length === 0 || payload.title.length > 256))
@@ -764,6 +781,32 @@ export function createSessionDaemon({
       ...(parent ? { sessionFile: parent.path } : {}),
     });
     if (!newRuntime.cwd) newRuntime.cwd = targetCwd;
+    // Apply default retry limit for new sessions. Explicit per-run overrides win.
+    try {
+      const settingsManager = newRuntime.services?.settingsManager;
+      if (settingsManager && typeof settingsManager.getRetrySettings === 'function') {
+        let effective = explicitRetryLimit;
+        if (effective === undefined) {
+          try {
+            const raw = await readFile(join(resolvePiChamberDataDir(), 'pi', 'settings.json'), 'utf8');
+            const parsed = JSON.parse(raw);
+            if (Number.isInteger(parsed?.defaultRetryLimit)) effective = parsed.defaultRetryLimit;
+          } catch {}
+          if (effective === undefined) effective = 3;
+        }
+        if (Number.isInteger(effective) && effective >= 0 && effective <= 10) {
+          const current = settingsManager.getRetrySettings().maxRetries;
+          if (current !== effective) {
+            if (typeof settingsManager.applyOverrides === 'function') {
+              settingsManager.applyOverrides({ retry: { maxRetries: effective } });
+              if (explicitRetryLimit === undefined) await settingsManager.flush().catch(() => {});
+            } else if (settingsManager.globalSettings) {
+              settingsManager.globalSettings.retry = { ...(settingsManager.globalSettings.retry ?? {}), maxRetries: effective };
+            }
+          }
+        }
+      }
+    } catch {}
     let result = { cancelled: false };
     if (typeof newRuntime.newSession === 'function') {
       result = await newRuntime.newSession({
@@ -1349,11 +1392,72 @@ export function createSessionDaemon({
     }
   };
 
-  const redactAttachmentPaths = (text) => typeof text === 'string'
-    ? text
-      .replace(/\[Attachment[^\]\r\n]*pi-clipboard-[0-9a-f-]{36}[^\]\r\n]*\]/gi, '[attachment]')
-      .replace(/(?:[A-Za-z]:)?[^\s[\](){}"'`]*pi-clipboard-[0-9a-f-]{36}(?:\.[^\s\])}\]"'`,;]+)?/gi, '[attachment]')
-    : '';
+  const attachmentMarkerPattern = /pi-clipboard-/i;
+  const attachmentMarkerSearchPattern = /pi-clipboard-/gi;
+  const attachmentIdPattern = /^[0-9a-f-]{36}$/i;
+  const attachmentBracketStartPattern = /\[Attachment/gi;
+  const attachmentTokenPattern = /pi-clipboard-[0-9a-f-]{36}/i;
+  const isAttachmentPathDelimiter = (character) => /[\s[\](){}"'`,;]/u.test(character);
+
+  const redactAttachmentBrackets = (text) => {
+    let cursor = 0;
+    let output = '';
+    while (cursor < text.length) {
+      attachmentBracketStartPattern.lastIndex = cursor;
+      const bracketStart = attachmentBracketStartPattern.exec(text);
+      if (!bracketStart) {
+        output += text.slice(cursor);
+        break;
+      }
+
+      output += text.slice(cursor, bracketStart.index);
+      let bracketEnd = bracketStart.index + bracketStart[0].length;
+      while (bracketEnd < text.length && text[bracketEnd] !== ']' && text[bracketEnd] !== '\r' && text[bracketEnd] !== '\n') bracketEnd += 1;
+      if (text[bracketEnd] === ']') {
+        const candidate = text.slice(bracketStart.index, bracketEnd + 1);
+        output += attachmentTokenPattern.test(candidate) ? '[attachment]' : candidate;
+        cursor = bracketEnd + 1;
+      } else {
+        output += text.slice(bracketStart.index, bracketEnd);
+        cursor = bracketEnd;
+      }
+    }
+    return output;
+  };
+
+  const redactAttachmentPaths = (text) => {
+    if (typeof text !== 'string') return '';
+
+    if (!attachmentMarkerPattern.test(text)) return text;
+    const bracketRedacted = redactAttachmentBrackets(text);
+    let cursor = 0;
+    let output = '';
+    while (cursor < bracketRedacted.length) {
+      attachmentMarkerSearchPattern.lastIndex = cursor;
+      const markerMatch = attachmentMarkerSearchPattern.exec(bracketRedacted);
+      if (!markerMatch) {
+        output += bracketRedacted.slice(cursor);
+        break;
+      }
+
+      const markerIndex = markerMatch.index;
+      const idStart = markerIndex + markerMatch[0].length;
+      const idEnd = idStart + 36;
+      if (!attachmentIdPattern.test(bracketRedacted.slice(idStart, idEnd))) {
+        output += bracketRedacted.slice(cursor, idStart);
+        cursor = idStart;
+        continue;
+      }
+
+      let tokenStart = markerIndex;
+      while (tokenStart > cursor && !isAttachmentPathDelimiter(bracketRedacted[tokenStart - 1])) tokenStart -= 1;
+      let tokenEnd = idEnd;
+      while (tokenEnd < bracketRedacted.length && !isAttachmentPathDelimiter(bracketRedacted[tokenEnd])) tokenEnd += 1;
+      output += `${bracketRedacted.slice(cursor, tokenStart)}[attachment]`;
+      cursor = tokenEnd;
+    }
+    return output;
+  };
 
   const redactAttachmentValues = (value) => {
     if (typeof value === 'string') return redactAttachmentPaths(value);
@@ -1602,7 +1706,12 @@ export function createSessionDaemon({
       targetDir = directory;
       await rm(target.path, { force: false });
     }
-    publish('session.lifecycle', { state: 'idle', deleted: true }, sessionId, targetDir);
+    messageEntryAliases.clearSession({ cwd: active?.cwd || targetDir, sessionId });
+    retryStateBySession.delete(sessionId);
+    activeRunStartedAt.delete(sessionId);
+    latestUserMessageIds.delete(sessionId);
+    latestAssistantMessageIds.delete(sessionId);
+    publish('session.lifecycle', { state: 'idle', deleted: true, serverNow: Date.now() }, sessionId, targetDir);
   };
 
   const publishSessionEvent = (sessionId, event, directory = activeDirectory || cwd) => {
@@ -1616,6 +1725,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 +1735,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 +1764,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 +1789,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 +1853,11 @@ export function createSessionDaemon({
         break;
       case 'agent_start':
         clearIdleDisposal(sessionId);
-        publish('session.lifecycle', { state: 'busy' }, sessionId, directory);
+        retryStateBySession.delete(sessionId);
+        if (!activeRunStartedAt.has(sessionId)) activeRunStartedAt.set(sessionId, Date.now());
+        publish('session.lifecycle', { state: 'busy', runStartedAt: activeRunStartedAt.get(sessionId), serverNow: Date.now() }, 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,16 +1866,26 @@ 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);
+        if (!activeRunStartedAt.has(sessionId)) activeRunStartedAt.set(sessionId, Date.now());
+        publish('session.lifecycle', { state: 'retry', ...retry, runStartedAt: activeRunStartedAt.get(sessionId), serverNow: Date.now() }, sessionId, directory);
+        break;
+      }
+      case 'auto_retry_end':
+        retryStateBySession.delete(sessionId);
         break;
       case 'agent_settled':
-        publish('session.lifecycle', { state: 'idle' }, sessionId, directory);
+        retryStateBySession.delete(sessionId);
+        activeRunStartedAt.delete(sessionId);
+        latestUserMessageIds.delete(sessionId);
+        latestAssistantMessageIds.delete(sessionId);
+        publish('session.lifecycle', { state: 'idle', serverNow: Date.now() }, sessionId, directory);
         scheduleIdleDisposal(sessionId);
         break;
       case 'thinking_level_changed':
@@ -1924,35 +2059,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 +2083,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 +2260,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 +2274,13 @@ export function createSessionDaemon({
         clearTimeout(attempt.expiry);
       }
       loginAttempts.clear();
+      retryStateBySession.clear();
+      activeRunStartedAt.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());
       });