repoburg 1.3.186 → 1.3.188

package/agent-pane/backend/src/codex/codex-provider.ts

@@ -1,5 +1,7 @@
 import { Codex, type Thread, type ThreadEvent, type ThreadItem, type ThreadOptions } from '@openai/codex-sdk';
 import { v4 as uuidv4 } from 'uuid';
+import Database from 'better-sqlite3';
+import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
 import { getDb } from '../db/index.ts';
 import { broadcast } from '../ws/index.ts';
 import { mapItemData, getItemStatus } from './item-mapper.ts';
@@ -213,9 +215,12 @@ function handleEvent(event: ThreadEvent, sessionId: string, turnId: string): voi
       const usage = event.usage;
       db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?')
         .run('completed', JSON.stringify(usage), now, turnId);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
+      db.prepare('UPDATE sessions SET is_running = 0, status = ?, has_unreviewed = 1, updated_at = ? WHERE id = ?')
         .run('active', now, sessionId);
-      broadcast('turn:completed', { sessionId, turnId, usage });
+      broadcast('turn:completed', { sessionId, turnId, usage, hasUnreviewed: true });
+
+      // Auto-generate session title from first turn (if title is still null)
+      syncThreadTitle(sessionId);
       break;
     }
 
@@ -257,4 +262,102 @@ function makeItem(
     created_at: createdAt,
     updated_at: updatedAt,
   };
+}
+
+/** Tracks sessions currently generating titles — prevents duplicate throwaway threads. */
+const titleGenerating = new Set<string>();
+
+/** Generate a title for the session using a throwaway Codex thread.
+ *  Only runs once per session — guarded by title === null AND titleGenerating set. */
+function syncThreadTitle(sessionId: string): void {
+  const db = getDb();
+  const session = db.prepare('SELECT title FROM sessions WHERE id = ?')
+    .get(sessionId) as { title: string | null } | undefined;
+  if (!session || session.title !== null) return; // Already has a title
+  if (titleGenerating.has(sessionId)) return; // Already generating
+
+  // Get the first turn's user_prompt and agent_response
+  const turn = db.prepare('SELECT user_prompt, agent_response FROM turns WHERE session_id = ? ORDER BY created_at ASC LIMIT 1')
+    .get(sessionId) as { user_prompt: string; agent_response: string | null } | undefined;
+  if (!turn) return;
+
+  // Mark as generating — prevents concurrent title generation for same session
+  titleGenerating.add(sessionId);
+
+  // Fire-and-forget — don't block the turn:completed handler
+  generateTitleAsync(sessionId, turn.user_prompt, turn.agent_response).finally(() => {
+    titleGenerating.delete(sessionId);
+  });
+}
+
+/** Create a throwaway Codex thread, ask for a title, update the session, then clean up. */
+async function generateTitleAsync(sessionId: string, userPrompt: string, agentResponse: string | null): Promise<void> {
+  let throwawayThreadId: string | null = null;
+  try {
+    const codex = new Codex();
+    const thread = codex.startThread({ skipGitRepoCheck: true });
+    throwawayThreadId = thread.id;
+
+    const truncatedPrompt = userPrompt.slice(0, 500);
+    const truncatedResponse = (agentResponse || '').slice(0, 500);
+
+    const titlePrompt = `Generate a concise 3-5 word title for this conversation. Reply with only the title, nothing else.\n\nUser asked: "${truncatedPrompt}"\n\nAgent responded: "${truncatedResponse}"`;
+
+    const result = await thread.run(titlePrompt);
+    const title = result.finalResponse.trim().replace(/^["']|["']$/g, '').slice(0, 100);
+
+    if (title) {
+      const db = getDb();
+      const now = new Date().toISOString();
+      db.prepare('UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?').run(title, now, sessionId);
+      broadcast('session:title', { sessionId, title });
+    }
+  } catch {
+    // Silently skip on error — session keeps null title
+  } finally {
+    // Clean up the throwaway thread
+    if (throwawayThreadId) {
+      cleanupThrowawayThread(throwawayThreadId);
+    }
+  }
+}
+
+/** Delete throwaway thread from Codex state DB, rollout file, and session_index.jsonl. */
+function cleanupThrowawayThread(threadId: string): void {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+
+  // 1. Delete from state DB and get rollout path
+  try {
+    const codexDb = new Database(`${home}/.codex/state_5.sqlite`);
+    const row = codexDb.prepare('SELECT rollout_path FROM threads WHERE id = ?')
+      .get(threadId) as { rollout_path: string } | undefined;
+
+    codexDb.prepare('DELETE FROM thread_spawn_edges WHERE child_thread_id = ? OR parent_thread_id = ?').run(threadId, threadId);
+    codexDb.prepare('DELETE FROM threads WHERE id = ?').run(threadId);
+    codexDb.close();
+
+    // 2. Delete rollout file
+    if (row?.rollout_path) {
+      try { unlinkSync(row.rollout_path); } catch { /* file may not exist */ }
+    }
+  } catch {
+    // DB not found — skip
+  }
+
+  // 3. Remove from session_index.jsonl
+  try {
+    const indexPath = `${home}/.codex/session_index.jsonl`;
+    const content = readFileSync(indexPath, 'utf-8');
+    const lines = content.trim().split('\n').filter((line) => {
+      try {
+        const entry = JSON.parse(line) as { id: string };
+        return entry.id !== threadId;
+      } catch {
+        return true; // keep unparseable lines
+      }
+    });
+    writeFileSync(indexPath, lines.join('\n') + '\n');
+  } catch {
+    // File not found — skip
+  }
 }

package/agent-pane/backend/src/db/index.ts

@@ -61,7 +61,31 @@ function createTables(database: DB): void {
       FOREIGN KEY (turn_id) REFERENCES turns(id) ON DELETE CASCADE
     );
 
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id          TEXT PRIMARY KEY,
+      path        TEXT NOT NULL UNIQUE,
+      label       TEXT,
+      deleted     INTEGER NOT NULL DEFAULT 0,
+      created_at  TEXT NOT NULL
+    );
+
     CREATE INDEX IF NOT EXISTS idx_turns_session_id ON turns(session_id);
     CREATE INDEX IF NOT EXISTS idx_items_turn_id ON items(turn_id);
+    CREATE INDEX IF NOT EXISTS idx_workspaces_path ON workspaces(path);
   `);
+
+  // Migration: add 'deleted' column to existing workspaces table if missing
+  const wsColumns = database.prepare("PRAGMA table_info(workspaces)").all() as { name: string }[];
+  if (!wsColumns.some((c) => c.name === 'deleted')) {
+    database.exec('ALTER TABLE workspaces ADD COLUMN deleted INTEGER NOT NULL DEFAULT 0');
+  }
+
+  // Migration: add 'lifecycle' + 'has_unreviewed' columns to existing sessions table
+  const sessColumns = database.prepare("PRAGMA table_info(sessions)").all() as { name: string }[];
+  if (!sessColumns.some((c) => c.name === 'lifecycle')) {
+    database.exec("ALTER TABLE sessions ADD COLUMN lifecycle TEXT NOT NULL DEFAULT 'working'");
+  }
+  if (!sessColumns.some((c) => c.name === 'has_unreviewed')) {
+    database.exec('ALTER TABLE sessions ADD COLUMN has_unreviewed INTEGER NOT NULL DEFAULT 0');
+  }
 }

package/agent-pane/backend/src/db/schema.ts

@@ -22,6 +22,8 @@ export interface Session {
   external_thread_id: string | null; // Codex thread ID for resume
   status: SessionStatus;
   is_running: number; // 0 | 1
+  lifecycle: string; // 'working' | 'finished'
+  has_unreviewed: number; // 0 | 1
   created_at: string; // ISO
   updated_at: string; // ISO
 }
@@ -59,6 +61,15 @@ export interface Item {
   updated_at: string;
 }
 
+// Workspaces — directory paths for grouping sessions in sidebar
+export interface Workspace {
+  id: string;
+  path: string; // directory path, e.g. "/Users/me/projects/my-app"
+  label: string | null; // optional custom label, null = use basename
+  deleted: number; // 0 = active, 1 = soft-deleted (hidden from sidebar)
+  created_at: string; // ISO
+}
+
 // Nested session detail for GET /api/sessions/:id
 export interface SessionDetail extends Session {
   turns: (Turn & { items: Item[] })[];

package/agent-pane/backend/src/index.ts

@@ -4,6 +4,7 @@ import { initDb } from './db/index.ts';
 import { initWs, handleUpgrade, getWss } from './ws/index.ts';
 import { registerSessionRoutes } from './routes/sessions.ts';
 import { registerTurnRoutes } from './routes/turns.ts';
+import { registerWorkspaceRoutes } from './routes/workspaces.ts';
 
 const PORT = 3001;
 
@@ -20,6 +21,7 @@ async function main(): Promise<void> {
   // Register routes
   await registerSessionRoutes(fastify);
   await registerTurnRoutes(fastify);
+  await registerWorkspaceRoutes(fastify);
 
   // Initialize WebSocket server (noServer mode)
   const wss = initWs();

package/agent-pane/backend/src/routes/sessions.ts

@@ -94,4 +94,41 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
 
     return { success: true };
   });
+
+  // PATCH /api/sessions/:id — update session (title, lifecycle, has_unreviewed)
+  fastify.patch<{ Params: { id: string }; Body: { title?: string; lifecycle?: string; has_unreviewed?: number } }>(
+    '/api/sessions/:id',
+    async (request, reply) => {
+      const { id } = request.params;
+      const { title, lifecycle, has_unreviewed } = request.body || {};
+      const db = getDb();
+
+      const existing = db.prepare('SELECT id FROM sessions WHERE id = ?').get(id);
+      if (!existing) {
+        return reply.code(404).send({ error: 'Session not found' });
+      }
+
+      const now = new Date().toISOString();
+      const updates: string[] = ['updated_at = ?'];
+      const params: (string | number | null)[] = [now];
+
+      if (title !== undefined) {
+        updates.push('title = ?');
+        params.push(title);
+      }
+      if (lifecycle !== undefined) {
+        updates.push('lifecycle = ?');
+        params.push(lifecycle);
+      }
+      if (has_unreviewed !== undefined) {
+        updates.push('has_unreviewed = ?');
+        params.push(has_unreviewed);
+      }
+
+      db.prepare(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`).run(...params, id);
+
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
+      return session;
+    },
+  );
 }

package/agent-pane/backend/src/routes/workspaces.ts

@@ -0,0 +1,110 @@
+import type { FastifyInstance } from 'fastify';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.ts';
+import type { Workspace } from '../db/schema.ts';
+
+const execFileAsync = promisify(execFile);
+
+export async function registerWorkspaceRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /api/workspaces — list ALL workspaces (active + soft-deleted)
+  fastify.get('/api/workspaces', async () => {
+    const rows = getDb()
+      .prepare('SELECT * FROM workspaces ORDER BY created_at ASC')
+      .all() as Workspace[];
+    return rows;
+  });
+
+  // POST /api/workspaces — create workspace (or restore if soft-deleted)
+  fastify.post<{ Body: { path: string; label?: string } }>(
+    '/api/workspaces',
+    async (request, reply) => {
+      const { path, label = null } = request.body || {};
+      if (!path || !path.trim()) {
+        return reply.code(400).send({ error: 'Path is required' });
+      }
+
+      const trimmedPath = path.trim();
+      const db = getDb();
+
+      // Check if workspace with this path already exists
+      const existing = db.prepare('SELECT * FROM workspaces WHERE path = ?').get(trimmedPath) as Workspace | undefined;
+
+      if (existing) {
+        if (existing.deleted === 0) {
+          return reply.code(409).send({ error: 'Workspace with this path already exists' });
+        }
+        // Restore soft-deleted workspace
+        db.prepare('UPDATE workspaces SET deleted = 0, label = ? WHERE id = ?').run(label, existing.id);
+        const restored = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(existing.id) as Workspace;
+        return restored;
+      }
+
+      // Create new workspace
+      const id = uuidv4();
+      const now = new Date().toISOString();
+      db.prepare(
+        'INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, ?, 0, ?)',
+      ).run(id, trimmedPath, label, now);
+
+      const workspace = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(id) as Workspace;
+      return workspace;
+    },
+  );
+
+  // GET /api/pick-directory — open native OS folder picker (macOS only)
+  fastify.get('/api/pick-directory', async (_request, reply) => {
+    try {
+      const { stdout } = await execFileAsync('osascript', [
+        '-e',
+        'POSIX path of (choose folder with prompt "Select a workspace directory")',
+      ]);
+      const path = stdout.trim().replace(/\/$/, '');
+      return { path };
+    } catch {
+      // User cancelled the dialog or osascript not available
+      return reply.code(204).send({ cancelled: true });
+    }
+  });
+
+  // POST /api/workspaces/hide — soft-delete workspace by path (creates record if not exists)
+  fastify.post<{ Body: { path: string } }>(
+    '/api/workspaces/hide',
+    async (request, reply) => {
+      const { path } = request.body || {};
+      if (!path || !path.trim()) {
+        return reply.code(400).send({ error: 'Path is required' });
+      }
+      const trimmedPath = path.trim();
+      const db = getDb();
+
+      const existing = db.prepare('SELECT * FROM workspaces WHERE path = ?').get(trimmedPath) as Workspace | undefined;
+      if (existing) {
+        db.prepare('UPDATE workspaces SET deleted = 1 WHERE id = ?').run(existing.id);
+      } else {
+        const id = uuidv4();
+        const now = new Date().toISOString();
+        db.prepare(
+          'INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, NULL, 1, ?)',
+        ).run(id, trimmedPath, now);
+      }
+
+      return { success: true };
+    },
+  );
+
+  // DELETE /api/workspaces/:id — soft-delete workspace by ID (does NOT delete sessions)
+  fastify.delete<{ Params: { id: string } }>('/api/workspaces/:id', async (request, reply) => {
+    const { id } = request.params;
+    const db = getDb();
+
+    const existing = db.prepare('SELECT id FROM workspaces WHERE id = ? AND deleted = 0').get(id);
+    if (!existing) {
+      return reply.code(404).send({ error: 'Workspace not found' });
+    }
+
+    db.prepare('UPDATE workspaces SET deleted = 1 WHERE id = ?').run(id);
+    return { success: true };
+  });
+}

package/agent-pane/frontend/src/api/client.ts

@@ -26,4 +26,16 @@ export async function apiDelete<T>(path: string): Promise<T> {
     throw new Error(`DELETE ${path} failed: ${res.status} ${res.statusText}`);
   }
   return res.json() as Promise<T>;
+}
+
+export async function apiPatch<T>(path: string, body?: unknown): Promise<T> {
+  const res = await fetch(`${API_BASE}${path}`, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  if (!res.ok) {
+    throw new Error(`PATCH ${path} failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json() as Promise<T>;
 }

package/agent-pane/frontend/src/api/sessions.ts

@@ -1,4 +1,4 @@
-import { apiGet, apiPost, apiDelete } from './client.ts';
+import { apiGet, apiPost, apiDelete, apiPatch } from './client.ts';
 import type { Session, SessionDetail, Turn } from '../types/index.ts';
 
 export function fetchSessions(): Promise<Session[]> {
@@ -28,4 +28,20 @@ export function submitPrompt(sessionId: string, userPrompt: string): Promise<Tur
 
 export function cancelTurn(sessionId: string): Promise<{ success: boolean }> {
   return apiPost<{ success: boolean }>(`/sessions/${sessionId}/cancel`);
+}
+
+export function renameSession(sessionId: string, title: string): Promise<Session> {
+  return apiPatch<Session>(`/sessions/${sessionId}`, { title });
+}
+
+export function markFinished(sessionId: string): Promise<Session> {
+  return apiPatch<Session>(`/sessions/${sessionId}`, { lifecycle: 'finished' });
+}
+
+export function reopenSession(sessionId: string): Promise<Session> {
+  return apiPatch<Session>(`/sessions/${sessionId}`, { lifecycle: 'working' });
+}
+
+export function clearUnreviewed(sessionId: string): Promise<Session> {
+  return apiPatch<Session>(`/sessions/${sessionId}`, { has_unreviewed: 0 });
 }

package/agent-pane/frontend/src/api/websocket.ts

@@ -103,6 +103,7 @@ interface TurnCompletedPayload {
   sessionId: string;
   turnId: string;
   usage: TokenUsage;
+  hasUnreviewed?: boolean;
 }
 
 interface TurnFailedPayload {
@@ -111,6 +112,11 @@ interface TurnFailedPayload {
   error: string;
 }
 
+interface SessionTitlePayload {
+  sessionId: string;
+  title: string;
+}
+
 const HANDLERS: Record<string, WsEventHandler> = {
   'turn:started': (data) => {
     const p = data as TurnEventPayload;
@@ -130,10 +136,14 @@ const HANDLERS: Record<string, WsEventHandler> = {
   },
   'turn:completed': (data) => {
     const p = data as TurnCompletedPayload;
-    useStore.getState().onTurnCompleted(p.sessionId, p.turnId, p.usage);
+    useStore.getState().onTurnCompleted(p.sessionId, p.turnId, p.usage, p.hasUnreviewed);
   },
   'turn:failed': (data) => {
     const p = data as TurnFailedPayload;
     useStore.getState().onTurnFailed(p.sessionId, p.turnId, p.error);
   },
+  'session:title': (data) => {
+    const p = data as SessionTitlePayload;
+    useStore.getState().onSessionTitle(p.sessionId, p.title);
+  },
 };

package/agent-pane/frontend/src/api/workspaces.ts

@@ -0,0 +1,24 @@
+import { apiGet, apiPost, apiDelete } from './client.ts';
+import type { Workspace } from '../types/index.ts';
+
+export function fetchWorkspaces(): Promise<Workspace[]> {
+  return apiGet<Workspace[]>('/workspaces');
+}
+
+export function createWorkspace(path: string, label?: string): Promise<Workspace> {
+  return apiPost<Workspace>('/workspaces', { path, label });
+}
+
+export function hideWorkspace(path: string): Promise<{ success: boolean }> {
+  return apiPost<{ success: boolean }>('/workspaces/hide', { path });
+}
+
+export function deleteWorkspace(id: string): Promise<{ success: boolean }> {
+  return apiDelete<{ success: boolean }>(`/workspaces/${id}`);
+}
+
+export async function pickDirectory(): Promise<{ path?: string; cancelled?: boolean }> {
+  const res = await fetch('/api/pick-directory');
+  if (res.status === 204) return { cancelled: true };
+  return res.json();
+}

package/agent-pane/frontend/src/components/CollapsibleToolCalls.tsx

@@ -0,0 +1,50 @@
+import { useState } from 'react';
+import { Wrench, ChevronRight } from 'lucide-react';
+import { MemoItemCard } from './TurnContent.tsx';
+import type { Item } from '../types/index.ts';
+
+const TOOL_TYPES = new Set(['command_execution', 'file_change', 'mcp_tool_call', 'web_search']);
+
+export function isToolItem(item: Item): boolean {
+  return TOOL_TYPES.has(item.type);
+}
+
+interface Props {
+  items: Item[];
+}
+
+export default function CollapsibleToolCalls({ items }: Props) {
+  const [expanded, setExpanded] = useState(false);
+
+  if (items.length === 0) return null;
+
+  const count = items.length;
+
+  return (
+    <div className="tool-calls">
+      <div
+        className="tool-calls-header"
+        onClick={() => setExpanded((e) => !e)}
+      >
+        <span className="tool-calls-icon">
+          <Wrench size={12} />
+        </span>
+        <span className="tool-calls-summary">
+          {count} tool call{count > 1 ? 's' : ''}
+        </span>
+        <ChevronRight
+          size={14}
+          className="tool-calls-chevron"
+          style={{ transform: expanded ? 'rotate(90deg)' : 'none' }}
+        />
+      </div>
+      {expanded && (
+        <div className="tool-calls-body">
+          {items.map((item) => (
+            <MemoItemCard key={item.id} item={item} />
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

package/agent-pane/frontend/src/components/CommandPalette.tsx

@@ -190,6 +190,17 @@ export default function CommandPalette() {
             })}
           </div>
         )}
+        <div className="palette-footer">
+          <span className="palette-footer-hint">
+            <span className="kbd">↑</span><span className="kbd">↓</span> Navigate
+          </span>
+          <span className="palette-footer-hint">
+            <span className="kbd">↵</span> Select
+          </span>
+          <span className="palette-footer-hint">
+            <span className="kbd">Esc</span> Close
+          </span>
+        </div>
       </div>
     </div>
   );