glad-web 1.0.19 → 1.0.21

package/lib/commands/web.js

@@ -33,11 +33,16 @@ function sendCompressedJson(req, res, payload) {
   res.type('application/json').send(body);
 }
 
+function getSessionWorkingDirectory(session) {
+  return session.workingDir || (session.ptyManager && session.ptyManager.workingDir) || process.cwd();
+}
+
 const { detectInstalledTools } = require('../ai-tools/detector');
 const logger = require('../utils/logger');
 const { JobStore } = require('../schedule/job-store');
 const JobRunner = require('../schedule/job-runner');
 const SchedulerService = require('../schedule/scheduler-service');
+const { getClaudeRuntimeConfig } = require('../claude/config');
 
 async function webCommand(options) {
   const port = parseInt(options.port) || 3000;
@@ -85,6 +90,9 @@ async function webCommand(options) {
   sessionManager.on('output', ({ sessionId, data }) => {
     broadcastToSession(sessionId, { type: 'output', data });
   });
+  sessionManager.on('claude-event', ({ sessionId, event }) => {
+    broadcastToSession(sessionId, { type: 'claude-event', event });
+  });
   sessionManager.on('exit', ({ sessionId }) => {
     broadcastToSession(sessionId, { type: 'exit' });
   });
@@ -179,12 +187,16 @@ async function webCommand(options) {
     res.json(sessionManager.list());
   });
 
+  app.get('/api/claude-config', (req, res) => {
+    res.json({ success: true, config: getClaudeRuntimeConfig(process.env) });
+  });
+
   // API: Create a new PTY session
   app.post('/api/sessions', async (req, res) => {
     logger.debug(`API: POST /api/sessions - ${JSON.stringify(req.body)}`);
     try {
-      const { toolKey, workingDirectory } = req.body;
-      const session = sessionManager.create({ toolKey, workingDirectory });
+      const { toolKey, workingDirectory, claudeOptions } = req.body;
+      const session = sessionManager.create({ toolKey, workingDirectory, claudeOptions });
       res.json({ id: session.id });
     } catch (e) {
       logger.error(`API: POST /api/sessions failed: ${e.message}`);
@@ -263,6 +275,32 @@ async function webCommand(options) {
     res.json({ success: true, diagnostics });
   });
 
+  app.get('/api/sessions/:id/claude-resume-sessions', (req, res) => {
+    const items = sessionManager.listClaudeResumeSessions(req.params.id);
+    if (!items) return res.status(404).json({ error: 'Claude session not found' });
+    res.json({ success: true, items });
+  });
+
+  app.patch('/api/sessions/:id/claude-settings', (req, res) => {
+    const state = sessionManager.updateClaudeSettings(req.params.id, req.body || {});
+    if (!state) return res.status(404).json({ error: 'Claude session not found' });
+    res.json({ success: true, state });
+  });
+
+  app.post('/api/sessions/:id/claude-abort', (req, res) => {
+    const success = sessionManager.abortClaude(req.params.id);
+    if (!success) return res.status(404).json({ error: 'Claude session not found or idle' });
+    res.json({ success: true });
+  });
+
+  app.post('/api/sessions/:id/claude-resume', (req, res) => {
+    const resumeSessionId = req.body && req.body.resumeSessionId;
+    if (!resumeSessionId) return res.status(400).json({ error: 'Missing resumeSessionId' });
+    const success = sessionManager.resumeClaude(req.params.id, resumeSessionId);
+    if (!success) return res.status(404).json({ error: 'Claude session not found' });
+    res.json({ success: true });
+  });
+
   app.post('/api/debug/client-log', (req, res) => {
     const { sessionId, event, payload } = req.body || {};
     sessionManager.logClientDebug(sessionId, event, payload);
@@ -274,7 +312,7 @@ async function webCommand(options) {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const hash = req.params.hash;
-    const result = await gitService.show(session.ptyManager.workingDir, hash);
+    const result = await gitService.show(getSessionWorkingDirectory(session), hash);
     res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
   });
 
@@ -283,7 +321,7 @@ async function webCommand(options) {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const hash = req.params.hash;
-    const result = await gitService.nameRev(session.ptyManager.workingDir, hash);
+    const result = await gitService.nameRev(getSessionWorkingDirectory(session), hash);
     res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
   });
 
@@ -291,7 +329,7 @@ async function webCommand(options) {
   app.get('/api/sessions/:id/git-log', async (req, res) => {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
-    const result = await gitService.log(session.ptyManager.workingDir, req.query.maxCount);
+    const result = await gitService.log(getSessionWorkingDirectory(session), req.query.maxCount);
     if (!result.success) {
       return res.status(500).json({ error: result.error, stderr: result.stderr });
     }
@@ -302,7 +340,7 @@ async function webCommand(options) {
   app.get('/api/sessions/:id/git-status', async (req, res) => {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
-    const result = await gitService.status(session.ptyManager.workingDir);
+    const result = await gitService.status(getSessionWorkingDirectory(session));
     if (!result.success) {
       return res.status(500).json({ error: result.error, stderr: result.stderr });
     }
@@ -314,7 +352,7 @@ async function webCommand(options) {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const isStaged = req.query.staged === 'true';
-    const result = await gitService.diffNumstat(session.ptyManager.workingDir, isStaged);
+    const result = await gitService.diffNumstat(getSessionWorkingDirectory(session), isStaged);
     res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
   });
 
@@ -325,7 +363,7 @@ async function webCommand(options) {
     const isStaged = req.query.staged === 'true';
     const filePath = req.query.path;
     if (!filePath) return res.status(400).json({ error: 'Missing file path' });
-    const result = await gitService.diffFile(session.ptyManager.workingDir, filePath, isStaged);
+    const result = await gitService.diffFile(getSessionWorkingDirectory(session), filePath, isStaged);
     res.json({ success: result.success, stdout: result.stdout, stderr: result.stderr });
   });
 
@@ -335,7 +373,7 @@ async function webCommand(options) {
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const filePath = req.query.path || '';
     if (!filePath) return res.status(400).json({ error: 'Missing file path' });
-    const cwd = session.ptyManager.workingDir || '';
+    const cwd = getSessionWorkingDirectory(session);
     try {
       const content = workspaceService.readFile(cwd, filePath);
       res.json({ success: true, content });
@@ -349,7 +387,7 @@ async function webCommand(options) {
     const session = sessionManager.get(req.params.id);
     if (!session) return res.status(404).json({ error: 'Session not found' });
     const dirPath = req.query.path || '';
-    const cwd = session.ptyManager.workingDir || '';
+    const cwd = getSessionWorkingDirectory(session);
     try {
       const files = await workspaceService.listDirectory(cwd, dirPath);
       res.json({ success: true, files });
@@ -393,15 +431,20 @@ async function webCommand(options) {
       session.resizeOwner = ws;
     }
     sessionManager.logWsConnected(sessionId, req);
+
+    if (session.kind === 'claude-structured') {
+      ws.send(JSON.stringify({ type: 'claude-snapshot', snapshot: sessionManager.getClaudeSnapshot(sessionId) }));
+    }
     
     // Send catchup output. TUI tools may skip the raw circular buffer, so fall
     // back to the rendered/text history snapshot instead of reconnecting blank.
     const catchup = sessionManager.getCatchupOutput(sessionId);
-    ws.needsTuiRedraw = ['antigravity', 'claude-code', 'codex'].includes(session.tool.key)
+    ws.needsTuiRedraw = session.kind !== 'claude-structured'
+      && ['antigravity', 'claude-code', 'codex'].includes(session.tool.key)
       && (isReconnect || (catchup && catchup.source === 'rendered-history'));
     if (ws.needsTuiRedraw) {
       ws.send(JSON.stringify({ type: 'reset' }));
-    } else if (catchup && catchup.data) {
+    } else if (session.kind !== 'claude-structured' && catchup && catchup.data) {
       sessionManager.logWsCatchupOutput(sessionId, catchup);
       ws.send(JSON.stringify({ type: 'output', data: catchup.data }));
     }
@@ -412,6 +455,21 @@ async function webCommand(options) {
         if (payload.type === 'input') {
           session.write(payload.data);
         }
+        if (payload.type === 'claude-input') {
+          sessionManager.sendClaudeInput(sessionId, payload.text || '');
+        }
+        if (payload.type === 'claude-permission') {
+          sessionManager.respondClaudePermission(sessionId, payload.id, Boolean(payload.approved), payload.action || null);
+        }
+        if (payload.type === 'claude-settings') {
+          sessionManager.updateClaudeSettings(sessionId, payload.settings || {});
+        }
+        if (payload.type === 'claude-abort') {
+          sessionManager.abortClaude(sessionId);
+        }
+        if (payload.type === 'claude-resume') {
+          sessionManager.resumeClaude(sessionId, payload.resumeSessionId || '');
+        }
         if (payload.type === 'resize' && session.resizeOwner === ws) {
           sessionManager.logWsResize(sessionId, payload.cols, payload.rows);
           if (ws.needsTuiRedraw) {

package/lib/session/session-manager.js

@@ -1,12 +1,14 @@
 const { EventEmitter } = require('events');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const { v4: uuidv4 } = require('uuid');
 const PTYManager = require('./pty-manager');
 const TextHistory = require('./text-history');
 const RenderedHistory = require('./rendered-history');
 const CircularBuffer = require('./buffer');
 const { getToolByKey } = require('../ai-tools/registry');
+const ClaudeStructuredSession = require('../claude/structured-session');
 
 function previewText(text, maxChars = 320) {
   if (!text) return '';
@@ -36,7 +38,8 @@ class SessionManager extends EventEmitter {
       tool: session.tool.displayName,
       startTime: session.startTime,
       toolKey: session.tool.key,
-      workingDirectory: session.ptyManager.workingDir,
+      workingDirectory: this.getSessionWorkingDirectory(session),
+      mode: session.kind === 'claude-structured' ? 'structured' : 'terminal',
       hasUnreadCompletion: Boolean(session.hasUnreadCompletion),
       timedInputCount: session.timedInputs
         ? Array.from(session.timedInputs.values()).filter(item => item.sendAt > Date.now()).length
@@ -52,7 +55,7 @@ class SessionManager extends EventEmitter {
     return this.sessions.has(id);
   }
 
-  create({ toolKey, workingDirectory, name }) {
+  create({ toolKey, workingDirectory, name, claudeOptions }) {
     this.logger.info(`Creating session: toolKey=${toolKey || ''}, workingDirectory=${workingDirectory || '(default)'}`);
     const tool = getToolByKey(toolKey);
     if (!tool) {
@@ -62,6 +65,10 @@ class SessionManager extends EventEmitter {
       throw err;
     }
 
+    if (tool.key === 'claude-code') {
+      return this.createClaudeStructuredSession({ tool, workingDirectory, name, claudeOptions });
+    }
+
     const id = uuidv4();
     const buffer = new CircularBuffer(500000);
     const textHistory = new TextHistory({ maxBytes: 20 * 1024 * 1024, debugLabel: id });
@@ -125,16 +132,86 @@ class SessionManager extends EventEmitter {
     return session;
   }
 
+  createClaudeStructuredSession({ tool, workingDirectory, name, claudeOptions = {} }) {
+    const sessionDir = workingDirectory && String(workingDirectory).trim()
+      ? path.resolve(this.baseDir, String(workingDirectory).trim())
+      : this.baseDir;
+
+    if (!fs.existsSync(sessionDir)) {
+      const err = new Error(`Directory does not exist: ${sessionDir}`);
+      err.statusCode = 400;
+      this.logger.error(`Create Claude session failed: missing directory ${sessionDir}`);
+      throw err;
+    }
+
+    const id = uuidv4();
+    const session = new ClaudeStructuredSession({
+      id,
+      tool,
+      workingDir: sessionDir,
+      name: name || tool.displayName,
+      logger: this.logger,
+      options: claudeOptions
+    });
+
+    this.sessions.set(id, session);
+    session.on('event', event => this.emit('claude-event', { sessionId: id, event, session }));
+    session.on('exit', () => this.handleExit(session));
+    this.logSessionDiagnostics('claude-session-created', session, {}, { compact: true });
+
+    return session;
+  }
+
   write(id, data) {
     const session = this.get(id);
     if (!session) return false;
     this.markSessionInput(session, data);
+    if (session.kind === 'claude-structured') return session.write(data);
     return session.ptyManager.write(data);
   }
 
+  sendClaudeInput(id, text) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return false;
+    this.markSessionInput(session, text);
+    return session.sendUserMessage(text);
+  }
+
+  respondClaudePermission(id, permissionId, approved, action = null) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return false;
+    return session.respondPermission(permissionId, approved, action);
+  }
+
+  updateClaudeSettings(id, settings) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return null;
+    return session.updateSettings(settings || {});
+  }
+
+  abortClaude(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return false;
+    return session.abort('Aborted by user');
+  }
+
+  resumeClaude(id, resumeSessionId) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return false;
+    const historyMessages = this.readClaudeTranscriptMessages(this.getSessionWorkingDirectory(session), resumeSessionId);
+    return session.selectResumeSession(resumeSessionId, historyMessages);
+  }
+
+  listClaudeResumeSessions(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return null;
+    return this.scanClaudeProjectSessions(this.getSessionWorkingDirectory(session));
+  }
+
   resize(id, cols, rows) {
     const session = this.get(id);
     if (!session) return false;
+    if (session.kind === 'claude-structured') return true;
     if (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -145,6 +222,7 @@ class SessionManager extends EventEmitter {
   redraw(id, cols, rows) {
     const session = this.get(id);
     if (!session) return false;
+    if (session.kind === 'claude-structured') return true;
     if (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -162,6 +240,11 @@ class SessionManager extends EventEmitter {
   markCompletionRead(id) {
     const session = this.get(id);
     if (!session) return null;
+    if (session.kind === 'claude-structured') {
+      session.markCompletionRead();
+      this.logSessionDiagnostics('completion-read', session, {}, { compact: true });
+      return session;
+    }
     session.hasUnreadCompletion = false;
     session.awaitingCompletion = false;
     session.isThinking = false;
@@ -288,6 +371,10 @@ class SessionManager extends EventEmitter {
     this.clearTimedInputs(session);
     this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
     this.disposeSessionHistory(session);
+    if (session.kind === 'claude-structured') {
+      session.ptyManager.kill();
+      return true;
+    }
     session.ptyManager.kill();
     this.sessions.delete(id);
     this.emit('exit', { sessionId: id, session });
@@ -307,6 +394,7 @@ class SessionManager extends EventEmitter {
   getHistory(id) {
     const session = this.get(id);
     if (!session) return null;
+    if (session.kind === 'claude-structured') return session.getHistory();
     const historySource = session.renderedHistory || session.textHistory;
     return {
       success: true,
@@ -321,6 +409,7 @@ class SessionManager extends EventEmitter {
   getCatchupOutput(id) {
     const session = this.get(id);
     if (!session) return null;
+    if (session.kind === 'claude-structured') return session.getCatchupOutput();
 
     const bufferHistory = session.buffer.getAfter(0);
     if (bufferHistory.length > 0) {
@@ -350,6 +439,201 @@ class SessionManager extends EventEmitter {
     return session ? this.getSessionDiagnostics(session) : null;
   }
 
+  getClaudeSnapshot(id) {
+    const session = this.get(id);
+    if (!session || session.kind !== 'claude-structured') return null;
+    return session.snapshot();
+  }
+
+  scanClaudeProjectSessions(workingDirectory) {
+    const projectDir = this.getClaudeProjectDir(workingDirectory);
+    if (!projectDir || !fs.existsSync(projectDir)) return [];
+    const files = fs.readdirSync(projectDir)
+      .filter(file => /^[0-9a-f-]{36}\.jsonl$/i.test(file))
+      .map(file => {
+        const fullPath = path.join(projectDir, file);
+        const stat = fs.statSync(fullPath);
+        return {
+          id: file.replace(/\.jsonl$/i, ''),
+          path: fullPath,
+          mtimeMs: stat.mtimeMs,
+          size: stat.size
+        };
+      })
+      .sort((a, b) => b.mtimeMs - a.mtimeMs)
+      .slice(0, 40);
+
+    return files.map(file => this.describeClaudeSessionFile(file));
+  }
+
+  getClaudeProjectDir(workingDirectory) {
+    const cwd = path.resolve(workingDirectory || this.baseDir);
+    const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-');
+    return path.join(os.homedir(), '.claude', 'projects', encoded);
+  }
+
+  describeClaudeSessionFile(file) {
+    let cwd = '';
+    let firstText = '';
+    let lastText = '';
+    try {
+      const content = fs.readFileSync(file.path, 'utf8');
+      const lines = content.split('\n').filter(Boolean);
+      for (const line of lines) {
+        const parsed = this.parseClaudeJsonLine(line);
+        if (!parsed) continue;
+        if (!cwd && typeof parsed.cwd === 'string') cwd = parsed.cwd;
+        const text = this.extractClaudeTranscriptText(parsed);
+        if (!text) continue;
+        if (!firstText) firstText = text;
+        lastText = text;
+      }
+    } catch (error) {
+      this.logger.debugInfo?.(`[claude-resume] Failed to read ${file.path}: ${error.message}`);
+    }
+    return {
+      id: file.id,
+      cwd,
+      updatedAt: file.mtimeMs,
+      size: file.size,
+      firstText: firstText ? previewText(firstText, 120) : '',
+      lastText: lastText ? previewText(lastText, 160) : ''
+    };
+  }
+
+  readClaudeTranscriptMessages(workingDirectory, resumeSessionId) {
+    const id = String(resumeSessionId || '').trim();
+    if (!/^[0-9a-f-]{36}$/i.test(id)) return [];
+    const filePath = path.join(this.getClaudeProjectDir(workingDirectory), `${id}.jsonl`);
+    if (!fs.existsSync(filePath)) return [];
+
+    const messages = [];
+    try {
+      const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        const record = this.parseClaudeJsonLine(line);
+        if (!record || record.isSidechain) continue;
+        messages.push(...this.mapClaudeTranscriptRecord(record));
+      }
+    } catch (error) {
+      this.logger.debugInfo?.(`[claude-resume] Failed to backfill ${filePath}: ${error.message}`);
+      return [];
+    }
+
+    const maxMessages = 1000;
+    const visible = messages.filter(Boolean).slice(-maxMessages);
+    if (messages.length > maxMessages) {
+      visible.unshift({
+        id: uuidv4(),
+        kind: 'event',
+        level: 'info',
+        text: `Showing the latest ${maxMessages} resumed transcript items.`,
+        createdAt: Date.now()
+      });
+    }
+    return visible;
+  }
+
+  mapClaudeTranscriptRecord(record) {
+    const createdAt = Number.isFinite(Date.parse(record.timestamp)) ? Date.parse(record.timestamp) : Date.now();
+    const message = record.message || {};
+    const content = message.content;
+    if (record.type === 'user') {
+      if (typeof content === 'string') {
+        const text = content.trim();
+        return text ? [{ id: uuidv4(), kind: 'user', text, createdAt }] : [];
+      }
+      if (Array.isArray(content)) {
+        return content.flatMap(item => {
+          if (!item || typeof item !== 'object') return [];
+          if (item.type === 'tool_result') {
+            const text = this.textFromClaudeContent(item.content).trim();
+            return text ? [{
+              id: uuidv4(),
+              kind: 'tool-result',
+              toolUseId: item.tool_use_id,
+              text,
+              isError: Boolean(item.is_error),
+              createdAt
+            }] : [];
+          }
+          if (item.type === 'text' && typeof item.text === 'string' && item.text.trim()) {
+            return [{ id: uuidv4(), kind: 'user', text: item.text.trim(), createdAt }];
+          }
+          return [];
+        });
+      }
+    }
+
+    if (record.type === 'assistant' && Array.isArray(content)) {
+      const mapped = [];
+      const text = this.textFromClaudeContent(content).trim();
+      if (text) mapped.push({ id: uuidv4(), kind: 'assistant', text, createdAt });
+      for (const item of content) {
+        if (!item || item.type !== 'tool_use') continue;
+        mapped.push({
+          id: uuidv4(),
+          kind: 'tool',
+          name: item.name || 'tool',
+          summary: this.summarizeClaudeToolInput(item.input),
+          input: item.input,
+          toolUseId: item.id,
+          createdAt
+        });
+      }
+      return mapped;
+    }
+
+    if (record.type === 'summary' && typeof record.summary === 'string' && record.summary.trim()) {
+      return [{ id: uuidv4(), kind: 'event', level: 'info', text: `Summary: ${record.summary.trim()}`, createdAt }];
+    }
+
+    return [];
+  }
+
+  textFromClaudeContent(content) {
+    if (typeof content === 'string') return content;
+    if (!Array.isArray(content)) return '';
+    return content.map(item => {
+      if (!item || typeof item !== 'object') return '';
+      if (item.type === 'text' && typeof item.text === 'string') return item.text;
+      if (item.type === 'tool_result') return this.textFromClaudeContent(item.content);
+      return '';
+    }).filter(Boolean).join('\n');
+  }
+
+  summarizeClaudeToolInput(input) {
+    if (!input || typeof input !== 'object') return '';
+    if (typeof input.command === 'string') return input.command;
+    if (typeof input.file_path === 'string') return input.file_path;
+    if (typeof input.path === 'string') return input.path;
+    const serialized = JSON.stringify(input);
+    return serialized.length > 240 ? serialized.slice(0, 240) + '...' : serialized;
+  }
+
+  parseClaudeJsonLine(line) {
+    try {
+      return JSON.parse(line);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  extractClaudeTranscriptText(record) {
+    const message = record && record.message;
+    const content = message && message.content;
+    if (typeof content === 'string') return content.trim();
+    if (Array.isArray(content)) {
+      return content.map(item => {
+        if (!item || typeof item !== 'object') return '';
+        if (item.type === 'text' && typeof item.text === 'string') return item.text;
+        if (item.type === 'tool_use') return `[tool] ${item.name || 'tool'}`;
+        return '';
+      }).filter(Boolean).join('\n').trim();
+    }
+    return '';
+  }
+
   logHistoryRequest(id, req) {
     const session = this.get(id);
     if (!session) return;
@@ -457,6 +741,14 @@ class SessionManager extends EventEmitter {
   markSessionInput(session, data) {
     if (typeof data !== 'string' || data.length === 0) return;
     session.inputSeq = (session.inputSeq || 0) + 1;
+    if (session.kind === 'claude-structured') {
+      session.hasUnreadCompletion = false;
+      this.logSessionDiagnostics('session-input', session, {
+        inputSeq: session.inputSeq,
+        inputPreview: previewText(data)
+      }, { compact: true });
+      return;
+    }
     session.awaitingCompletion = true;
     session.isThinking = false;
     session.hasUnreadCompletion = false;
@@ -468,6 +760,7 @@ class SessionManager extends EventEmitter {
   }
 
   disposeSessionHistory(session) {
+    if (session.kind === 'claude-structured') return;
     if (session.renderedHistory) {
       session.renderedHistory.dispose();
       session.renderedHistory = null;
@@ -483,6 +776,21 @@ class SessionManager extends EventEmitter {
   }
 
   getSessionDiagnostics(session, extra = {}) {
+    if (session.kind === 'claude-structured') {
+      return {
+        sessionId: session.id,
+        sessionName: session.name,
+        toolKey: session.tool.key,
+        kind: session.kind,
+        historyMode: 'structured',
+        status: session.status,
+        workingDirectory: this.getSessionWorkingDirectory(session),
+        messages: session.messages.length,
+        pendingPermissions: session.pendingPermissions.size,
+        timedInputCount: session.timedInputs ? session.timedInputs.size : 0,
+        ...extra
+      };
+    }
     return {
       sessionId: session.id,
       sessionName: session.name,
@@ -497,6 +805,9 @@ class SessionManager extends EventEmitter {
   }
 
   getCompactSessionDiagnostics(session, extra = {}) {
+    if (session.kind === 'claude-structured') {
+      return this.getSessionDiagnostics(session, extra);
+    }
     const buffer = session.buffer.getDebugSnapshot();
     const textHistory = session.textHistory.getDebugSnapshot();
     const renderedHistory = session.renderedHistory ? session.renderedHistory.getDebugSnapshot() : null;
@@ -550,6 +861,10 @@ class SessionManager extends EventEmitter {
       : this.getSessionDiagnostics(session, extra);
     this.logger.debugInfo(`[history-debug] ${reason} ${JSON.stringify(payload)}`);
   }
+
+  getSessionWorkingDirectory(session) {
+    return session.workingDir || (session.ptyManager && session.ptyManager.workingDir) || this.baseDir;
+  }
 }
 
 module.exports = SessionManager;