@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/services/ExportImportService.ts

@@ -1,296 +0,0 @@
-/**
- * Core orchestration service for tenant configuration export and import.
- *
- * @module @axiom-lattice/gateway/services/ExportImportService
- */
-
-import { ExportableEntityRegistry, DependencyResolver, IdRemapper } from '@axiom-lattice/core';
-import type {
-  ExportBundle,
-  ExportableEntity,
-  ImportPreviewResult,
-  Resolution,
-  ImportApplyResult,
-  ImportEntityResult,
-} from '@axiom-lattice/core';
-import { randomUUID } from 'crypto';
-
-interface JobEntry {
-  bundle: ExportBundle;
-  tenantId: string;
-  createdAt: number;
-}
-
-/** Ephemeral in-memory job store (jobs expire after TTL). */
-const exportJobs = new Map<string, JobEntry>();
-
-/** TTL: 1 hour */
-const JOB_TTL_MS = 60 * 60 * 1000;
-
-function cleanExpiredJobs(): void {
-  const now = Date.now();
-  for (const [id, entry] of exportJobs) {
-    if (now - entry.createdAt > JOB_TTL_MS) {
-      exportJobs.delete(id);
-    }
-  }
-}
-
-export class ExportImportService {
-  private registry = ExportableEntityRegistry.getInstance();
-
-  /**
-   * Preview an export: check which types would be auto-included, which dependencies are missing.
-   */
-  async exportPreview(
-    tenantId: string,
-    selectedTypes: string[],
-  ): Promise<{ missingDependencies: string[]; cascadeAdditions: string[] }> {
-    const allDefs = this.registry.getAll();
-
-    const expanded = DependencyResolver.expandCascade(allDefs, selectedTypes);
-    const cascadeAdditions = expanded.filter((t) => !selectedTypes.includes(t));
-
-    const deps = DependencyResolver.computeDependencies(allDefs, expanded);
-    const registeredTypes = new Set(allDefs.map((d) => d.entityType));
-    const missingDependencies = deps.missing.filter((t) => registeredTypes.has(t));
-
-    return { missingDependencies, cascadeAdditions };
-  }
-
-  /**
-   * Generate a full ExportBundle for the given tenant and entity types.
-   * Stores the bundle in-memory and returns a jobId for download.
-   */
-  async export(
-    tenantId: string,
-    entityTypes: string[],
-    entityIds?: Record<string, string[]>,
-  ): Promise<{ jobId: string; bundle: ExportBundle }> {
-    const allDefs = this.registry.getAll();
-    const expanded = DependencyResolver.expandCascade(allDefs, entityTypes);
-    const finalTypes = [...new Set([...expanded, ...entityTypes])];
-
-    const dependencyOrder = DependencyResolver.resolveOrder(
-      finalTypes.map((t) => this.registry.get(t)),
-    );
-
-    const entities: Record<string, ExportableEntity[]> = {};
-    let exportCounter = 0;
-
-    for (const type of dependencyOrder) {
-      const def = this.registry.get(type);
-      let raw = await def.listForExport(tenantId);
-
-      if (entityIds && entityIds[type] && entityIds[type].length > 0) {
-        const idSet = new Set(entityIds[type]);
-        raw = raw.filter((e) => idSet.has(e.data.id as string));
-      }
-
-      entities[type] = raw.map((e) => ({
-        ...e,
-        _exportId: `exp-${type}-${String(++exportCounter).padStart(3, '0')}`,
-        data: this.sanitizeEntityData(e.data),
-      }));
-    }
-
-    // Build reverse map: raw entity ID → _exportId
-    const rawIdToExportId = new Map<string, string>();
-    for (const [, entityList] of Object.entries(entities)) {
-      for (const entity of entityList) {
-        const rawId = entity.data.id as string;
-        if (rawId) {
-          rawIdToExportId.set(rawId, entity._exportId);
-        }
-      }
-    }
-
-    // Rewrite reference fields to @type/exportId format
-    for (const [type, entityList] of Object.entries(entities)) {
-      const def = this.registry.get(type);
-      const refFields = def.referenceFields || {};
-      for (const entity of entityList) {
-        for (const [fieldName, refEntityType] of Object.entries(refFields)) {
-          const rawValue = entity.data[fieldName];
-          if (typeof rawValue === 'string' && rawValue) {
-            const exportId = rawIdToExportId.get(rawValue);
-            if (exportId) {
-              entity.data[fieldName] = `@${refEntityType}/${exportId}`;
-            }
-          }
-        }
-      }
-    }
-
-    const bundle: ExportBundle = {
-      version: 1,
-      exportedAt: new Date().toISOString(),
-      sourceTenantId: tenantId,
-      entities,
-      dependencyOrder,
-      _warning: 'This file contains plaintext secrets (passwords, API keys, tokens). Store it securely and delete after import.',
-    };
-
-    const jobId = randomUUID();
-    exportJobs.set(jobId, { bundle, tenantId, createdAt: Date.now() });
-
-    return { jobId, bundle };
-  }
-
-  /**
-   * Retrieve a previously generated export bundle by jobId with tenant validation.
-   */
-  getExportJob(jobId: string, tenantId: string): ExportBundle | undefined {
-    cleanExpiredJobs();
-    const entry = exportJobs.get(jobId);
-    if (!entry || entry.tenantId !== tenantId) return undefined;
-    return entry.bundle;
-  }
-
-  /**
-   * Preview import: validate bundle and detect conflicts.
-   */
-  async previewImport(
-    tenantId: string,
-    bundle: ExportBundle,
-  ): Promise<ImportPreviewResult> {
-    this.validateBundle(bundle);
-
-    const allConflicts: ImportPreviewResult['conflicts'] = [];
-    const allInsertions: ImportPreviewResult['insertions'] = [];
-    const allErrors: ImportPreviewResult['errors'] = [];
-
-    for (const [entityType, entities] of Object.entries(bundle.entities)) {
-      if (entities.length === 0) continue;
-
-      try {
-        const def = this.registry.get(entityType);
-        const result = await def.previewImport(tenantId, entities);
-
-        allConflicts.push(...result.conflicts);
-        allInsertions.push(...result.insertions);
-        allErrors.push(...result.errors);
-      } catch (err) {
-        for (const entity of entities) {
-          allErrors.push({
-            _exportId: entity._exportId,
-            entityType,
-            error: `Preview failed: ${(err as Error).message}`,
-          });
-        }
-      }
-    }
-
-    return { conflicts: allConflicts, insertions: allInsertions, errors: allErrors };
-  }
-
-  /**
-   * Apply import: create entities in dependency order with ID remapping.
-   */
-  async applyImport(
-    tenantId: string,
-    bundle: ExportBundle,
-    resolutions: Record<string, Resolution>,
-  ): Promise<ImportApplyResult> {
-    this.validateBundle(bundle);
-
-    const results: ImportEntityResult[] = [];
-    const idMap: Record<string, string> = {};
-    // Track skill old id → new id for agent graphDefinition implicit refs
-    const skillIdRemap: Record<string, string> = {};
-
-    for (const entityType of bundle.dependencyOrder) {
-      const entities = bundle.entities[entityType];
-      if (!entities || entities.length === 0) continue;
-
-      const def = this.registry.get(entityType);
-      const remapper = new IdRemapper(idMap);
-
-      for (const entity of entities) {
-        const resolution = resolutions[entity._exportId];
-
-        if (resolution?.action === 'skip') {
-          results.push({ _exportId: entity._exportId, entityType, status: 'skipped' });
-          continue;
-        }
-
-        try {
-          const remappedData = remapper.remapReferences(entity.data) as Record<string, unknown>;
-
-          // Remap implicit skill references in agent graphDefinition.skillIds
-          if (entityType === 'agent' && Object.keys(skillIdRemap).length > 0) {
-            const skillRemapper = new IdRemapper({});
-            remappedData.graphDefinition = skillRemapper.remapSkillIds(
-              (remappedData.graphDefinition as Record<string, unknown>) || {},
-              skillIdRemap,
-            );
-          }
-
-          if (resolution?.action === 'rename' && resolution.newId) {
-            remappedData.id = resolution.newId;
-          }
-
-          const entityWithRemappedData = { ...entity, data: remappedData };
-          const { newId } = await def.applyImport(
-            tenantId,
-            entityWithRemappedData,
-            resolution ?? { _exportId: entity._exportId, action: 'overwrite' },
-          );
-
-          if (newId) {
-            idMap[entity._exportId] = newId;
-            // Track skill ID renames for agent graphDefinition remapping
-            if (entityType === 'skill' && newId) {
-              const oldSkillId = remappedData.id as string;
-              if (oldSkillId !== newId) {
-                skillIdRemap[oldSkillId] = newId;
-              }
-            }
-            results.push({
-              _exportId: entity._exportId,
-              entityType,
-              status: resolution?.action === 'overwrite' ? 'updated' : 'created',
-              newId,
-            });
-          }
-        } catch (err) {
-          results.push({
-            _exportId: entity._exportId,
-            entityType,
-            status: 'failed',
-            error: (err as Error).message,
-          });
-        }
-      }
-    }
-
-    return { results, idMap };
-  }
-
-  /**
-   * List all registered exportable types (for frontend).
-   */
-  listExportableTypes() {
-    return this.registry.listTypes();
-  }
-
-  private validateBundle(bundle: ExportBundle): void {
-    if (bundle.version !== 1) {
-      throw new Error(`Unsupported bundle version: ${bundle.version}. Expected: 1`);
-    }
-    if (!bundle.entities || typeof bundle.entities !== 'object') {
-      throw new Error('Invalid bundle: missing entities');
-    }
-    if (!Array.isArray(bundle.dependencyOrder)) {
-      throw new Error('Invalid bundle: missing dependencyOrder');
-    }
-  }
-
-  private sanitizeEntityData(data: Record<string, unknown>): Record<string, unknown> {
-    const sanitized = { ...data };
-    delete sanitized.tenantId;
-    delete sanitized.createdAt;
-    delete sanitized.updatedAt;
-    return sanitized;
-  }
-}

package/src/services/__tests__/ExportImportService.test.ts

@@ -1,130 +0,0 @@
-import { ExportImportService } from '../ExportImportService';
-import { ExportableEntityRegistry } from '@axiom-lattice/core';
-import type { ExportableEntityDefinition, ExportableEntity } from '@axiom-lattice/core';
-
-function makeDef(
-  entityType: string,
-  entities: ExportableEntity[] = [],
-  dependsOn: string[] = [],
-): ExportableEntityDefinition {
-  return {
-    entityType,
-    label: entityType,
-    category: 'core',
-    dependsOn,
-    cascadeParents: [],
-    listForExport: jest.fn().mockResolvedValue(entities),
-    previewImport: jest.fn().mockResolvedValue({ conflicts: [], insertions: [], errors: [] }),
-    applyImport: jest.fn().mockResolvedValue({ newId: 'new-id' }),
-  };
-}
-
-describe('ExportImportService', () => {
-  beforeEach(() => {
-    (ExportableEntityRegistry as any).instance = undefined;
-    const registry = ExportableEntityRegistry.getInstance();
-    const s1 = { _exportId: '', data: { id: 's1', name: 'Skill 1' } };
-    const s2 = { _exportId: '', data: { id: 's2', name: 'Skill 2' } };
-    registry.register(makeDef('skill', [s1, s2]));
-    registry.register(makeDef('agent', [], ['skill']));
-    registry.register(makeDef('binding', [], ['agent']));
-  });
-
-  it('generates a valid ExportBundle', async () => {
-    const svc = new ExportImportService();
-    const { bundle } = await svc.export('tenant-1', ['skill']);
-
-    expect(bundle.version).toBe(1);
-    expect(bundle.sourceTenantId).toBe('tenant-1');
-    expect(bundle.entities.skill).toHaveLength(2);
-    expect(bundle.entities.skill[0]._exportId).toMatch(/^exp-skill-0/);
-    expect(bundle.entities.skill[0].data.id).toBe('s1');
-    expect(bundle.entities.skill[0].data).not.toHaveProperty('tenantId');
-    expect(bundle.entities.skill[0].data).not.toHaveProperty('createdAt');
-    expect(bundle.entities.skill[0].data).not.toHaveProperty('updatedAt');
-    expect(bundle.dependencyOrder).toEqual(['skill']);
-  });
-
-  it('filters entities by entityIds', async () => {
-    const svc = new ExportImportService();
-    const { bundle } = await svc.export('tenant-1', ['skill'], { skill: ['s1'] });
-    expect(bundle.entities.skill).toHaveLength(1);
-    expect(bundle.entities.skill[0].data.id).toBe('s1');
-  });
-
-  it('exportPreview detects missing dependencies', async () => {
-    const svc = new ExportImportService();
-    const result = await svc.exportPreview('tenant-1', ['agent']);
-    expect(result.missingDependencies).toContain('skill');
-    expect(result.cascadeAdditions).toEqual([]);
-  });
-
-  it('export includes transitive deps when explicitly requested', async () => {
-    const svc = new ExportImportService();
-    const { bundle } = await svc.export('tenant-1', ['skill', 'agent']);
-    expect(bundle.dependencyOrder).toContain('skill');
-    expect(bundle.dependencyOrder).toContain('agent');
-    expect(bundle.dependencyOrder.indexOf('skill')).toBeLessThan(bundle.dependencyOrder.indexOf('agent'));
-  });
-
-  it('previewImport returns insertions for new entities', async () => {
-    const svc = new ExportImportService();
-    const bundle = {
-      version: 1 as const,
-      exportedAt: new Date().toISOString(),
-      sourceTenantId: 't1',
-      entities: {
-        skill: [{ _exportId: 'exp-s-1', data: { id: 's1', name: 'Skill' } }],
-      },
-      dependencyOrder: ['skill'],
-    };
-
-    await svc.previewImport('tenant-2', bundle);
-    const registry = ExportableEntityRegistry.getInstance();
-    expect(registry.get('skill').previewImport).toHaveBeenCalled();
-  });
-
-  it('throws on invalid bundle version', async () => {
-    const svc = new ExportImportService();
-    await expect(
-      svc.previewImport('tenant-2', {
-        version: 99 as any,
-        entities: {},
-        dependencyOrder: [],
-        exportedAt: '',
-        sourceTenantId: '',
-      }),
-    ).rejects.toThrow(/version/);
-  });
-
-  it('throws on missing entities field', async () => {
-    const svc = new ExportImportService();
-    await expect(
-      svc.previewImport('tenant-2', {
-        version: 1,
-        exportedAt: '',
-        sourceTenantId: '',
-        dependencyOrder: [],
-      } as any),
-    ).rejects.toThrow(/entities/);
-  });
-
-  it('getExportJob returns undefined for unknown jobId', () => {
-    const svc = new ExportImportService();
-    expect(svc.getExportJob('nonexistent', 'tenant-1')).toBeUndefined();
-  });
-
-  it('getExportJob returns bundle after export', async () => {
-    const svc = new ExportImportService();
-    const { jobId, bundle } = await svc.export('tenant-1', ['skill']);
-    const retrieved = svc.getExportJob(jobId, 'tenant-1');
-    expect(retrieved).toEqual(bundle);
-  });
-
-  it('listExportableTypes returns registered types', () => {
-    const svc = new ExportImportService();
-    const types = svc.listExportableTypes();
-    expect(types).toHaveLength(3);
-    expect(types.map((t) => t.entityType)).toEqual(['skill', 'agent', 'binding']);
-  });
-});

package/src/services/__tests__/eval-runner.test.ts

@@ -1,131 +0,0 @@
-/**
- * EvalRunner 孤儿 run 处理测试
- *
- * 网关重启后 DB 中 status=running 的 run 在内存中不存在（孤儿）。
- * startRun 应先将孤儿标记为 failed，再允许新 run 启动。
- */
-
-import { describe, expect, it, jest, beforeEach, afterEach } from "@jest/globals";
-
-const mockStore = {
-  getProjectById: jest.fn(),
-  getRunsByTenant: jest.fn(),
-  getSuitesByProject: jest.fn(),
-  getCasesBySuite: jest.fn(),
-  updateRunStatus: jest.fn(),
-  createRun: jest.fn(),
-  createRunResult: jest.fn(),
-  getResultsByRun: jest.fn(),
-};
-
-jest.mock("@axiom-lattice/core", () => {
-  const actual = jest.requireActual("@axiom-lattice/core");
-  return {
-    ...actual,
-    getStoreLattice: jest.fn(() => ({ store: mockStore })),
-    modelLatticeManager: {
-      hasLattice: jest.fn(() => true),
-      getAllLattices: jest.fn(() => [{ key: "mock-model" }]),
-    },
-    LatticeEvalProject: jest.fn().mockImplementation(() => ({
-      calibrateJudge: jest.fn().mockResolvedValue({ ok: true }),
-      runAllSuitesBatch: jest.fn().mockResolvedValue({
-        report: { summary: { total_cases: 0, passed_cases: 0, failed_cases: 0, pass_rate: 0 } },
-      }),
-    })),
-  };
-});
-
-import { evalRunner } from "../eval-runner";
-
-const runningRun = (id: string, createdAt = new Date()) => ({
-  id,
-  projectId: "p1",
-  tenantId: "t1",
-  status: "running" as const,
-  concurrency: 3,
-  totalCases: 0,
-  passedCases: 0,
-  failedCases: 0,
-  avgScore: 0,
-  createdAt,
-});
-
-describe("EvalRunner orphaned run handling", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockStore.getProjectById.mockResolvedValue({ id: "p1", name: "eval-test", tenantId: "t1" });
-    mockStore.getSuitesByProject.mockResolvedValue([]);
-    mockStore.getCasesBySuite.mockResolvedValue([]);
-    mockStore.updateRunStatus.mockResolvedValue(null);
-    mockStore.createRun.mockResolvedValue(runningRun("new-run-1"));
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it("marks orphaned running runs as failed before starting a new run", async () => {
-    const orphan = runningRun("orphan-1", new Date(Date.now() - 60_000));
-    mockStore.getRunsByTenant
-      .mockResolvedValueOnce([orphan])                  // first call: orphan found
-      .mockResolvedValueOnce([]);                        // second call: all cleaned
-
-    const runId = await evalRunner.startRun("t1", "p1");
-
-    expect(mockStore.updateRunStatus).toHaveBeenCalledWith(
-      "t1",
-      "orphan-1",
-      expect.objectContaining({ status: "failed" })
-    );
-    expect(mockStore.createRun).toHaveBeenCalled();
-    expect(runId).toBeTruthy();
-  });
-
-  it("does not clean a run that is alive in memory", async () => {
-    mockStore.getRunsByTenant.mockResolvedValue([]);
-
-    const runId = await evalRunner.startRun("t1", "p1");
-    expect(runId).toBeTruthy();
-    expect(mockStore.updateRunStatus).not.toHaveBeenCalled();
-  });
-
-  it("does not clean a run created after process start (other instance)", async () => {
-    const live = runningRun("other-instance-1", new Date()); // created now → after process start
-    mockStore.getRunsByTenant
-      .mockResolvedValueOnce([live])
-      .mockResolvedValueOnce([live]); // still running after cleanup attempt
-
-    await expect(evalRunner.startRun("t1", "p1")).rejects.toThrow(/already in progress/);
-    expect(mockStore.updateRunStatus).not.toHaveBeenCalled();
-  });
-
-  it("runs only the requested suites when suiteIds is provided", async () => {
-    mockStore.getSuitesByProject.mockResolvedValue([
-      { id: "s-dev", name: "po-extraction-user-sample", tenantId: "t1", projectId: "p1", createdAt: new Date(), updatedAt: new Date() },
-      { id: "s-val", name: "po-extraction-validation", tenantId: "t1", projectId: "p1", createdAt: new Date(), updatedAt: new Date() },
-    ]);
-    const { LatticeEvalProject } = jest.requireMock("@axiom-lattice/core");
-    const runProjectConfigs: any[] = [];
-    LatticeEvalProject.mockImplementation((config: any) => {
-      runProjectConfigs.push(config);
-      return {
-        calibrateJudge: jest.fn().mockResolvedValue({ ok: true }),
-        runAllSuitesBatch: jest.fn().mockResolvedValue({
-          report: { summary: { total_cases: 0, passed_cases: 0, failed_cases: 0, pass_rate: 0 } },
-        }),
-      };
-    });
-
-    const runId = await evalRunner.startRun("t1", "p1", ["s-val"]);
-    expect(runId).toBeTruthy();
-    expect(runProjectConfigs[0].suites.map((s: any) => s.suiteName)).toEqual(["po-extraction-validation"]);
-  });
-
-  it("throws when suiteIds filter matches nothing", async () => {
-    mockStore.getSuitesByProject.mockResolvedValue([
-      { id: "s-dev", name: "dev", tenantId: "t1", projectId: "p1", createdAt: new Date(), updatedAt: new Date() },
-    ]);
-    await expect(evalRunner.startRun("t1", "p1", ["s-val"])).rejects.toThrow(/No suites match/);
-  });
-});

package/src/services/__tests__/local-a2a.test.ts

@@ -1,124 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  appendStderrTail,
-  LocalA2AService,
-  resolveLocalA2AWorkingDirectory,
-} from "../local-a2a";
-import type { LocalRuntimeConfig } from "@axiom-lattice/protocols";
-
-describe("LocalA2AService working directory resolution", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), "local-a2a-"));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it("prefers env override, then explicit command cwd", () => {
-    expect(resolveLocalA2AWorkingDirectory({
-      envWorkdir: "/env/root",
-      commandCwd: "/command/root",
-      currentCwd: tempDir,
-    })).toBe("/env/root");
-
-    expect(resolveLocalA2AWorkingDirectory({
-      envWorkdir: "",
-      commandCwd: "/command/root",
-      currentCwd: tempDir,
-    })).toBe("/command/root");
-  });
-
-  it("falls back to the nearest pnpm workspace root", () => {
-    writeFileSync(join(tempDir, "pnpm-workspace.yaml"), "packages: []\n");
-    const nested = join(tempDir, "examples", "deep_research");
-    mkdirSync(nested, { recursive: true });
-
-    expect(resolveLocalA2AWorkingDirectory({
-      commandCwd: undefined,
-      currentCwd: nested,
-    })).toBe(tempDir);
-  });
-
-  it("falls back to current cwd when no workspace root exists", () => {
-    expect(resolveLocalA2AWorkingDirectory({
-      commandCwd: undefined,
-      currentCwd: tempDir,
-    })).toBe(tempDir);
-  });
-});
-
-describe("LocalA2AService startup diagnostics", () => {
-  const originalAutoStart = process.env.LOCAL_A2A_AUTO_START;
-  const originalWorkdir = process.env.LOCAL_A2A_WORKDIR;
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), "local-a2a-"));
-    process.env.LOCAL_A2A_AUTO_START = "true";
-    delete process.env.LOCAL_A2A_WORKDIR;
-  });
-
-  afterEach(() => {
-    if (originalAutoStart === undefined) {
-      delete process.env.LOCAL_A2A_AUTO_START;
-    } else {
-      process.env.LOCAL_A2A_AUTO_START = originalAutoStart;
-    }
-
-    if (originalWorkdir === undefined) {
-      delete process.env.LOCAL_A2A_WORKDIR;
-    } else {
-      process.env.LOCAL_A2A_WORKDIR = originalWorkdir;
-    }
-
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  function runtime(command: LocalRuntimeConfig["command"]): LocalRuntimeConfig {
-    return {
-      label: "Test Runtime",
-      agentCardUrl: "http://127.0.0.1:1/.well-known/agent-card.json",
-      command,
-    };
-  }
-
-  it("fails before spawn when cwd is not accessible", async () => {
-    const service = new LocalA2AService();
-
-    const state = await service.startProvider("runtime-1", runtime({
-      executable: process.execPath,
-      args: ["-e", "process.exit(0)"],
-      cwd: join(tempDir, "missing"),
-    }));
-
-    expect(state.status).toBe("failed");
-    expect(state.message).toContain("Working directory is not accessible");
-  });
-
-  it("includes stderr tail when the child exits before ready", async () => {
-    const service = new LocalA2AService();
-
-    const state = await service.startProvider("runtime-2", runtime({
-      executable: process.execPath,
-      args: ["-e", "console.error('diagnostic stderr'); process.exit(1)"],
-      cwd: tempDir,
-    }));
-
-    expect(state.status).toBe("failed");
-    expect(state.message).toContain("Exited before becoming ready (1)");
-    expect(state.message).toContain("diagnostic stderr");
-  });
-
-  it("keeps only the last 4KB of stderr", () => {
-    const tail = appendStderrTail("prefix", `${"x".repeat(5000)}end`);
-
-    expect(tail.length).toBe(4096);
-    expect(tail.endsWith("end")).toBe(true);
-    expect(tail.startsWith("prefix")).toBe(false);
-  });
-});