repoburg 1.3.202 → 1.3.209

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

@@ -1,565 +0,0 @@
-import type { FastifyInstance } from 'fastify';
-import path from 'node:path';
-import { v4 as uuidv4 } from 'uuid';
-import { getDb } from '../db/index.ts';
-import { getProvider } from '../providers/registry.ts';
-import type { Session, SessionDetail, Turn, Item, DiscussionThread, Attachment } from '../db/schema.ts';
-
-/** Raw DB row for turns — token_usage, attachments and runtime_input_ids are
- *  JSON strings, not parsed; no items field. */
-interface TurnRow extends Omit<Turn, 'token_usage' | 'items' | 'attachments' | 'runtime_input_ids'> {
-  token_usage: string | null;
-  attachments: string | null;
-  runtime_input_ids: string | null;
-}
-
-/** Raw DB row for items — data is a JSON string, not parsed. */
-interface ItemRow extends Omit<Item, 'data'> {
-  data: string | null;
-}
-
-export async function registerSessionRoutes(fastify: FastifyInstance): Promise<void> {
-  // GET /api/sessions — list all sessions
-  fastify.get('/api/sessions', async () => {
-    const rows = getDb().prepare('SELECT * FROM sessions ORDER BY created_at DESC').all() as Session[];
-    return rows;
-  });
-
-  // GET /api/sessions/:id — session with turns + items
-  fastify.get<{ Params: { id: string } }>('/api/sessions/:id', async (request, reply) => {
-    const { id } = request.params;
-    const db = getDb();
-
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
-    if (!session) {
-      return reply.code(404).send({ error: 'Session not found' });
-    }
-
-    // If the session is rewound, only show turns up to and including the rewind point
-    const turnFilter = session.rewound_at_turn_id
-      ? db.prepare('SELECT created_at FROM turns WHERE id = ?').get(session.rewound_at_turn_id) as { created_at: string } | undefined
-      : null;
-
-    const turnRows = turnFilter
-      ? db
-          .prepare('SELECT * FROM turns WHERE session_id = ? AND created_at <= ? ORDER BY created_at ASC')
-          .all(id, turnFilter.created_at) as TurnRow[]
-      : db
-          .prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC')
-          .all(id) as TurnRow[];
-
-    const itemRows = db
-      .prepare(
-        'SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?' +
-          (turnFilter ? ' AND created_at <= ?' : '') +
-          ') ORDER BY created_at ASC',
-      )
-      .all(...(turnFilter ? [id, turnFilter.created_at] : [id])) as ItemRow[];
-
-    // Parse item data from JSON string and group by turn_id
-    const itemsByTurn = new Map<string, Item[]>();
-    for (const row of itemRows) {
-      const item: Item = {
-        ...row,
-        data: row.data ? JSON.parse(row.data) : null,
-      };
-      const list = itemsByTurn.get(item.turn_id) ?? [];
-      list.push(item);
-      itemsByTurn.set(item.turn_id, list);
-    }
-
-    const detail: SessionDetail = {
-      ...session,
-      turns: turnRows.map((row) => ({
-        ...row,
-        token_usage: row.token_usage ? JSON.parse(row.token_usage) : null,
-        attachments: row.attachments ? (JSON.parse(row.attachments) as Attachment[]) : null,
-        runtime_input_ids: row.runtime_input_ids ? (JSON.parse(row.runtime_input_ids) as string[]) : null,
-        items: itemsByTurn.get(row.id) ?? [],
-      })),
-    };
-
-    // Fetch discussion threads for this session and attach to the response
-    const threadRows = db
-      .prepare('SELECT * FROM discussion_threads WHERE session_id = ? ORDER BY created_at ASC')
-      .all(id) as DiscussionThread[];
-
-    if (threadRows.length > 0) {
-      detail.threads = threadRows.map((tr) => ({
-        ...tr,
-        turns: detail.turns.filter((t) => t.thread_id === tr.id),
-      }));
-    }
-
-    // Restore persisted context-window usage so the status-bar counter survives reload.
-    const cuRow = db.prepare('SELECT context_usage FROM sessions WHERE id = ?').get(id) as
-      | { context_usage: string | null }
-      | undefined;
-    if (cuRow?.context_usage) {
-      try {
-        detail.contextUsage = JSON.parse(cuRow.context_usage) as SessionDetail['contextUsage'];
-      } catch {
-        // Corrupt JSON — leave contextUsage unset.
-      }
-    }
-
-    return detail;
-  });
-
-  // POST /api/sessions — create session
-  fastify.post<{
-    Body: { title?: string; runtime_type?: string; model?: string; model_reasoning_effort?: string; cwd?: string; runtime_config?: string };
-  }>('/api/sessions', {
-    schema: {
-      body: {
-        type: 'object',
-        properties: {
-          title: { type: 'string' },
-          runtime_type: { type: 'string' },
-          model: { type: ['string', 'null'] },
-          model_reasoning_effort: { type: ['string', 'null'] },
-          cwd: { type: ['string', 'null'] },
-          runtime_config: { type: ['string', 'null'] },
-        },
-      },
-    },
-  }, async (request) => {
-    const {
-      title = null,
-      runtime_type = 'codex',
-      model = null,
-      model_reasoning_effort = null,
-      cwd = null,
-      runtime_config = null,
-    } = request.body || {};
-    const id = uuidv4();
-    const now = new Date().toISOString();
-
-    getDb()
-      .prepare(
-        `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, cwd, external_thread_id, status, is_running, created_at, updated_at, runtime_config)
-         VALUES (?, ?, ?, ?, ?, ?, NULL, 'active', 0, ?, ?, ?)`,
-      )
-      .run(id, title, runtime_type, model, model_reasoning_effort, cwd, now, now, runtime_config);
-
-    const session = getDb().prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
-    return session;
-  });
-
-  // DELETE /api/sessions/:id — delete session (cascade)
-  fastify.delete<{ Params: { id: string } }>('/api/sessions/:id', async (request, reply) => {
-    const { id } = request.params;
-    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' });
-    }
-
-    // Delete items first (turns cascade via FK, but better-sqlite3 needs explicit cascade if pragma is set)
-    db.prepare('DELETE FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?)').run(id);
-    db.prepare('DELETE FROM turns WHERE session_id = ?').run(id);
-    db.prepare('DELETE FROM sessions WHERE id = ?').run(id);
-
-    return { success: true };
-  });
-
-  // PATCH /api/sessions/:id — update session (title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config, cwd)
-  fastify.patch<{
-    Params: { id: string };
-    Body: {
-      title?: string;
-      lifecycle?: string;
-      has_unreviewed?: number;
-      model?: string | null;
-      model_reasoning_effort?: string | null;
-      runtime_config?: string | null;
-      runtime_type?: string;
-      cwd?: string | null;
-    };
-  }>('/api/sessions/:id', {
-    schema: {
-      body: {
-        type: 'object',
-        properties: {
-          title: { type: 'string' },
-          lifecycle: { type: 'string' },
-          has_unreviewed: { type: 'number' },
-          model: { type: ['string', 'null'] },
-          model_reasoning_effort: { type: ['string', 'null'] },
-          runtime_config: { type: ['string', 'null'] },
-          runtime_type: { type: 'string' },
-          cwd: { type: ['string', 'null'] },
-        },
-      },
-    },
-  }, async (request, reply) => {
-    const { id } = request.params;
-    const { title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config, runtime_type, cwd } = request.body || {};
-    const db = getDb();
-
-    const existing = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
-    if (!existing) {
-      return reply.code(404).send({ error: 'Session not found' });
-    }
-
-    // Block provider switch while a turn is running
-    if (runtime_type !== undefined && runtime_type !== existing.runtime_type && existing.is_running) {
-      return reply.code(409).send({ error: 'Cannot switch provider while a turn is running' });
-    }
-
-    const now = new Date().toISOString();
-    const updates: string[] = ['updated_at = ?'];
-    const params: (string | number | null)[] = [now];
-
-    let providerChanged = false;
-
-    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);
-    }
-
-    // Provider switch — clear model/reasoning if not explicitly provided
-    if (runtime_type !== undefined && runtime_type !== existing.runtime_type) {
-      providerChanged = true; // different provider can't resume the old thread
-      updates.push('runtime_type = ?');
-      params.push(runtime_type);
-
-      // Clear model if not explicitly set in this request
-      if (model === undefined) {
-        updates.push('model = ?');
-        params.push(null);
-      }
-      // Clear reasoning if not explicitly set
-      if (model_reasoning_effort === undefined) {
-        updates.push('model_reasoning_effort = ?');
-        params.push(null);
-      }
-    }
-
-    // Workspace (cwd) change — the runtime thread belongs to the old
-    // workspace backend, so it is cleared like a provider switch; the next
-    // turn creates a fresh runtime session on the new workspace.
-    // Compare resolve-normalized paths — cosmetic differences (trailing
-    // slash) are not a workspace change.
-    let workspaceChanged = false;
-    if (cwd !== undefined) {
-      const oldAbs = existing.cwd ? path.resolve(existing.cwd) : null;
-      const newAbs = cwd ? path.resolve(cwd) : null;
-      workspaceChanged = oldAbs !== newAbs;
-      if (workspaceChanged && existing.is_running) {
-        return reply.code(409).send({ error: 'Cannot change workspace while a turn is running' });
-      }
-      updates.push('cwd = ?');
-      params.push(cwd);
-    }
-
-    // Model and reasoning changes update DB columns but do NOT clear the thread.
-    // The Claude SDK supports query({ resume: sessionId, model: newModel }) —
-    // changing the model within the same provider preserves conversation context.
-    // In streaming-input mode, also call query.setModel() on the live session
-    // so the CLI switches models without restarting.
-    if (model !== undefined) {
-      updates.push('model = ?');
-      params.push(model);
-      // If the provider supports mid-session model switching and the model
-      // actually changed (same provider), update the live query.
-      if (model !== existing.model && !providerChanged) {
-        const provider = getProvider(existing.runtime_type);
-        if (provider.setModel) {
-          provider.setModel(id, model ?? '').catch((err) => {
-            console.error(`[patch] setModel failed for session ${id}:`, err);
-          });
-        }
-      }
-    }
-    if (model_reasoning_effort !== undefined) {
-      updates.push('model_reasoning_effort = ?');
-      params.push(model_reasoning_effort);
-    }
-    if (runtime_config !== undefined) {
-      updates.push('runtime_config = ?');
-      params.push(runtime_config);
-    }
-
-    db.prepare(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`).run(...params, id);
-
-    // Clear the thread when the PROVIDER or WORKSPACE changes — the runtime
-    // session belongs to the old provider/backend and cannot be resumed.
-    // Model/reasoning changes within the same provider keep the thread intact.
-    if (providerChanged || workspaceChanged) {
-      if (existing.external_thread_id) {
-        db.prepare('UPDATE sessions SET external_thread_id = NULL, rewound_at_turn_id = NULL, pre_rewind_thread_id = NULL, updated_at = ? WHERE id = ?').run(now, id);
-      }
-      // Drop the in-memory entry even without a persisted thread id (stale state).
-      getProvider(existing.runtime_type).clearThread(id);
-    }
-
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
-    return session;
-  });
-
-  // POST /api/sessions/:id/rewind — non-destructive rewind: hide turns after target, fork provider session
-  fastify.post<{ Params: { id: string }; Body: { turn_id: string } }>(
-    '/api/sessions/:id/rewind',
-    {
-      schema: {
-        body: {
-          type: 'object',
-          required: ['turn_id'],
-          properties: {
-            turn_id: { type: 'string' },
-          },
-        },
-      },
-    },
-    async (request, reply) => {
-      const { id } = request.params;
-      const { turn_id } = request.body || {};
-      if (!turn_id) {
-        return reply.code(400).send({ error: 'turn_id is required' });
-      }
-
-      const db = getDb();
-      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
-      if (!session) {
-        return reply.code(404).send({ error: 'Session not found' });
-      }
-      if (session.is_running) {
-        return reply.code(409).send({ error: 'Cannot rewind while a turn is running' });
-      }
-
-      const targetTurnFull = db.prepare('SELECT * FROM turns WHERE id = ? AND session_id = ?').get(turn_id, id) as
-        | Turn
-        | undefined;
-      if (!targetTurnFull) {
-        return reply.code(404).send({ error: 'Turn not found' });
-      }
-
-      const provider = getProvider(session.runtime_type);
-
-      // RUNTIME-FIRST (repoburg in-place truncation): hard-delete the runtime
-      // history after the target turn BEFORE any local change. Errors pass
-      // through — on failure the local view stays untouched and consistent
-      // with the runtime (e.g. 400 summary-in-range from until-here).
-      if (provider.rewindRuntime) {
-        await provider.rewindRuntime(session, targetTurnFull);
-
-        // Platform-parity HARD DELETE: the runtime history after the anchor
-        // is permanently gone, so mirror it locally — delete the local turns
-        // after the target and leave NO rewind marker (nothing to restore).
-        // Stale markers are cleared too: a marker would hide every turn
-        // created after the rewind (GET /:id filters by rewound_at_turn_id).
-        const now2 = new Date().toISOString();
-        db.prepare(
-          'DELETE FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ? AND created_at > ?)',
-        ).run(id, targetTurnFull.created_at);
-        db.prepare('DELETE FROM turns WHERE session_id = ? AND created_at > ?').run(
-          id,
-          targetTurnFull.created_at,
-        );
-        db.prepare(
-          'UPDATE sessions SET rewound_at_turn_id = NULL, pre_rewind_thread_id = NULL, updated_at = ? WHERE id = ?',
-        ).run(now2, id);
-        const truncated = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
-        return truncated;
-      }
-
-      const now = new Date().toISOString();
-
-      // Mark the session as rewound (non-destructive — turns are NOT deleted, just hidden)
-      // Save the original external_thread_id only on the first rewind (don't overwrite on subsequent rewinds)
-      // Use explicit two-step logic instead of COALESCE to avoid any evaluation-order ambiguity
-      if (!session.pre_rewind_thread_id && session.external_thread_id) {
-        db.prepare(
-          'UPDATE sessions SET rewound_at_turn_id = ?, pre_rewind_thread_id = ?, updated_at = ? WHERE id = ?',
-        ).run(turn_id, session.external_thread_id, now, id);
-        console.log(`[rewind] saved pre_rewind_thread_id=${session.external_thread_id} for session ${id}`);
-      } else {
-        db.prepare(
-          'UPDATE sessions SET rewound_at_turn_id = ?, updated_at = ? WHERE id = ?',
-        ).run(turn_id, now, id);
-        console.log(`[rewind] pre_rewind_thread_id already set (${session.pre_rewind_thread_id}) or external_thread_id is null for session ${id}`);
-      }
-
-      // Fork the provider-native session so the provider has conversation context up to the target turn
-      if (provider.forkSession) {
-        try {
-          const forkedId = await provider.forkSession(session, targetTurnFull);
-          if (forkedId) {
-            db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?')
-              .run(forkedId, now, id);
-            console.log(`[rewind] forked to ${forkedId} for session ${id}`);
-          } else {
-            console.warn(`[rewind] forkSession returned null for session ${id} (external_thread_id=${session.external_thread_id}, upToMessageId=${targetTurnFull.external_turn_id})`);
-          }
-        } catch (err) {
-          console.error(`[rewind] forkSession threw for session ${id}:`, err);
-        }
-      }
-
-      // Clear in-memory thread entry (the Claude session ID changed)
-      provider.clearThread(id);
-
-      const updated = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
-      return updated;
-    },
-  );
-
-  // POST /api/sessions/:id/restore — undo rewind: show all turns again, restore original thread
-  fastify.post<{ Params: { id: string } }>('/api/sessions/:id/restore', async (request, reply) => {
-    const { id } = request.params;
-    const db = getDb();
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
-    if (!session) {
-      return reply.code(404).send({ error: 'Session not found' });
-    }
-    if (!session.rewound_at_turn_id) {
-      return reply.code(409).send({ error: 'Session is not rewound' });
-    }
-    // Repoburg rewind = platform-parity HARD DELETE — the runtime history was
-    // permanently truncated, so local turns can never be restored.
-    if (session.runtime_type === 'repoburg') {
-      return reply.code(409).send({
-        error: 'Restore is not available for repoburg sessions — the rewind permanently deleted the runtime history.',
-      });
-    }
-
-    const now = new Date().toISOString();
-    // Restore the original external_thread_id and clear rewind markers
-    db.prepare(
-      'UPDATE sessions SET rewound_at_turn_id = NULL, pre_rewind_thread_id = NULL, external_thread_id = COALESCE(pre_rewind_thread_id, external_thread_id), updated_at = ? WHERE id = ?',
-    ).run(now, id);
-
-    // Clear in-memory thread entry (the Claude session ID changed back)
-    getProvider(session.runtime_type).clearThread(id);
-
-    const updated = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
-    return updated;
-  });
-
-  // POST /api/sessions/:id/branch — create new session with turns up to and including target turn
-  fastify.post<{ Params: { id: string }; Body: { turn_id: string; title?: string } }>(
-    '/api/sessions/:id/branch',
-    {
-      schema: {
-        body: {
-          type: 'object',
-          required: ['turn_id'],
-          properties: {
-            turn_id: { type: 'string' },
-            title: { type: 'string' },
-          },
-        },
-      },
-    },
-    async (request, reply) => {
-      const { id } = request.params;
-      const { turn_id, title } = request.body || {};
-      if (!turn_id) {
-        return reply.code(400).send({ error: 'turn_id is required' });
-      }
-
-      const db = getDb();
-      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
-      if (!session) {
-        return reply.code(404).send({ error: 'Session not found' });
-      }
-
-      const targetTurn = db.prepare('SELECT created_at FROM turns WHERE id = ? AND session_id = ?').get(turn_id, id) as
-        { created_at: string } | undefined;
-      if (!targetTurn) {
-        return reply.code(404).send({ error: 'Turn not found' });
-      }
-
-      // Create new session
-      const newSessionId = uuidv4();
-      const now = new Date().toISOString();
-      const newTitle = title || `Branch of ${session.title || session.id.slice(0, 8)}`;
-
-      db.prepare(
-        `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, cwd, external_thread_id, status, is_running, lifecycle, has_unreviewed, created_at, updated_at, runtime_config)
-         VALUES (?, ?, ?, ?, ?, ?, NULL, 'active', 0, 'working', 0, ?, ?, ?)`,
-      ).run(
-        newSessionId,
-        newTitle,
-        session.runtime_type,
-        session.model,
-        session.model_reasoning_effort,
-        session.cwd,
-        now,
-        now,
-        session.runtime_config,
-      );
-
-      // Copy turns up to and including the target turn
-      const turnRows = db
-        .prepare('SELECT * FROM turns WHERE session_id = ? AND created_at <= ? ORDER BY created_at ASC')
-        .all(id, targetTurn.created_at) as TurnRow[];
-
-      for (const turn of turnRows) {
-        const newTurnId = uuidv4();
-        db.prepare(
-          `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, attachments, created_at, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        ).run(
-          newTurnId,
-          newSessionId,
-          turn.user_prompt,
-          turn.agent_response,
-          turn.thoughts,
-          turn.token_usage,
-          turn.external_turn_id,
-          turn.status,
-          turn.error,
-          turn.attachments,
-          turn.created_at,
-          turn.updated_at,
-        );
-
-        // Copy items for this turn
-        const itemRows = db
-          .prepare('SELECT * FROM items WHERE turn_id = ? ORDER BY created_at ASC')
-          .all(turn.id) as ItemRow[];
-        for (const item of itemRows) {
-          const newItemId = uuidv4();
-          db.prepare(
-            `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-          ).run(
-            newItemId,
-            newTurnId,
-            item.external_item_id,
-            item.type,
-            item.data,
-            item.status,
-            item.created_at,
-            item.updated_at,
-          );
-        }
-      }
-
-      // Fork the provider-native session so the provider has conversation context
-      const provider = getProvider(session.runtime_type);
-      if (provider.forkSession) {
-        const targetTurnFull = db.prepare('SELECT * FROM turns WHERE id = ?').get(turn_id) as Turn;
-        const forkedId = await provider.forkSession(session, targetTurnFull);
-        if (forkedId) {
-          db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?')
-            .run(forkedId, now, newSessionId);
-        }
-      }
-
-      const newSession = db.prepare('SELECT * FROM sessions WHERE id = ?').get(newSessionId) as Session;
-      return newSession;
-    },
-  );
-}

package/agent-pane/backend/src/routes/skills.test.ts

@@ -1,114 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import Fastify, { type FastifyInstance } from 'fastify';
-
-// Mock shared-app-server to return a mock client
-const mockRequest = vi.fn();
-
-vi.mock('../codex/shared-app-server.ts', () => ({
-  getSharedAppServer: vi.fn(() => ({
-    request: mockRequest,
-    isClosed: vi.fn(() => false),
-    initialize: vi.fn(() => Promise.resolve()),
-    close: vi.fn(() => Promise.resolve()),
-  })),
-}));
-
-// Mock node:fs for readFileSync used in GET /api/skills/:name
-vi.mock('node:fs', () => ({
-  readFileSync: vi.fn(),
-}));
-
-import { registerSkillRoutes } from './skills.ts';
-import { readFileSync } from 'node:fs';
-import type { SkillsListResult } from '../codex/app-server-types.ts';
-
-const MOCK_SKILLS_RESULT: SkillsListResult = {
-  data: [
-    {
-      cwd: '/tmp',
-      skills: [
-        {
-          name: 'cloudflare',
-          description: 'Cloudflare skill',
-          path: '/home/.codex/skills/cloudflare/SKILL.md',
-          scope: 'user',
-          enabled: true,
-        },
-        {
-          name: 'imagegen',
-          description: 'Image generation skill',
-          path: '/home/.codex/skills/.system/imagegen/SKILL.md',
-          scope: 'system',
-          enabled: true,
-          interface: {
-            displayName: 'Image Gen',
-            shortDescription: 'Generate images',
-          },
-        },
-      ],
-      errors: [],
-    },
-  ],
-};
-
-describe('Skill routes', () => {
-  let app: FastifyInstance;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    mockRequest.mockResolvedValue(MOCK_SKILLS_RESULT);
-    app = Fastify();
-    await registerSkillRoutes(app);
-  });
-
-  describe('GET /api/skills', () => {
-    it('returns skills from app-server', async () => {
-      const res = await app.inject({ method: 'GET', url: '/api/skills' });
-      expect(res.statusCode).toBe(200);
-      const skills = res.json();
-      expect(skills).toHaveLength(2);
-      expect(skills[0].name).toBe('cloudflare');
-      expect(skills[0].type).toBe('skill');
-      expect(skills[0].metadata.scope).toBe('user');
-      expect(skills[1].name).toBe('Image Gen');
-      expect(skills[1].metadata.scope).toBe('system');
-    });
-
-    it('calls skills/list with cwd from query', async () => {
-      await app.inject({ method: 'GET', url: '/api/skills?cwd=/custom/path' });
-      expect(mockRequest).toHaveBeenCalledWith('skills/list', { cwds: ['/custom/path'] });
-    });
-
-    it('defaults cwd to process.cwd()', async () => {
-      await app.inject({ method: 'GET', url: '/api/skills' });
-      expect(mockRequest).toHaveBeenCalledWith('skills/list', {
-        cwds: [process.cwd()],
-      });
-    });
-
-    it('returns empty array when app-server returns no skills', async () => {
-      mockRequest.mockResolvedValue({ data: [{ cwd: '/tmp', skills: [], errors: [] }] });
-      const res = await app.inject({ method: 'GET', url: '/api/skills' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual([]);
-    });
-  });
-
-  describe('GET /api/skills/:name', () => {
-    it('returns 404 for unknown skill', async () => {
-      mockRequest.mockResolvedValue(MOCK_SKILLS_RESULT);
-      const res = await app.inject({ method: 'GET', url: '/api/skills/nonexistent' });
-      expect(res.statusCode).toBe(404);
-      expect(res.json()).toEqual({ error: 'Skill not found' });
-    });
-
-    it('returns SKILL.md content for known skill', async () => {
-      vi.mocked(readFileSync).mockReturnValue('# Cloudflare\nSkill content here');
-      const res = await app.inject({ method: 'GET', url: '/api/skills/cloudflare' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json().name).toBe('cloudflare');
-      expect(res.json().content).toContain('# Cloudflare');
-      expect(res.json().path).toBe('/home/.codex/skills/cloudflare/SKILL.md');
-    });
-  });
-});