claude-ws 0.3.97 → 0.3.99

package/server.ts

@@ -113,6 +113,9 @@ app.prepare().then(async () => {
     pingTimeout: 10000,
   });
 
+  // Disconnect cleanup timers - keyed by attemptId
+  const disconnectTimers = new Map<string, NodeJS.Timeout>();
+
   // Socket.io connection handler
   io.on('connection', (socket) => {
     log.info(`Client connected: ${socket.id}`);
@@ -408,6 +411,14 @@ app.prepare().then(async () => {
     socket.on('attempt:subscribe', (data: { attemptId: string }) => {
       log.info(`[Server] Socket ${socket.id} subscribing to attempt:${data.attemptId}`);
       socket.join(`attempt:${data.attemptId}`);
+
+      // Clear disconnect timer if client reconnected
+      const timer = disconnectTimers.get(data.attemptId);
+      if (timer) {
+        clearTimeout(timer);
+        disconnectTimers.delete(data.attemptId);
+        log.info({ attemptId: data.attemptId }, '[Server] Cleared disconnect timer on reconnect');
+      }
     });
 
     // Unsubscribe from attempt logs
@@ -527,6 +538,48 @@ app.prepare().then(async () => {
       }
     );
 
+    // Handle manual compact request
+    socket.on('attempt:compact', async (data: { taskId: string }) => {
+      const { taskId: compactTaskId } = data;
+      log.info({ taskId: compactTaskId }, '[Server] Manual compact requested');
+
+      try {
+        const task = await db.query.tasks.findFirst({
+          where: eq(schema.tasks.id, compactTaskId),
+        });
+        if (!task) { socket.emit('error', { message: 'Task not found' }); return; }
+
+        const project = await db.query.projects.findFirst({
+          where: eq(schema.projects.id, task.projectId),
+        });
+        if (!project) { socket.emit('error', { message: 'Project not found' }); return; }
+
+        const conversationSummary = await sessionManager.getConversationSummary(compactTaskId);
+
+        const compactAttemptId = nanoid();
+        await db.insert(schema.attempts).values({
+          id: compactAttemptId,
+          taskId: compactTaskId,
+          prompt: 'Manual compact: summarize conversation context',
+          displayPrompt: 'Compacting conversation...',
+          status: 'running',
+        });
+
+        socket.join(`attempt:${compactAttemptId}`);
+        socket.emit('attempt:started', { attemptId: compactAttemptId, taskId: compactTaskId });
+        io.to(`attempt:${compactAttemptId}`).emit('context:compacting', { attemptId: compactAttemptId, taskId: compactTaskId });
+
+        agentManager.compact({
+          attemptId: compactAttemptId,
+          projectPath: project.path,
+          conversationSummary,
+        });
+      } catch (error) {
+        log.error({ error }, '[Server] Manual compact failed');
+        socket.emit('error', { message: 'Compact failed: ' + (error instanceof Error ? error.message : 'Unknown error') });
+      }
+    });
+
     // ========================================
     // Inline Edit Socket Handlers
     // ========================================
@@ -688,6 +741,49 @@ app.prepare().then(async () => {
 
     socket.on('disconnect', () => {
       log.info(`Client disconnected: ${socket.id}`);
+
+      // Find all attempt rooms this socket was in
+      // Socket.io automatically removes the socket from rooms on disconnect
+      // but we can check which rooms had this socket before disconnect
+      const socketRooms = Array.from(socket.rooms || []);
+      const attemptRooms = socketRooms
+        .filter(room => room.startsWith('attempt:'))
+        .map(room => room.replace('attempt:', ''));
+
+      for (const attemptId of attemptRooms) {
+        // Start grace timer for this attempt
+        if (disconnectTimers.has(attemptId)) continue; // Already has a timer
+
+        const timer = setTimeout(async () => {
+          disconnectTimers.delete(attemptId);
+
+          // Check if attempt room still has 0 clients
+          const room = io.sockets.adapter.rooms.get(`attempt:${attemptId}`);
+          if (room && room.size > 0) {
+            log.info({ attemptId, clients: room.size }, '[Server] Attempt room still has clients, skipping cleanup');
+            return;
+          }
+
+          // Check if attempt is still running
+          if (!agentManager.isRunning(attemptId)) return;
+
+          log.info({ attemptId }, '[Server] No clients for 30s, cancelling orphaned attempt');
+
+          // Cancel the agent
+          agentManager.cancel(attemptId);
+
+          // Mark subagents as orphaned in DB
+          try {
+            await db.update(schema.subagents)
+              .set({ status: 'orphaned', completedAt: Date.now() })
+              .where(eq(schema.subagents.attemptId, attemptId));
+          } catch (err) {
+            log.error({ err, attemptId }, '[Server] Failed to mark subagents as orphaned on disconnect');
+          }
+        }, 30000);
+
+        disconnectTimers.set(attemptId, timer);
+      }
     });
   });
 
@@ -857,21 +953,53 @@ app.prepare().then(async () => {
   });
 
   // Handle AskUserQuestion detection from AgentManager
-  agentManager.on('question', ({ attemptId, toolUseId, questions }) => {
+  agentManager.on('question', async ({ attemptId, toolUseId, questions }) => {
     log.info({
       attemptId,
       toolUseId,
       questionCount: questions?.length,
       questions: questions?.map((q: any) => ({ header: q.header, question: q.question?.substring(0, 50) }))
     }, '[Server] AskUserQuestion detected');
+
+    // Emit to attempt room (existing behavior)
     io.to(`attempt:${attemptId}`).emit('question:ask', {
       attemptId,
       toolUseId,
       questions,
     });
+
+    // Emit global question:new event for the questions panel
+    // Look up taskId from the attempt
+    try {
+      const attempt = await db.query.attempts.findFirst({
+        where: eq(schema.attempts.id, attemptId),
+      });
+      if (attempt) {
+        const task = await db.query.tasks.findFirst({
+          where: eq(schema.tasks.id, attempt.taskId),
+        });
+        io.emit('question:new', {
+          attemptId,
+          taskId: attempt.taskId,
+          taskTitle: task?.title || '',
+          projectId: task?.projectId || '',
+          toolUseId,
+          questions,
+          timestamp: Date.now(),
+        });
+      }
+    } catch (err) {
+      log.error({ err }, '[Server] Failed to emit global question:new');
+    }
+
     log.info(`[Server] Emitted question:ask to attempt:${attemptId}`);
   });
 
+  // Handle question resolved from AgentManager (answered or cancelled, including via REST API)
+  agentManager.on('questionResolved', ({ attemptId }) => {
+    io.emit('question:resolved', { attemptId });
+  });
+
   // Handle background shell detection from AgentManager (Bash with run_in_background=true)
   // NOTE: SDK spawns process but it dies when conversation ends.
   // We spawn our own detached shell that survives.
@@ -1038,6 +1166,31 @@ app.prepare().then(async () => {
     }
   });
 
+  // Handle "prompt too long" error - trigger auto-compact if enabled
+  agentManager.on('promptTooLong', async ({ attemptId }) => {
+    log.warn({ attemptId }, '[Server] Prompt too long detected');
+
+    try {
+      const autoCompactSetting = await db
+        .select()
+        .from(schema.appSettings)
+        .where(eq(schema.appSettings.key, 'auto_compact_enabled'))
+        .limit(1);
+
+      const autoCompactEnabled = autoCompactSetting.length > 0 && autoCompactSetting[0].value === 'true';
+
+      io.to(`attempt:${attemptId}`).emit('context:prompt-too-long', {
+        attemptId,
+        autoCompactEnabled,
+        message: autoCompactEnabled
+          ? 'Context limit exceeded. Auto-compacting...'
+          : 'Context limit exceeded. Use /compact to reduce context size, or start a new conversation.',
+      });
+    } catch (error) {
+      log.error({ error }, '[Server] Failed to handle prompt-too-long');
+    }
+  });
+
   // Register exit event handler
   agentManager.on('exit', async ({ attemptId, code }) => {
     // Get attempt to retrieve taskId and current status
@@ -1164,6 +1317,73 @@ app.prepare().then(async () => {
     if (attempt?.taskId) {
       io.emit('task:finished', { taskId: attempt.taskId, status });
     }
+
+    // Auto-compact check: if context exceeded threshold and auto-compact is enabled
+    if (status === 'completed' && usageStats?.contextHealth?.shouldCompact && attempt?.taskId) {
+      try {
+        const autoCompactSetting = await db
+          .select()
+          .from(schema.appSettings)
+          .where(eq(schema.appSettings.key, 'auto_compact_enabled'))
+          .limit(1);
+
+        const autoCompactEnabled = autoCompactSetting.length > 0 && autoCompactSetting[0].value === 'true';
+
+        if (autoCompactEnabled) {
+          const project = await db.query.projects.findFirst({
+            where: eq(schema.projects.id, (await db.query.tasks.findFirst({ where: eq(schema.tasks.id, attempt.taskId) }))!.projectId),
+          });
+
+          if (project) {
+            const conversationSummary = await sessionManager.getConversationSummary(attempt.taskId);
+
+            const compactAttemptId = nanoid();
+            await db.insert(schema.attempts).values({
+              id: compactAttemptId,
+              taskId: attempt.taskId,
+              prompt: 'Auto-compact: summarize conversation context',
+              displayPrompt: 'Auto-compacting conversation...',
+              status: 'running',
+            });
+
+            log.info({ attemptId: compactAttemptId, taskId: attempt.taskId }, '[Server] Auto-compacting conversation');
+            io.to(`attempt:${attemptId}`).emit('context:compacting', { attemptId: compactAttemptId, taskId: attempt.taskId });
+
+            agentManager.compact({
+              attemptId: compactAttemptId,
+              projectPath: project.path,
+              conversationSummary,
+            });
+          }
+        }
+      } catch (compactError) {
+        log.error({ compactError }, '[Server] Auto-compact failed');
+      }
+    }
+
+    // Mark any remaining in-progress subagents as orphaned in DB
+    const orphanedNodes = workflowTracker.markOrphaned(attemptId);
+    if (orphanedNodes.length > 0) {
+      log.info({ attemptId, count: orphanedNodes.length }, '[Server] Marking orphaned subagents');
+      for (const node of orphanedNodes) {
+        try {
+          await db.update(schema.subagents)
+            .set({
+              status: 'orphaned',
+              completedAt: node.completedAt || Date.now(),
+              durationMs: node.durationMs || null,
+            })
+            .where(eq(schema.subagents.id, node.id));
+        } catch (err) {
+          log.error({ err, nodeId: node.id }, '[Server] Failed to mark subagent as orphaned');
+        }
+      }
+    }
+
+    // Clean up in-memory tracking data for this attempt to prevent unbounded growth
+    usageTracker.clearSession(attemptId);
+    workflowTracker.clearWorkflow(attemptId);
+    gitStatsCache.clear(attemptId);
   });
 
   // Forward tracking module events to Socket.io clients
@@ -1177,14 +1397,71 @@ app.prepare().then(async () => {
   });
 
   // Workflow tracking (subagent execution chain)
-  workflowTracker.on('workflow-update', ({ attemptId, workflow }) => {
-    const summary = workflowTracker.getWorkflowSummary(attemptId);
-    if (summary) {
-      log.info({ attemptId, chain: summary.chain }, '[Server] Emitting status:workflow');
+  workflowTracker.on('workflow-update', ({ attemptId }) => {
+    const expanded = workflowTracker.getExpandedWorkflow(attemptId);
+    if (expanded) {
+      log.info({ attemptId, chain: expanded.summary.chain }, '[Server] Emitting status:workflow');
       io.to(`attempt:${attemptId}`).emit('status:workflow', {
         attemptId,
-        workflow: summary,
+        nodes: expanded.nodes,
+        messages: expanded.messages,
+        summary: expanded.summary,
       });
+
+      // Also emit global workflow:update for cross-task awareness
+      // Look up taskId and title for the attempt
+      db.query.attempts.findFirst({
+        where: eq(schema.attempts.id, attemptId),
+      }).then(attempt => {
+        if (attempt) {
+          db.query.tasks.findFirst({
+            where: eq(schema.tasks.id, attempt.taskId),
+          }).then(task => {
+            io.emit('workflow:update', {
+              attemptId,
+              taskId: attempt.taskId,
+              taskTitle: task?.title || 'Unknown',
+              summary: expanded.summary,
+            });
+          }).catch(() => {});
+        }
+      }).catch(() => {});
+    }
+  });
+
+  // Persist subagent start to DB
+  workflowTracker.on('subagent-start', async ({ attemptId, node }) => {
+    try {
+      await db.insert(schema.subagents).values({
+        id: node.id,
+        attemptId,
+        type: node.type,
+        name: node.name || null,
+        parentId: node.parentId,
+        teamName: node.teamName || null,
+        status: 'in_progress',
+        depth: node.depth,
+        startedAt: node.startedAt || Date.now(),
+      });
+    } catch (err) {
+      log.error({ err, attemptId, nodeId: node.id }, '[Server] Failed to persist subagent start');
+    }
+  });
+
+  // Persist subagent end to DB
+  workflowTracker.on('subagent-end', async ({ attemptId, node }) => {
+    try {
+      const dbStatus = node.status as 'in_progress' | 'completed' | 'failed' | 'orphaned';
+      await db.update(schema.subagents)
+        .set({
+          status: dbStatus,
+          completedAt: node.completedAt || Date.now(),
+          durationMs: node.durationMs || null,
+          error: node.error || null,
+        })
+        .where(eq(schema.subagents.id, node.id));
+    } catch (err) {
+      log.error({ err, attemptId, nodeId: node.id }, '[Server] Failed to persist subagent end');
     }
   });
 

package/src/app/[locale]/not-found.tsx

@@ -3,13 +3,16 @@
 // Force dynamic rendering to avoid Next.js 16 Turbopack build bug
 export const dynamic = 'force-dynamic';
 
+import { useTranslations } from 'next-intl';
+
 export default function NotFound() {
+  const t = useTranslations('notFound');
   return (
     <div style={{ padding: '2rem', fontFamily: 'system-ui', textAlign: 'center' }}>
-      <h1>404 - Page Not Found</h1>
-      <p>The page you're looking for doesn't exist.</p>
+      <h1>{t('title')}</h1>
+      <p>{t('description')}</p>
       <a href="/" style={{ color: '#0070f3', textDecoration: 'underline' }}>
-        Go back home
+        {t('goHome')}
       </a>
     </div>
   );

package/src/app/[locale]/page.tsx

@@ -11,6 +11,8 @@ import { SettingsPage } from '@/components/settings/settings-page';
 import { SetupDialog } from '@/components/settings/setup-dialog';
 import { SidebarPanel, FileTabsPanel, DiffTabsPanel } from '@/components/sidebar';
 import { RightSidebar } from '@/components/right-sidebar';
+import { QuestionsPanel } from '@/components/questions/questions-panel';
+import { WorkflowPanel } from '@/components/workflow/workflow-panel';
 import { PluginList } from '@/components/agent-factory/plugin-list';
 import { AccessAnywhereWizard } from '@/components/access-anywhere';
 import { TerminalPanel } from '@/components/terminal/terminal-panel';
@@ -24,8 +26,10 @@ import { useAgentFactoryUIStore } from '@/stores/agent-factory-ui-store';
 import { useSettingsUIStore } from '@/stores/settings-ui-store';
 import { useIsMobileViewport } from '@/hooks/use-mobile-viewport';
 import { useTerminalStore } from '@/stores/terminal-store';
+import { useTranslations } from 'next-intl';
 
 function KanbanApp() {
+  const tCommon = useTranslations('common');
   const [createTaskOpen, setCreateTaskOpen] = useState(false);
   const [setupOpen, setSetupOpen] = useState(false);
   const [searchQuery, setSearchQuery] = useState('');
@@ -134,7 +138,7 @@ function KanbanApp() {
     const tab = openTabs.find(t => t.id === tabId);
     if (tab?.isDirty) {
       const fileName = tab.filePath.split('/').pop() || tab.filePath;
-      if (!confirm(`"${fileName}" has unsaved changes. Close anyway?`)) {
+      if (!confirm(tCommon('unsavedChangesConfirm', { fileName }))) {
         return;
       }
     }
@@ -204,7 +208,7 @@ function KanbanApp() {
       <div className="flex h-screen items-center justify-center">
         <div className="flex items-center gap-3 text-muted-foreground">
           <img src="/logo.svg" alt="Logo" className="h-8 w-8 animate-spin" />
-          <span>Loading to Claude<span style={{ color: '#d87756' }}>.</span>WS</span>
+          <span>{tCommon('loadingApp')}</span>
         </div>
       </div>
     );
@@ -236,12 +240,12 @@ function KanbanApp() {
           ) : (
             <div className="flex h-full items-center justify-center">
               <div className="text-center">
-                <p className="text-muted-foreground mb-4">No projects configured</p>
+                <p className="text-muted-foreground mb-4">{tCommon('noProjectsConfigured')}</p>
                 <button
                   onClick={() => setSetupOpen(true)}
                   className="text-primary underline hover:no-underline"
                 >
-                  Set up a project
+                  {tCommon('setUpProject')}
                 </button>
               </div>
             </div>
@@ -283,6 +287,12 @@ function KanbanApp() {
         onCreateTask={() => setCreateTaskOpen(true)}
       />
 
+      {/* Questions Panel - pending questions sidebar */}
+      <QuestionsPanel />
+
+      {/* Workflow Panel - agent workflow sidebar */}
+      <WorkflowPanel />
+
       {/* Access Anywhere Wizard */}
       <AccessAnywhereWizard />
 

package/src/app/api/attempts/[id]/workflow/route.ts

@@ -0,0 +1,76 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { db, schema } from '@/lib/db';
+import { eq } from 'drizzle-orm';
+import { workflowTracker } from '@/lib/workflow-tracker';
+
+/**
+ * GET /api/attempts/[id]/workflow
+ *
+ * Returns the workflow tree for an attempt.
+ * - Running attempt: returns from workflowTracker in-memory state
+ * - Completed attempt: returns from DB subagents table
+ */
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id: attemptId } = await params;
+
+  // Try in-memory state first (for running attempts)
+  const expanded = workflowTracker.getExpandedWorkflow(attemptId);
+  if (expanded) {
+    return NextResponse.json({
+      source: 'live',
+      nodes: expanded.nodes,
+      messages: expanded.messages,
+      summary: expanded.summary,
+    });
+  }
+
+  // Fall back to DB (for completed attempts)
+  const subagents = await db.query.subagents.findMany({
+    where: eq(schema.subagents.attemptId, attemptId),
+  });
+
+  if (subagents.length === 0) {
+    return NextResponse.json({
+      source: 'db',
+      nodes: [],
+      messages: [],
+      summary: { chain: [], completedCount: 0, activeCount: 0, totalCount: 0 },
+    });
+  }
+
+  // Build summary from DB records
+  const rootNodes = subagents.filter(s => !s.parentId);
+  const chain = rootNodes.map(s => s.name || s.type);
+  const completedCount = subagents.filter(s => s.status === 'completed').length;
+  const activeCount = subagents.filter(s => s.status === 'in_progress').length;
+
+  // Map DB records to SubagentNode format
+  const nodes = subagents
+    .sort((a, b) => {
+      if (a.depth !== b.depth) return a.depth - b.depth;
+      return (a.startedAt || 0) - (b.startedAt || 0);
+    })
+    .map(s => ({
+      id: s.id,
+      type: s.type,
+      name: s.name,
+      status: s.status,
+      parentId: s.parentId,
+      depth: s.depth,
+      teamName: s.teamName,
+      startedAt: s.startedAt,
+      completedAt: s.completedAt,
+      durationMs: s.durationMs,
+      error: s.error,
+    }));
+
+  return NextResponse.json({
+    source: 'db',
+    nodes,
+    messages: [], // Messages are not persisted to DB
+    summary: { chain, completedCount, activeCount, totalCount: subagents.length },
+  });
+}

package/src/app/api/questions/answer/route.ts

@@ -0,0 +1,58 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { agentManager } from '@/lib/agent-manager';
+import { db, schema } from '@/lib/db';
+import { eq } from 'drizzle-orm';
+
+// POST /api/questions/answer - Answer a pending question via REST API
+// Used by the global questions panel (which doesn't have a socket connection to the attempt room)
+export async function POST(request: NextRequest) {
+  try {
+    const { attemptId, toolUseId, questions, answers } = await request.json() as {
+      attemptId: string;
+      toolUseId: string;
+      questions: unknown[];
+      answers: Record<string, string>;
+    };
+
+    if (!agentManager.hasPendingQuestion(attemptId)) {
+      return NextResponse.json(
+        { error: 'No pending question for this attempt' },
+        { status: 404 }
+      );
+    }
+
+    const success = agentManager.answerQuestion(attemptId, toolUseId, questions, answers);
+
+    if (!success) {
+      return NextResponse.json(
+        { error: 'Failed to answer question' },
+        { status: 400 }
+      );
+    }
+
+    // Save answer to database for persistence
+    const answerText = Object.entries(answers)
+      .map(([question, answer]) => `${question}: **${answer}**`)
+      .join('\n');
+
+    await db.insert(schema.attemptLogs).values({
+      attemptId,
+      type: 'json',
+      content: JSON.stringify({
+        type: 'user_answer',
+        questions,
+        answers,
+        displayText: `✓ You answered:\n${answerText}`
+      }),
+      createdAt: Date.now(),
+    });
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Error answering question:', error);
+    return NextResponse.json(
+      { error: 'Failed to answer question' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/questions/route.ts

@@ -0,0 +1,68 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { agentManager } from '@/lib/agent-manager';
+import { db, schema } from '@/lib/db';
+import { eq, inArray } from 'drizzle-orm';
+
+// GET /api/questions - Get all pending questions across running attempts
+// Optional query param: ?projectIds=id1,id2 to filter by project
+export async function GET(request: NextRequest) {
+  try {
+    const allPending = agentManager.getAllPendingQuestions();
+
+    if (allPending.length === 0) {
+      return NextResponse.json({ questions: [] });
+    }
+
+    // Look up attemptId → taskId → projectId from DB
+    const attemptIds = allPending.map((p) => p.attemptId);
+    const attempts = await db.query.attempts.findMany({
+      where: inArray(schema.attempts.id, attemptIds),
+    });
+
+    const attemptMap = new Map(attempts.map((a) => [a.id, a]));
+
+    // Get task info for all relevant tasks
+    const taskIds = [...new Set(attempts.map((a) => a.taskId))];
+    const tasks = taskIds.length > 0
+      ? await db.query.tasks.findMany({
+          where: inArray(schema.tasks.id, taskIds),
+        })
+      : [];
+    const taskMap = new Map(tasks.map((t) => [t.id, t]));
+
+    // Filter by projectIds if provided
+    const projectIdsParam = request.nextUrl.searchParams.get('projectIds');
+    const filterProjectIds = projectIdsParam ? projectIdsParam.split(',').filter(Boolean) : null;
+
+    const questions = allPending
+      .map((pending) => {
+        const attempt = attemptMap.get(pending.attemptId);
+        if (!attempt) return null;
+        const task = taskMap.get(attempt.taskId);
+        if (!task) return null;
+
+        return {
+          attemptId: pending.attemptId,
+          taskId: task.id,
+          taskTitle: task.title,
+          projectId: task.projectId,
+          toolUseId: pending.toolUseId,
+          questions: pending.questions,
+          timestamp: pending.timestamp,
+        };
+      })
+      .filter((q): q is NonNullable<typeof q> => {
+        if (!q) return false;
+        if (filterProjectIds && !filterProjectIds.includes(q.projectId)) return false;
+        return true;
+      });
+
+    return NextResponse.json({ questions });
+  } catch (error) {
+    console.error('Error getting pending questions:', error);
+    return NextResponse.json(
+      { error: 'Failed to get pending questions' },
+      { status: 500 }
+    );
+  }
+}