@axhub/genie 0.2.8 → 0.2.9

package/server/routes/session-core.js

@@ -1,8 +1,17 @@
 import express from 'express';
-import { getProjects } from '../projects.js';
+import crypto from 'node:crypto';
+import path from 'path';
+import {
+  getClaudeSessionMetadata,
+  getCodexSessionMetadata,
+  getGeminiSessionMetadata,
+  getOpencodeSessionMetadata,
+  getProjects,
+  getProjectsList
+} from '../projects.js';
 import { discoverAllProviders, discoverProvider } from '../session-core/providerDiscovery.js';
 import { getProviderAdapter } from '../session-core/providerAdapters.js';
-import { listAcpSessions } from '../acp-runtime/session-store.js';
+import { findAcpSessionRecord, listAcpSessions } from '../acp-runtime/session-store.js';
 
 const router = express.Router();
 
@@ -29,6 +38,127 @@ async function flattenProjectSessions(project) {
     .sort((a, b) => new Date(b.lastActivity || b.updated_at || b.createdAt || 0) - new Date(a.lastActivity || a.updated_at || a.createdAt || 0));
 }
 
+async function resolveProviderSessionRoute({
+  provider,
+  sessionId,
+  projectList = null
+}) {
+  const normalizedProvider = String(provider || '').trim().toLowerCase();
+  const normalizedSessionId = String(sessionId || '').trim();
+
+  if (!normalizedProvider || !normalizedSessionId) {
+    return null;
+  }
+
+  const projects = Array.isArray(projectList) ? projectList : await getProjectsList();
+  const normalizeComparableProjectPath = (projectPath) => {
+    if (typeof projectPath !== 'string' || !projectPath.trim()) {
+      return '';
+    }
+
+    const withoutWindowsLongPathPrefix = projectPath.startsWith('\\\\?\\')
+      ? projectPath.slice(4)
+      : projectPath;
+
+    return path.normalize(withoutWindowsLongPathPrefix);
+  };
+
+  const findProjectByPath = (projectPath) => {
+    const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
+    if (!normalizedProjectPath) {
+      return null;
+    }
+
+    return projects.find((project) => {
+      const candidatePath = project.fullPath || project.path || '';
+      return normalizeComparableProjectPath(candidatePath) === normalizedProjectPath;
+    }) || null;
+  };
+
+  const acpRecord = await findAcpSessionRecord(normalizedSessionId, normalizedProvider);
+  const acpProject = findProjectByPath(acpRecord?.projectPath || null);
+
+  let matchedProject = acpProject;
+  let resolvedSource = acpRecord ? 'acp' : 'legacy';
+
+  if (!matchedProject) {
+    switch (normalizedProvider) {
+      case 'claude': {
+        const metadata = await getClaudeSessionMetadata(normalizedSessionId);
+        matchedProject = findProjectByPath(metadata?.cwd || null);
+        break;
+      }
+      case 'codex': {
+        const metadata = await getCodexSessionMetadata(normalizedSessionId);
+        matchedProject = findProjectByPath(metadata?.cwd || null);
+        break;
+      }
+      case 'gemini': {
+        const metadata = await getGeminiSessionMetadata(normalizedSessionId);
+        const projectHash = String(metadata?.projectHash || '').trim();
+
+        if (projectHash) {
+          matchedProject = projects.find((project) => {
+            const projectPath = normalizeComparableProjectPath(project.fullPath || project.path || '');
+            if (!projectPath) {
+              return false;
+            }
+
+            const candidateHash = crypto.createHash('sha256').update(projectPath).digest('hex');
+            return candidateHash === projectHash;
+          }) || null;
+        }
+        break;
+      }
+      case 'opencode': {
+        const metadata = await getOpencodeSessionMetadata(normalizedSessionId);
+        matchedProject = findProjectByPath(metadata?.cwd || null);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  if (!matchedProject) {
+    return null;
+  }
+
+  const adapter = getProviderAdapter(normalizedProvider);
+  let sessions = [];
+
+  if (normalizedProvider === 'claude') {
+    sessions = await adapter.listSessions({
+      projectName: matchedProject.name,
+      projectPath: matchedProject.fullPath || matchedProject.path,
+      limit: 1000,
+      offset: 0
+    });
+  } else {
+    sessions = await adapter.listSessions({
+      projectPath: matchedProject.fullPath || matchedProject.path,
+      limit: 0
+    });
+  }
+
+  const matchedSession = (Array.isArray(sessions) ? sessions : []).find((session) => session.id === normalizedSessionId);
+  if (!matchedSession) {
+    return null;
+  }
+
+  return {
+    provider: normalizedProvider,
+    source: matchedSession.source || resolvedSource,
+    session: matchedSession,
+    project: {
+      name: matchedProject.name,
+      fullPath: matchedProject.fullPath || matchedProject.path,
+      path: matchedProject.path,
+      displayName: matchedProject.displayName || matchedProject.name
+    }
+  };
+}
+
 router.get('/providers', async (req, res) => {
   try {
     const providers = await discoverAllProviders({ projectPath: req.query.projectPath });
@@ -68,98 +198,29 @@ router.get('/projects/:projectName/history-index', async (req, res) => {
   }
 });
 
-router.get('/sessions/:sessionId/resolve', async (req, res) => {
+router.get('/sessions/:provider/:sessionId/resolve', async (req, res) => {
   try {
-    const projects = await getProjects();
+    const requestedProvider = String(req.params.provider || '').trim().toLowerCase();
     const requestedSessionId = String(req.params.sessionId || '').trim();
-    const providerHint = typeof req.query.provider === 'string' ? req.query.provider.trim().toLowerCase() : '';
-
-    if (!requestedSessionId) {
-      return res.status(400).json({ success: false, error: 'Session id is required' });
-    }
 
-    const providerOrder = [
-      providerHint,
-      'codex',
-      'claude',
-      'gemini',
-      'opencode'
-    ].filter((provider, index, all) => provider && all.indexOf(provider) === index);
-
-    let directProjectMatch = null;
-    let directMatchSessions = [];
-
-    for (const project of projects) {
-      const flattened = await flattenProjectSessions(project);
-      if (flattened.some((session) => session.id === requestedSessionId)) {
-        directProjectMatch = project;
-        directMatchSessions = flattened;
-        break;
-      }
+    if (!requestedProvider || !requestedSessionId) {
+      return res.status(400).json({ success: false, error: 'provider and session id are required' });
     }
 
-    if (directProjectMatch) {
-      const matchedSession = directMatchSessions.find((session) => session.id === requestedSessionId);
-
-      return res.json({
-        success: true,
-        found: true,
-        provider: matchedSession.provider,
-        source: matchedSession.source || 'legacy',
-        session: matchedSession,
-        project: {
-          name: directProjectMatch.name,
-          fullPath: directProjectMatch.fullPath || directProjectMatch.path,
-          path: directProjectMatch.path,
-          displayName: directProjectMatch.displayName || directProjectMatch.name
-        }
-      });
-    }
-
-    for (const provider of providerOrder) {
-      const adapter = getProviderAdapter(provider);
-
-      for (const project of projects) {
-        let sessions = [];
-
-        try {
-          if (provider === 'claude') {
-            const result = await adapter.listSessions({
-              projectName: project.name,
-              projectPath: project.fullPath || project.path,
-              limit: 1000,
-              offset: 0
-            });
-            sessions = Array.isArray(result) ? result : [];
-          } else {
-            sessions = await adapter.listSessions({ projectPath: project.fullPath || project.path, limit: 0 });
-          }
-        } catch (error) {
-          continue;
-        }
-
-        const matchedSession = sessions.find((session) => session.id === requestedSessionId);
-        if (!matchedSession) {
-          continue;
-        }
+    const result = await resolveProviderSessionRoute({
+      provider: requestedProvider,
+      sessionId: requestedSessionId
+    });
 
-        return res.json({
-          success: true,
-          found: true,
-          provider,
-          source: matchedSession.source || 'legacy',
-          session: matchedSession,
-          project: {
-            name: project.name,
-            fullPath: project.fullPath || project.path,
-            path: project.path,
-            displayName: project.displayName || project.name
-          }
-        });
-      }
+    if (!result) {
+      return res.status(404).json({ success: true, found: false });
     }
 
-    res.status(404).json({ success: true, found: false });
+    res.json({
+      success: true,
+      found: true,
+      ...result
+    });
   } catch (error) {
     res.status(500).json({ success: false, error: error.message });
   }
@@ -208,4 +269,6 @@ router.get('/sessions/:provider/:sessionId/events', async (req, res) => {
   }
 });
 
+export { resolveProviderSessionRoute };
+
 export default router;

package/server/session-core/eventStore.js

@@ -1,6 +1,8 @@
+import fsSync from 'fs';
 import fs from 'fs/promises';
 import os from 'os';
 import path from 'path';
+import readline from 'readline';
 
 import {
   CONVERSATION_EVENT_KINDS,
@@ -13,7 +15,11 @@ const PERSISTED_EVENT_KINDS = new Set([
   CONVERSATION_EVENT_KINDS.ERROR,
   CONVERSATION_EVENT_KINDS.APPROVAL_REQUEST,
   CONVERSATION_EVENT_KINDS.APPROVAL_RESOLVED,
-  CONVERSATION_EVENT_KINDS.SYSTEM_NOTICE
+  CONVERSATION_EVENT_KINDS.SYSTEM_NOTICE,
+  CONVERSATION_EVENT_KINDS.MODE_UPDATE,
+  CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE,
+  CONVERSATION_EVENT_KINDS.PLAN_UPDATE,
+  CONVERSATION_EVENT_KINDS.ARTIFACT_CREATED
 ]);
 
 function getSessionEventFilePath(provider, sessionId) {
@@ -24,14 +30,19 @@ function normalizePersistedEvents(events = []) {
   return events.filter((event) => (
     isConversationEvent(event) &&
     event.sessionId &&
-    (
-      event.extensions?.runtimeSource === 'acp' ||
-      event.rawRef?.runtime === 'acp' ||
-      PERSISTED_EVENT_KINDS.has(event.kind)
-    )
+    PERSISTED_EVENT_KINDS.has(event.kind)
   ));
 }
 
+function extractSerializedEventKind(line) {
+  if (typeof line !== 'string' || !line) {
+    return null;
+  }
+
+  const match = line.match(/"kind"\s*:\s*"([^"]+)"/);
+  return match?.[1] || null;
+}
+
 function sortObjectKeys(value) {
   if (Array.isArray(value)) {
     return value.map(sortObjectKeys);
@@ -91,19 +102,35 @@ export async function readMirroredConversationEvents(provider, sessionId) {
   const filePath = getSessionEventFilePath(provider, sessionId);
 
   try {
-    const content = await fs.readFile(filePath, 'utf8');
-    return content
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean)
-      .map((line) => {
-        try {
-          return JSON.parse(line);
-        } catch {
-          return null;
+    const fileStream = fsSync.createReadStream(filePath, { encoding: 'utf8' });
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    const events = [];
+
+    for await (const rawLine of rl) {
+      const line = rawLine.trim();
+      if (!line) {
+        continue;
+      }
+
+      const kind = extractSerializedEventKind(line);
+      if (!kind || !PERSISTED_EVENT_KINDS.has(kind)) {
+        continue;
+      }
+
+      try {
+        const event = JSON.parse(line);
+        if (isConversationEvent(event) && PERSISTED_EVENT_KINDS.has(event.kind)) {
+          events.push(event);
         }
-      })
-      .filter(isConversationEvent);
+      } catch {
+        // Skip malformed lines and oversized legacy transcript events.
+      }
+    }
+
+    return events;
   } catch (error) {
     if (error?.code === 'ENOENT') {
       return [];

package/server/session-core/providerAdapters.js

@@ -37,6 +37,18 @@ async function normalizeLegacyLoadResult(result, provider, sessionId) {
   };
 }
 
+function createEventLoadResult(events = [], source = 'acp') {
+  const normalizedEvents = Array.isArray(events) ? events : [];
+  return {
+    events: normalizedEvents,
+    total: normalizedEvents.length,
+    hasMore: false,
+    offset: 0,
+    limit: null,
+    source
+  };
+}
+
 function mergeSessionLists(legacySessions = [], acpSessions = []) {
   const merged = new Map();
 
@@ -59,21 +71,30 @@ function mergeSessionLists(legacySessions = [], acpSessions = []) {
   });
 }
 
-async function loadAcpEvents(provider, sessionId) {
+async function loadAcpEvents(provider, sessionId, nativeHistoryLoader = null) {
   const record = await findAcpSessionRecord(sessionId, provider);
   if (!record) {
     return null;
   }
 
+  if (typeof nativeHistoryLoader === 'function') {
+    try {
+      const nativeResult = await nativeHistoryLoader();
+      const normalizedResult = await normalizeLegacyLoadResult(nativeResult, provider, sessionId);
+      if (Array.isArray(normalizedResult)) {
+        return createEventLoadResult(normalizedResult, 'acp');
+      }
+      return {
+        ...normalizedResult,
+        source: 'acp'
+      };
+    } catch {
+      // Fall back to the mirrored event store when native history is unavailable.
+    }
+  }
+
   const events = await readMirroredConversationEvents(provider, sessionId);
-  return {
-    events,
-    total: events.length,
-    hasMore: false,
-    offset: 0,
-    limit: null,
-    source: 'acp'
-  };
+  return createEventLoadResult(events, 'acp');
 }
 
 const PROVIDER_ADAPTERS = {
@@ -89,7 +110,11 @@ const PROVIDER_ADAPTERS = {
       );
     },
     async loadEvents({ projectName, sessionId, limit = null, offset = 0 }) {
-      const acpResult = await loadAcpEvents('claude', sessionId);
+      const acpResult = await loadAcpEvents(
+        'claude',
+        sessionId,
+        () => getSessionMessages(projectName, sessionId, limit, offset),
+      );
       if (acpResult) {
         return acpResult;
       }
@@ -110,7 +135,11 @@ const PROVIDER_ADAPTERS = {
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
-      const acpResult = await loadAcpEvents('codex', sessionId);
+      const acpResult = await loadAcpEvents(
+        'codex',
+        sessionId,
+        () => getCodexSessionMessages(sessionId, limit, offset),
+      );
       if (acpResult) {
         return acpResult;
       }
@@ -131,7 +160,11 @@ const PROVIDER_ADAPTERS = {
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
-      const acpResult = await loadAcpEvents('gemini', sessionId);
+      const acpResult = await loadAcpEvents(
+        'gemini',
+        sessionId,
+        () => getGeminiSessionMessages(sessionId, limit, offset),
+      );
       if (acpResult) {
         return acpResult;
       }
@@ -152,7 +185,11 @@ const PROVIDER_ADAPTERS = {
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
-      const acpResult = await loadAcpEvents('opencode', sessionId);
+      const acpResult = await loadAcpEvents(
+        'opencode',
+        sessionId,
+        () => getOpencodeSessionMessages(sessionId, limit, offset),
+      );
       if (acpResult) {
         return acpResult;
       }

package/server/session-core/runtimeState.js

@@ -266,6 +266,14 @@ function createRuntimeSignature(snapshot) {
   });
 }
 
+export function seedSessionRuntimeSubscriptionSnapshot(subscriptionKey, snapshot) {
+  if (!subscriptionKey || !snapshot) {
+    return;
+  }
+
+  lastBroadcastSignatures.set(subscriptionKey, createRuntimeSignature(snapshot));
+}
+
 export function createSessionRuntimeSubscriptionKey(provider, sessionId) {
   const normalizedProvider = normalizeProvider(provider);
   const normalizedSessionId = normalizeNonEmptyString(sessionId);

package/shared/conversationEvents.js

@@ -185,11 +185,61 @@ function createTextEndEvent({
   ];
 }
 
+function extractProtocolUserMessage(value) {
+  const text = String(value || '').trim();
+  if (!text) {
+    return null;
+  }
+
+  const dynamicContextMatch = text.match(
+    /<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>\s*<user_message(?:\s[^>]*)?>\s*([\s\S]*?)\s*<\/user_message>/i
+  );
+  if (!dynamicContextMatch) {
+    return null;
+  }
+
+  return String(dynamicContextMatch[1] || '').trim();
+}
+
+function hasAcpProtocolTags(value) {
+  return /<\/?(?:subagent_notification|environment_context|dynamic_context|user_message)(?:\s[^>]*)?>/i.test(String(value || ''));
+}
+
+export function stripAssistantProtocolTags(text) {
+  if (typeof text !== 'string') {
+    return text;
+  }
+
+  const visibleUserMessage = extractProtocolUserMessage(text);
+  if (visibleUserMessage != null) {
+    return visibleUserMessage;
+  }
+
+  const hadProtocolTags = hasAcpProtocolTags(text);
+  let result = text;
+
+  result = result.replace(/<subagent_notification(?:\s[^>]*)?>[\s\S]*?<\/subagent_notification>/gi, '');
+  result = result.replace(/<environment_context(?:\s[^>]*)?>[\s\S]*?<\/environment_context>/gi, '');
+  result = result.replace(/<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>/gi, '');
+  result = result.replace(/<\/?(?:subagent_notification|environment_context|dynamic_context|user_message)(?:\s[^>]*)?>/gi, '');
+
+  if (hadProtocolTags) {
+    result = result.replace(/["']?\s*\}\s*\}\s*$/g, '');
+  }
+
+  return result.trim();
+}
+
 function extractVisibleUserMessage(value) {
   const text = String(value || '').trim();
   if (!text) return '';
 
-  if (text.startsWith('# AGENTS.md instructions for ') || text.includes('<environment_context>')) {
+  if (
+    text.startsWith('# AGENTS.md instructions for ') ||
+    text.includes('<environment_context>') ||
+    text.startsWith('<subagent_notification>') ||
+    text.startsWith('</subagent_notification>')
+  ) {
     return '';
   }
 
@@ -202,11 +252,9 @@ function extractVisibleUserMessage(value) {
     return '';
   }
 
-  const dynamicContextMatch = text.match(
-    /^<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>\s*<user_message>\s*([\s\S]*?)\s*<\/user_message>$/i
-  );
-  if (dynamicContextMatch) {
-    return String(dynamicContextMatch[1] || '').trim();
+  const protocolUserMessage = extractProtocolUserMessage(text);
+  if (protocolUserMessage != null) {
+    return protocolUserMessage;
   }
 
   return text;
@@ -222,12 +270,16 @@ function isHiddenSystemContextContent(value) {
     text.startsWith('[Dynamic Context]') ||
     text.startsWith('[Hidden Context]') ||
     text.startsWith('# AGENTS.md instructions for ') ||
-    text.startsWith('[DYNAMIC CONTEXT V1]')
+    text.startsWith('[DYNAMIC CONTEXT V1]') ||
+    text.startsWith('<subagent_notification>') ||
+    text.startsWith('</subagent_notification>')
   ) {
     return true;
   }
 
-  return /^<dynamic_context(?:\s|>)/i.test(text) || text.includes('<environment_context>');
+  return /^<dynamic_context(?:\s|>)/i.test(text)
+    || text.includes('<environment_context>')
+    || /<subagent_notification(?:\s|>)/i.test(text);
 }
 
 function stringifyToolContent(value) {
@@ -613,8 +665,11 @@ export function normalizeLegacyHistoryEntries(rawMessages = [], provider = 'clau
     if (msg?.message?.role === 'assistant' && msg?.message?.content) {
       if (Array.isArray(msg.message.content)) {
         for (const part of msg.message.content) {
-          if (part?.type === 'text' && !isHiddenSystemContextContent(part.text)) {
-            events.push(...createTextSpanEvents({ text: part.text, provider, sessionId, timestamp, rawRef }));
+          if (part?.type === 'text') {
+            const cleanText = stripAssistantProtocolTags(part.text);
+            if (cleanText && !isHiddenSystemContextContent(cleanText)) {
+              events.push(...createTextSpanEvents({ text: cleanText, provider, sessionId, timestamp, rawRef }));
+            }
           } else if (part?.type === 'tool_use') {
             const toolCallId = part.id || createEventId('tool');
             const result = toolResults.get(part.id);
@@ -633,8 +688,11 @@ export function normalizeLegacyHistoryEntries(rawMessages = [], provider = 'clau
             }
           }
         }
-      } else if (!isHiddenSystemContextContent(msg.message.content)) {
-        events.push(...createTextSpanEvents({ text: msg.message.content, provider, sessionId, timestamp, rawRef }));
+      } else {
+        const cleanText = stripAssistantProtocolTags(msg.message.content);
+        if (cleanText && !isHiddenSystemContextContent(cleanText)) {
+          events.push(...createTextSpanEvents({ text: cleanText, provider, sessionId, timestamp, rawRef }));
+        }
       }
       continue;
     }
@@ -660,6 +718,12 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
       const clientRequestId = getConversationEventClientRequestId(event);
       const optimisticIndex = findMatchingOptimisticUserMessageIndex(nextMessages, event, payload);
       const normalizedContentBlocks = normalizeMessageContentBlocks(payload.contentBlocks);
+      const rawText = typeof payload.text === 'string' ? payload.text : '';
+      const visibleText = rawText ? extractVisibleUserMessage(rawText) : '';
+
+      if (rawText.trim() && !visibleText && normalizedContentBlocks.length === 0) {
+        break;
+      }
 
       if (optimisticIndex >= 0) {
         const existingMessage = nextMessages[optimisticIndex] || {};
@@ -670,7 +734,7 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
         nextMessages[optimisticIndex] = {
           ...existingMessage,
           type: 'user',
-          content: payload.text || existingMessage.content || '',
+          content: visibleText || existingMessage.content || '',
           timestamp: existingMessage.timestamp || timestamp,
           provider,
           contentBlocks: nextContentBlocks,
@@ -683,7 +747,7 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
 
       nextMessages.push({
         type: 'user',
-        content: payload.text || '',
+        content: visibleText,
         timestamp,
         provider,
         contentBlocks: normalizedContentBlocks,