@studio-foundation/cli 0.3.0-beta.1 → 0.3.0-beta.5

package/tests/registry/resolver.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { RegistryIndex, PackageMetadata, Lockfile } from '../../src/registry/types.js';
-
-// Build a minimal index entry
-function indexEntry(name: string, type: string) {
-  return { name, type, version: '1.0.0', description: '', author: '', license: 'MIT', tags: [], studio_version: null, downloads: 0 };
-}
-
-function meta(name: string, deps?: PackageMetadata['dependencies']): PackageMetadata {
-  return { ...indexEntry(name, 'tool'), dependencies: deps };
-}
-
-const EMPTY_LOCKFILE: Lockfile = { installed: {} };
-
-const MOCK_FETCH = async (name: string): Promise<PackageMetadata> => meta(name);
-
-describe('resolveDependencies', () => {
-  it('returns empty graph when package has no dependencies', async () => {
-    const { resolveDependencies } = await import('../../src/registry/resolver.js');
-    const index: RegistryIndex = { generated_at: '', version: '1', packages: [] };
-    const result = await resolveDependencies('my-pkg', meta('my-pkg'), index, EMPTY_LOCKFILE, MOCK_FETCH);
-    expect(result.required).toEqual([]);
-    expect(result.recommended).toEqual([]);
-  });
-
-  it('resolves required tools from first-level deps', async () => {
-    const { resolveDependencies } = await import('../../src/registry/resolver.js');
-    const index: RegistryIndex = {
-      generated_at: '', version: '1',
-      packages: [indexEntry('repo-manager', 'tool'), indexEntry('shell', 'tool')],
-    };
-    const pkgMeta = meta('software-full', {
-      tools: { required: ['repo-manager', 'shell'] },
-    });
-    const result = await resolveDependencies('software-full', pkgMeta, index, EMPTY_LOCKFILE, MOCK_FETCH);
-    expect(result.required.map(d => d.name)).toEqual(expect.arrayContaining(['repo-manager', 'shell']));
-    expect(result.required).toHaveLength(2);
-    expect(result.recommended).toEqual([]);
-  });
-
-  it('returns recommended at first level without recursion', async () => {
-    const { resolveDependencies } = await import('../../src/registry/resolver.js');
-    const index: RegistryIndex = {
-      generated_at: '', version: '1',
-      packages: [indexEntry('code-conventions', 'skill')],
-    };
-    const pkgMeta = meta('software-full', {
-      skills: { recommended: ['code-conventions'] },
-    });
-    const result = await resolveDependencies('software-full', pkgMeta, index, EMPTY_LOCKFILE, MOCK_FETCH);
-    expect(result.recommended.map(d => d.name)).toEqual(['code-conventions']);
-    expect(result.required).toEqual([]);
-  });
-
-  it('resolves required deps recursively (A requires B which requires C)', async () => {
-    const { resolveDependencies } = await import('../../src/registry/resolver.js');
-    const index: RegistryIndex = {
-      generated_at: '', version: '1',
-      packages: [
-        indexEntry('B', 'tool'),
-        indexEntry('C', 'tool'),
-      ],
-    };
-    const fetchMeta = async (name: string): Promise<PackageMetadata> => {
-      if (name === 'B') return meta('B', { tools: { required: ['C'] } });
-      return meta(name);
-    };
-    const pkgMeta = meta('A', { tools: { required: ['B'] } });
-    const result = await resolveDependencies('A', pkgMeta, index, EMPTY_LOCKFILE, fetchMeta);
-    expect(result.required.map(d => d.name)).toEqual(expect.arrayContaining(['B', 'C']));
-    expect(result.required).toHaveLength(2);
-  });
-
-  it('deduplicates when two paths lead to the same dep', async () => {
-    const { resolveDependencies } = await import('../../src/registry/resolver.js');
-    const index: RegistryIndex = {
-      generated_at: '', version: '1',
-      packages: [indexEntry('B', 'tool'), indexEntry('C', 'tool'), indexEntry('D', 'tool')],
-    };
-    // A requires B and C, both require D
-    const fetchMeta = async (name: string): Promise<PackageMetadata> => {
-      if (name === 'B') return meta('B', { tools: { required: ['D'] } });
-      if (name === 'C') return meta('C', { tools: { required: ['D'] } });
-      return meta(name);
-    };
-    const pkgMeta = meta('A', { tools: { required: ['B', 'C'] } });
-    const result = await resolveDependencies('A', pkgMeta, index, EMPTY_LOCKFILE, fetchMeta);
-    const names = result.required.map(d => d.name);
-    expect(names.filter(n => n === 'D')).toHaveLength(1); // D appears only once
-  });
-
-  it('throws on circular dependency', async () => {
-    const { resolveDependencies } = await import('../../src/registry/resolver.js');
-    const index: RegistryIndex = {
-      generated_at: '', version: '1',
-      packages: [indexEntry('B', 'tool')],
-    };
-    // A requires B, B requires A — cycle
-    const fetchMeta = async (name: string): Promise<PackageMetadata> => {
-      if (name === 'B') return meta('B', { tools: { required: ['A'] } });
-      return meta(name);
-    };
-    const pkgMeta = meta('A', { tools: { required: ['B'] } });
-    await expect(resolveDependencies('A', pkgMeta, index, EMPTY_LOCKFILE, fetchMeta))
-      .rejects.toThrow(/circular/i);
-  });
-
-  it('includes already-installed packages in required list (caller handles required_by update)', async () => {
-    const { resolveDependencies } = await import('../../src/registry/resolver.js');
-    const index: RegistryIndex = {
-      generated_at: '', version: '1',
-      packages: [indexEntry('repo-manager', 'tool')],
-    };
-    const lockfile: Lockfile = {
-      installed: { 'repo-manager': { version: '1.0.0', type: 'tool', installed_at: '2026-02-28', sha256: 'abc' } },
-    };
-    const pkgMeta = meta('software-full', { tools: { required: ['repo-manager'] } });
-    const result = await resolveDependencies('software-full', pkgMeta, index, lockfile, MOCK_FETCH);
-    // Already installed — should still appear in required list (caller handles required_by update)
-    expect(result.required.filter(d => d.name === 'repo-manager')).toHaveLength(1);
-  });
-});

package/tests/run-logger-events.test.ts

@@ -1,326 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import type { EngineEvents } from '@studio-foundation/engine';
-
-interface LogEntry {
-  ts: string;
-  event: string;
-  [key: string]: unknown;
-}
-
-function createCapturingLogger() {
-  const entries: LogEntry[] = [];
-  return {
-    logger: {
-      start: vi.fn(),
-      log: vi.fn((payload: Record<string, unknown>) => {
-        entries.push({ ts: new Date().toISOString(), ...payload } as LogEntry);
-      }),
-      close: vi.fn().mockResolvedValue(undefined),
-      getLogPath: () => '/tmp/test.jsonl',
-    },
-    entries,
-  };
-}
-
-describe('mergeEvents — pipeline_start', () => {
-  it('logs full input object (no truncation)', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-
-    const largeInput = {
-      brief_summary: 'A'.repeat(500),
-      nested: { deep: { value: 'B'.repeat(300) } },
-    };
-
-    const events = mergeEvents(noopEvents, logger, 'test-pipeline', largeInput);
-    events.onPipelineStart!({ pipeline_name: 'test-pipeline', run_id: 'abc12345-def6-7890' });
-
-    expect(logger.start).toHaveBeenCalledWith('abc12345-def6-7890', 'test-pipeline');
-    expect(entries).toHaveLength(1);
-    const entry = entries[0];
-    expect(entry.event).toBe('pipeline_start');
-    expect(entry.input).toEqual(largeInput);
-    // input_summary should not exist anymore
-    expect(entry).not.toHaveProperty('input_summary');
-  });
-
-  it('logs full input string (no truncation)', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-    const largeString = 'X'.repeat(1000);
-
-    const events = mergeEvents(noopEvents, logger, 'pipe', largeString);
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-id-12345678' });
-
-    const entry = entries[0];
-    expect(entry.input).toBe(largeString);
-  });
-});
-
-describe('mergeEvents — pipeline_complete', () => {
-  it('logs pipeline_name from event', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, logger, 'feature-builder', 'test input');
-    // Must call onPipelineStart first to initialize logger
-    events.onPipelineStart!({ pipeline_name: 'feature-builder', run_id: 'run-12345678' });
-    events.onPipelineComplete!({
-      pipeline_name: 'feature-builder',
-      run_id: 'run-12345678',
-      status: 'success',
-      duration_ms: 12345,
-      total_tokens: 5000,
-      total_tool_calls: 7,
-    });
-
-    const entry = entries.find(e => e.event === 'pipeline_complete')!;
-    expect(entry.pipeline_name).toBe('feature-builder');
-    expect(entry.status).toBe('success');
-    expect(entry.duration_ms).toBe(12345);
-    expect(entry.total_tokens).toBe(5000);
-    expect(entry.total_tool_calls).toBe(7);
-  });
-});
-
-describe('mergeEvents — stage_complete', () => {
-  it('logs full output object (not truncated summary)', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, logger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-
-    const largeOutput = {
-      summary: 'A'.repeat(500),
-      files_changed: ['src/a.ts', 'src/b.ts'],
-      details: { nested: 'B'.repeat(300) },
-    };
-
-    events.onStageComplete!({
-      stage_name: 'code-generation',
-      stage_index: 0,
-      total_stages: 3,
-      status: 'success',
-      attempts: 1,
-      duration_ms: 5000,
-      output: largeOutput,
-      output_summary: '3 fields: summary, files_changed, details',
-      tool_calls: [
-        { name: 'repo_manager-write_file', arguments_summary: 'src/a.ts' },
-        { name: 'repo_manager-write_file', arguments_summary: 'src/b.ts' },
-      ],
-      token_usage: { prompt_tokens: 1000, completion_tokens: 500, total_tokens: 1500 },
-    });
-
-    const entry = entries.find(e => e.event === 'stage_complete')!;
-    // Full output, not truncated
-    expect(entry.output).toEqual(largeOutput);
-    // output_summary and output_fields should NOT be logged
-    expect(entry).not.toHaveProperty('output_summary');
-    expect(entry).not.toHaveProperty('output_fields');
-    // tool_calls is the full array, not a count
-    expect(entry.tool_calls).toEqual([
-      { name: 'repo_manager-write_file', arguments_summary: 'src/a.ts' },
-      { name: 'repo_manager-write_file', arguments_summary: 'src/b.ts' },
-    ]);
-  });
-
-  it('handles stage_complete with no output', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, logger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-
-    events.onStageComplete!({
-      stage_name: 'analysis',
-      stage_index: 0,
-      total_stages: 1,
-      status: 'failed',
-      attempts: 3,
-      duration_ms: 10000,
-    });
-
-    const entry = entries.find(e => e.event === 'stage_complete')!;
-    expect(entry.output).toBeUndefined();
-    expect(entry.tool_calls).toBeUndefined();
-  });
-});
-
-describe('mergeEvents — stage_retry', () => {
-  it('logs all failures, real max_attempts, and diagnostic fields', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, logger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-
-    events.onTaskRetry!({
-      stage: 'code-generation',
-      attempt: 2,
-      max_attempts: 3,
-      failures: [
-        'missing required field: summary',
-        'tool_calls.minimum: expected 1, got 0',
-      ],
-      agent_output_raw: '{"partial": "data"}',
-      tool_calls_count: 0,
-    });
-
-    const entry = entries.find(e => e.event === 'stage_retry')!;
-    expect(entry.stage).toBe('code-generation');
-    expect(entry.attempt).toBe(2);
-    expect(entry.max_attempts).toBe(3);
-    expect(entry.failures).toEqual([
-      'missing required field: summary',
-      'tool_calls.minimum: expected 1, got 0',
-    ]);
-    expect(entry.agent_output_raw).toBe('{"partial": "data"}');
-    expect(entry.tool_calls_count).toBe(0);
-  });
-});
-
-describe('mergeEvents — tool call events', () => {
-  it('logs tool_call_start with tool name and params', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, logger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-
-    events.onToolCallStart!({
-      tool: 'repo_manager-write_file',
-      params: { path: 'src/index.ts', content: 'console.log("hello")' },
-      timestamp: Date.now(),
-    });
-
-    const entry = entries.find(e => e.event === 'tool_call_start')!;
-    expect(entry.tool).toBe('repo_manager-write_file');
-    expect(entry.params).toEqual({ path: 'src/index.ts', content: 'console.log("hello")' });
-  });
-
-  it('logs tool_call_complete with result and duration', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, logger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-
-    events.onToolCallComplete!({
-      tool: 'repo_manager-write_file',
-      result: { success: true, path: 'src/index.ts' },
-      duration_ms: 42,
-      timestamp: Date.now(),
-    });
-
-    const entry = entries.find(e => e.event === 'tool_call_complete')!;
-    expect(entry.tool).toBe('repo_manager-write_file');
-    expect(entry.result).toEqual({ success: true, path: 'src/index.ts' });
-    expect(entry.duration_ms).toBe(42);
-    expect(entry).not.toHaveProperty('error');
-  });
-
-  it('logs tool_call_complete with error', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger, entries } = createCapturingLogger();
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, logger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-
-    events.onToolCallComplete!({
-      tool: 'shell-run_command',
-      result: null,
-      error: 'Command failed with exit code 1',
-      duration_ms: 150,
-      timestamp: Date.now(),
-    });
-
-    const entry = entries.find(e => e.event === 'tool_call_complete')!;
-    expect(entry.error).toBe('Command failed with exit code 1');
-  });
-
-  it('still forwards tool call events to progress display', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const { logger } = createCapturingLogger();
-    const startSpy = vi.fn();
-    const completeSpy = vi.fn();
-    const progressEvents: EngineEvents = {
-      onToolCallStart: startSpy,
-      onToolCallComplete: completeSpy,
-    };
-
-    const events = mergeEvents(progressEvents, logger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-
-    const startEvent = { tool: 'test', params: {}, timestamp: Date.now() };
-    const completeEvent = { tool: 'test', result: 'ok', duration_ms: 1, timestamp: Date.now() };
-
-    events.onToolCallStart!(startEvent);
-    events.onToolCallComplete!(completeEvent);
-
-    expect(startSpy).toHaveBeenCalledWith(startEvent);
-    expect(completeSpy).toHaveBeenCalledWith(completeEvent);
-  });
-});
-
-describe('mergeEvents — run_id cleanup', () => {
-  it('does not pass explicit run_id: undefined in stage_start payload', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const payloads: Record<string, unknown>[] = [];
-    const fakeLogger = {
-      start: vi.fn(),
-      log: vi.fn((payload: Record<string, unknown>) => {
-        payloads.push(payload);
-      }),
-      close: vi.fn().mockResolvedValue(undefined),
-      getLogPath: () => '/tmp/test.jsonl',
-    };
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, fakeLogger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-    events.onStageStart!({ stage_name: 'analysis', stage_index: 0, total_stages: 2, max_attempts: 3 });
-
-    const stagePayload = payloads.find(p => p.event === 'stage_start')!;
-    // run_id key should not be present in the payload at all
-    expect('run_id' in stagePayload).toBe(false);
-  });
-
-  it('does not pass explicit run_id: undefined in group handlers', async () => {
-    const { mergeEvents } = await import('../src/commands/run.js');
-    const payloads: Record<string, unknown>[] = [];
-    const fakeLogger = {
-      start: vi.fn(),
-      log: vi.fn((payload: Record<string, unknown>) => {
-        payloads.push(payload);
-      }),
-      close: vi.fn().mockResolvedValue(undefined),
-      getLogPath: () => '/tmp/test.jsonl',
-    };
-    const noopEvents: EngineEvents = {};
-
-    const events = mergeEvents(noopEvents, fakeLogger, 'pipe', 'input');
-    events.onPipelineStart!({ pipeline_name: 'pipe', run_id: 'run-12345678' });
-    events.onGroupStart!({ group_name: 'impl-review', max_iterations: 3 });
-    events.onGroupIteration!({ group_name: 'impl-review', iteration: 1, max_iterations: 3 });
-    events.onGroupFeedback!({ group_name: 'impl-review', iteration: 1, rejection_reason: 'bad', rejection_details: [] });
-    events.onGroupComplete!({ group_name: 'impl-review', iterations: 1, status: 'success' });
-
-    const groupPayloads = payloads.filter(p =>
-      ['group_start', 'group_iteration', 'group_feedback', 'group_complete'].includes(p.event as string)
-    );
-    for (const payload of groupPayloads) {
-      expect('run_id' in payload).toBe(false);
-    }
-  });
-});

package/tests/run-logger.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { readFileSync, rmSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { createRunLogger } from '../src/run-logger.js';
-
-const TMP = resolve('/tmp', '.studio-run-logger-test');
-
-afterEach(() => {
-  try {
-    rmSync(TMP, { recursive: true, force: true });
-  } catch { /* ignore */ }
-});
-
-describe('RunLogger — close flushes to disk', () => {
-  it('close() returns a Promise', () => {
-    const logger = createRunLogger(TMP);
-    logger.start('aaaa1111-bbbb-cccc-dddd-eeeeeeee0001', 'test-pipe');
-    const result = logger.close();
-    // close() must return a thenable so callers can await it
-    expect(result).toBeInstanceOf(Promise);
-  });
-
-  it('all entries are on disk after close() resolves', async () => {
-    const logger = createRunLogger(TMP);
-    logger.start('aaaa1111-bbbb-cccc-dddd-eeeeeeee0002', 'flush-test');
-
-    logger.log({ event: 'pipeline_start', pipeline: 'flush-test' });
-    logger.log({ event: 'stage_start', stage: 'analysis' });
-    logger.log({ event: 'stage_complete', stage: 'analysis', status: 'failed' });
-    logger.log({ event: 'pipeline_complete', status: 'failed', duration_ms: 1234 });
-
-    await logger.close();
-
-    const content = readFileSync(logger.getLogPath(), 'utf-8');
-    const lines = content.trim().split('\n');
-    const events = lines.map(l => JSON.parse(l).event);
-
-    expect(events).toEqual([
-      'pipeline_start',
-      'stage_start',
-      'stage_complete',
-      'pipeline_complete',
-    ]);
-  });
-
-  it('pipeline_complete is present after close() on a rejected run', async () => {
-    const logger = createRunLogger(TMP);
-    logger.start('aaaa1111-bbbb-cccc-dddd-eeeeeeee0003', 'reject-test');
-
-    logger.log({ event: 'pipeline_start', pipeline: 'reject-test' });
-    logger.log({ event: 'group_start', group: 'impl-review' });
-    logger.log({ event: 'group_complete', group: 'impl-review', status: 'rejected' });
-    logger.log({ event: 'pipeline_complete', status: 'rejected', duration_ms: 5678 });
-
-    await logger.close();
-
-    const content = readFileSync(logger.getLogPath(), 'utf-8');
-    const lines = content.trim().split('\n');
-    const lastEvent = JSON.parse(lines[lines.length - 1]);
-
-    expect(lastEvent.event).toBe('pipeline_complete');
-    expect(lastEvent.status).toBe('rejected');
-  });
-});

package/tests/run-store-factory.test.ts

@@ -1,51 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { rm } from 'node:fs/promises';
-import { createRunStore } from '../src/run-store-factory.js';
-import type { PipelineRun } from '@studio-foundation/contracts';
-
-const tmpDir = `/tmp/.studio-factory-test-${Date.now()}`;
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-describe('createRunStore', () => {
-  it('returns a RunStore that can round-trip a PipelineRun', async () => {
-    const store = await createRunStore({ resolvedStudioDir: tmpDir });
-
-    const run: PipelineRun = {
-      id: 'abc-123',
-      pipeline_name: 'test-pipeline',
-      status: 'success',
-      started_at: '2026-01-01T00:00:00.000Z',
-      stages: [],
-    };
-
-    await store.savePipelineRun(run);
-    const retrieved = await store.getPipelineRun('abc-123');
-
-    expect(retrieved?.id).toBe('abc-123');
-    expect(retrieved?.pipeline_name).toBe('test-pipeline');
-    expect(retrieved?.status).toBe('success');
-
-    await store.close?.();
-  });
-
-  it('saves and retrieves log path', async () => {
-    const store = await createRunStore({ resolvedStudioDir: tmpDir });
-
-    const run: PipelineRun = {
-      id: 'log-run',
-      pipeline_name: 'p',
-      status: 'success',
-      started_at: '2026-01-01T00:00:00.000Z',
-      stages: [],
-    };
-    await store.savePipelineRun(run);
-    await store.saveLogPath('log-run', '/tmp/some.jsonl');
-
-    expect(await store.getLogPath('log-run')).toBe('/tmp/some.jsonl');
-
-    await store.close?.();
-  });
-});

package/tests/studio-dir.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdir, rm } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { findStudioDir } from '../src/studio-dir.js';
-
-const TMP = resolve(import.meta.dirname, '.tmp-studio-dir-test');
-
-beforeEach(async () => { await mkdir(TMP, { recursive: true }); });
-afterEach(async () => { await rm(TMP, { recursive: true, force: true }); });
-
-describe('findStudioDir', () => {
-  it('finds .studio/ in the given directory', async () => {
-    await mkdir(resolve(TMP, '.studio'), { recursive: true });
-    const result = await findStudioDir(TMP);
-    expect(result).toBe(resolve(TMP, '.studio'));
-  });
-
-  it('finds .studio/ in a parent directory', async () => {
-    await mkdir(resolve(TMP, '.studio'), { recursive: true });
-    const nested = resolve(TMP, 'a', 'b', 'c');
-    await mkdir(nested, { recursive: true });
-    const result = await findStudioDir(nested);
-    expect(result).toBe(resolve(TMP, '.studio'));
-  });
-
-  it('returns null when .studio/ is not found', async () => {
-    // Use the filesystem root — /.studio never exists, so findStudioDir returns null immediately
-    const result = await findStudioDir('/');
-    expect(result).toBeNull();
-  });
-});