@stigmer/cli 3.35.0 → 3.37.0

package/src/local/runtime/runtime.test.ts

@@ -1,240 +0,0 @@
-import { chmodSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { CliExitError } from "../../errors/cli-exit-error.js";
-import { resolveNode, resolveServerNode } from "./node.js";
-import { acquireRunner, resolveRunner } from "./runner.js";
-import { which } from "./which.js";
-
-function tempDir(prefix: string): string {
-  return mkdtempSync(join(tmpdir(), prefix));
-}
-
-// Snapshot and restore the env vars these resolvers read, so tests don't leak.
-const TOUCHED = ["PATH", "STIGMER_RUNNER_DIR", "STIGMER_NODE_BIN"] as const;
-let saved: Record<string, string | undefined>;
-
-beforeEach(() => {
-  saved = {};
-  for (const key of TOUCHED) saved[key] = process.env[key];
-});
-
-afterEach(() => {
-  for (const key of TOUCHED) {
-    if (saved[key] === undefined) delete process.env[key];
-    else process.env[key] = saved[key];
-  }
-});
-
-describe("which", () => {
-  it("resolves an executable on PATH and returns null for an unknown name", () => {
-    const dir = tempDir("stigmer-which-");
-    const exe = join(dir, "myexec");
-    writeFileSync(exe, "#!/bin/sh\n");
-    chmodSync(exe, 0o755);
-    process.env.PATH = dir;
-
-    expect(which("myexec")).toBe(exe);
-    expect(which("definitely-not-a-real-binary-xyz")).toBeNull();
-  });
-
-  it("checks an absolute path directly", () => {
-    const dir = tempDir("stigmer-which-");
-    const exe = join(dir, "tool");
-    writeFileSync(exe, "#!/bin/sh\n");
-    chmodSync(exe, 0o755);
-    expect(which(exe)).toBe(exe);
-    expect(which(join(dir, "missing"))).toBeNull();
-  });
-});
-
-// A fake "node" whose --version and capability-probe behavior the test
-// controls, making these tests deterministic regardless of which Node runs
-// the suite itself. The fake INSPECTS the probe script it receives ("fts5"
-// in the source distinguishes the server's FTS5 probe from the runner's
-// module-presence probe), so a mutation that wires resolveServerNode to the
-// weaker probe — or neuters the FTS5 probe's failure exit — fails here.
-function fakeNodeBinary(opts: { version: string; hasSqlite: boolean; hasFts5?: boolean }): string {
-  const bin = join(tempDir("stigmer-node-"), "node");
-  const fts5Exit = (opts.hasFts5 ?? opts.hasSqlite) ? 0 : 1;
-  writeFileSync(
-    bin,
-    `#!/bin/sh\n` +
-      `if [ "$1" = "--version" ]; then echo "${opts.version}"; exit 0; fi\n` +
-      `case "$2" in *fts5*) exit ${fts5Exit};; esac\n` +
-      `exit ${opts.hasSqlite ? 0 : 1}\n`,
-  );
-  chmodSync(bin, 0o755);
-  return bin;
-}
-
-describe("resolveNode", () => {
-  it("resolves the current runtime iff it provides node:sqlite", () => {
-    // The contract, not an environment assumption: on a supported Node the
-    // own-runtime path resolves; on an unsupported one (e.g. 23.0-23.3, the
-    // gap the old version-table gate let through) it must throw the
-    // capability error rather than hand the runner a Node it will crash on.
-    delete process.env.STIGMER_NODE_BIN;
-    if (process.getBuiltinModule?.("node:sqlite") !== undefined) {
-      expect(resolveNode()).toBe(process.execPath);
-    } else {
-      expect(() => resolveNode()).toThrow(/node:sqlite/);
-    }
-  });
-
-  it("honors an override that passes the capability probe", () => {
-    const bin = fakeNodeBinary({ version: "v22.13.0", hasSqlite: true });
-    process.env.STIGMER_NODE_BIN = bin;
-    expect(resolveNode()).toBe(bin);
-  });
-
-  it("rejects an override that is not a working Node", () => {
-    process.env.STIGMER_NODE_BIN = "/nonexistent/node";
-    expect(() => resolveNode()).toThrow(CliExitError);
-  });
-
-  it("rejects a Node without node:sqlite, naming the version and capability", () => {
-    // The shape of a real 23.0-23.3 binary: healthy --version, no node:sqlite.
-    process.env.STIGMER_NODE_BIN = fakeNodeBinary({ version: "v23.1.0", hasSqlite: false });
-
-    expect(() => resolveNode()).toThrow(/node:sqlite/);
-    expect(() => resolveNode()).toThrow(/v23\.1\.0/);
-  });
-});
-
-describe("resolveServerNode", () => {
-  it("honors an override that passes the FTS5 capability probe", () => {
-    const bin = fakeNodeBinary({ version: "v22.13.0", hasSqlite: true });
-    process.env.STIGMER_NODE_BIN = bin;
-    expect(resolveServerNode()).toBe(bin);
-  });
-
-  it("rejects a Node whose sqlite lacks FTS5, naming the capability (the 23.4 trap)", () => {
-    // The shape of a REAL 23.4 binary: node:sqlite present (the module probe
-    // would pass), FTS5 absent (the fts5 probe fails) — pinning that the
-    // server resolution dispatches the STRONGER probe (D4 #14).
-    process.env.STIGMER_NODE_BIN = fakeNodeBinary({ version: "v23.4.0", hasSqlite: true, hasFts5: false });
-
-    expect(() => resolveServerNode()).toThrow(/FTS5/);
-    expect(() => resolveServerNode()).toThrow(/v23\.4\.0/);
-  });
-
-  it("the runner resolution still accepts the 23.4 shape (module present, FTS5 absent)", () => {
-    // The two probes deliberately differ: the runner needs only node:sqlite.
-    const bin = fakeNodeBinary({ version: "v23.4.0", hasSqlite: true, hasFts5: false });
-    process.env.STIGMER_NODE_BIN = bin;
-    expect(resolveNode()).toBe(bin);
-  });
-
-  it("runs the real FTS5 probe against the current runtime", () => {
-    // The one place the REAL probe script executes end-to-end (the fake-node
-    // tests above only exercise the dispatch and error copy). Conditional on
-    // the runtime's own capability — the resolveNode own-runtime pattern —
-    // so a no-FTS5 Node (e.g. 23.4) asserts the throw instead of the pass.
-    delete process.env.STIGMER_NODE_BIN;
-    if (currentRuntimeHasFts5()) {
-      expect(resolveServerNode()).toBe(process.execPath);
-    } else {
-      expect(() => resolveServerNode()).toThrow(/FTS5/);
-    }
-  });
-
-  function currentRuntimeHasFts5(): boolean {
-    const sqlite = process.getBuiltinModule?.("node:sqlite");
-    if (sqlite === undefined) return false;
-    try {
-      new sqlite.DatabaseSync(":memory:").exec("CREATE VIRTUAL TABLE t USING fts5(x)");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-});
-
-describe("resolveRunner", () => {
-  const fakeNode = (): string => "/usr/bin/node";
-
-  it("resolves a built runner from STIGMER_RUNNER_DIR", () => {
-    const dir = tempDir("stigmer-runner-");
-    writeFileSync(join(dir, "package.json"), "{}");
-    mkdirSync(join(dir, "dist"));
-    writeFileSync(join(dir, "dist", "main.js"), "//");
-    process.env.STIGMER_RUNNER_DIR = dir;
-
-    const resolution = resolveRunner(fakeNode);
-    expect(resolution).toEqual({ nodeBin: "/usr/bin/node", entryPath: join(dir, "dist", "main.js"), appDir: dir });
-  });
-
-  it("errors with build guidance when dist/main.js is missing", () => {
-    const dir = tempDir("stigmer-runner-");
-    writeFileSync(join(dir, "package.json"), "{}");
-    process.env.STIGMER_RUNNER_DIR = dir;
-    expect(() => resolveRunner(fakeNode)).toThrow(/not built/);
-  });
-
-  it("rejects an override that is not a runner package", () => {
-    const dir = tempDir("stigmer-runner-");
-    process.env.STIGMER_RUNNER_DIR = join(dir, "no-package-here"); // no package.json
-    expect(() => resolveRunner(fakeNode)).toThrow(/not a runner package/);
-  });
-});
-
-describe("acquireRunner", () => {
-  const fakeNode = (): string => "/usr/bin/node";
-
-  it("installs the slim package and resolves its main.js entry", () => {
-    const home = tempDir("stigmer-home-");
-    const installed: Array<{ dir: string; spec: string }> = [];
-    const install = (dir: string, spec: string): void => {
-      installed.push({ dir, spec });
-      // Simulate the npm install laying down the slim package.
-      const pkgDir = join(dir, "node_modules", "@stigmer", "runner-slim");
-      mkdirSync(pkgDir, { recursive: true });
-      writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
-    };
-
-    const resolution = acquireRunner({ home, version: "0.5.0", node: fakeNode, install });
-
-    const expectedEntry = join(home, ".stigmer", "runtimes", "0.5.0", "node_modules", "@stigmer", "runner-slim", "main.js");
-    expect(resolution.nodeBin).toBe("/usr/bin/node");
-    expect(resolution.entryPath).toBe(expectedEntry);
-    expect(resolution.appDir).toBe(join(home, ".stigmer", "runtimes", "0.5.0", "node_modules", "@stigmer", "runner-slim"));
-    expect(installed).toEqual([{ dir: join(home, ".stigmer", "runtimes", "0.5.0"), spec: "@stigmer/runner-slim@0.5.0" }]);
-  });
-
-  it("reuses a prior install without reinstalling", () => {
-    const home = tempDir("stigmer-home-");
-    const pkgDir = join(home, ".stigmer", "runtimes", "0.5.0", "node_modules", "@stigmer", "runner-slim");
-    mkdirSync(pkgDir, { recursive: true });
-    writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
-
-    const install = vi.fn();
-    const resolution = acquireRunner({ home, version: "0.5.0", node: fakeNode, install });
-
-    expect(resolution.entryPath).toBe(join(pkgDir, "main.js"));
-    expect(install).not.toHaveBeenCalled();
-  });
-
-  it("refuses to acquire for a non-release (dev) build", () => {
-    const home = tempDir("stigmer-home-");
-    expect(() => acquireRunner({ home, version: "0.0.0-dev", node: fakeNode, install: vi.fn() })).toThrow(
-      /non-release build/,
-    );
-  });
-
-  // Presence beats acquirability (the server acquirer's rule; the all-in-one
-  // image bakes a dev-stamped runtime npm never published).
-  it("uses an already-installed runtime even for a non-release (dev) build", () => {
-    const home = tempDir("stigmer-home-");
-    const pkgDir = join(home, ".stigmer", "runtimes", "0.0.0-dev.abc123", "node_modules", "@stigmer", "runner-slim");
-    mkdirSync(pkgDir, { recursive: true });
-    writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
-
-    const install = vi.fn();
-    const resolution = acquireRunner({ home, version: "0.0.0-dev.abc123", node: fakeNode, install });
-
-    expect(resolution.entryPath).toBe(join(pkgDir, "main.js"));
-    expect(install).not.toHaveBeenCalled();
-  });
-});

package/src/local/runtime/runtimes-install.test.ts

@@ -1,58 +0,0 @@
-// Pins the shared runtimes-install contract both acquirers depend on: the
-// no-clobber root manifest (the runner and the server install into ONE
-// per-version root), the dev-version gate, and the actionable install
-// failure.
-
-import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { CliExitError } from "../../errors/cli-exit-error.js";
-import { ensureRuntimesRoot, isAcquirableRelease, npmInstallIntoRuntimes } from "./runtimes-install.js";
-
-function tempDir(): string {
-  return mkdtempSync(join(tmpdir(), "stigmer-runtimes-"));
-}
-
-describe("ensureRuntimesRoot", () => {
-  it("creates the root with the stable manifest when absent", () => {
-    const dir = join(tempDir(), "0.5.0");
-    ensureRuntimesRoot(dir);
-    const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-    expect(manifest).toEqual({ name: "stigmer-runtime", private: true, version: "0.0.0" });
-  });
-
-  it("never clobbers an existing root manifest — the shared-root contract", () => {
-    const dir = tempDir();
-    writeFileSync(join(dir, "package.json"), '{"name":"stigmer-runtime","marker":"first-installer"}\n');
-    ensureRuntimesRoot(dir);
-    expect(readFileSync(join(dir, "package.json"), "utf8")).toContain("first-installer");
-  });
-});
-
-describe("isAcquirableRelease", () => {
-  it("admits releases and rc/next versions, refuses dev builds", () => {
-    expect(isAcquirableRelease("0.5.0")).toBe(true);
-    expect(isAcquirableRelease("0.5.0-rc.1")).toBe(true);
-    expect(isAcquirableRelease("0.0.0-dev")).toBe(false);
-    expect(isAcquirableRelease("0.5.0-dev.20260825")).toBe(false);
-    // The bare stamp an unbundled server reports; the substring test this once was let it through.
-    expect(isAcquirableRelease("dev")).toBe(false);
-  });
-});
-
-describe("npmInstallIntoRuntimes", () => {
-  it("wraps an install failure in an actionable CliExitError with remediation hints", () => {
-    // /dev/null/x is unwritable on every POSIX system, so the real npm spawn
-    // fails deterministically without network access.
-    const attempt = (): void => npmInstallIntoRuntimes("/dev/null/x", "@stigmer/nonexistent@0.0.0");
-    expect(attempt).toThrow(CliExitError);
-    try {
-      attempt();
-    } catch (err) {
-      const hints = (err as CliExitError).hints?.join("\n") ?? "";
-      expect(hints).toMatch(/npm install/);
-      expect(hints).toMatch(/remove/i);
-    }
-  });
-});

package/src/local/runtime/server.test.ts

@@ -1,253 +0,0 @@
-// Pins the server resolution: exactly like the runner's (explicit dir →
-// repo tree → acquired slim package).
-
-import {
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { acquireServer, ensureServer, resolveServerTs } from "./server.js";
-
-function tempDir(prefix: string): string {
-  return mkdtempSync(join(tmpdir(), prefix));
-}
-
-const fakeNode = (): string => "/usr/bin/node";
-
-// Snapshot and restore the env vars the resolution reads, so tests don't leak.
-const TOUCHED = [
-  "STIGMER_SERVER_DIR",
-  "STIGMER_NODE_BIN",
-  "STIGMER_RUNTIMES_DIR",
-] as const;
-let saved: Record<string, string | undefined>;
-
-beforeEach(() => {
-  saved = {};
-  for (const key of TOUCHED) {
-    saved[key] = process.env[key];
-    delete process.env[key];
-  }
-});
-
-afterEach(() => {
-  for (const key of TOUCHED) {
-    if (saved[key] === undefined) delete process.env[key];
-    else process.env[key] = saved[key];
-  }
-});
-
-function builtServerDir(): string {
-  const dir = tempDir("stigmer-server-");
-  writeFileSync(join(dir, "package.json"), "{}");
-  mkdirSync(join(dir, "dist"));
-  writeFileSync(join(dir, "dist", "main.js"), "//");
-  return dir;
-}
-
-describe("ensureServer", () => {
-  it("resolves the server from STIGMER_SERVER_DIR", () => {
-    const dir = builtServerDir();
-    process.env.STIGMER_SERVER_DIR = dir;
-
-    expect(ensureServer({ node: fakeNode })).toEqual({
-      nodeBin: "/usr/bin/node",
-      entryPath: join(dir, "dist", "main.js"),
-      appDir: dir,
-    });
-  });
-});
-
-describe("resolveServerTs", () => {
-  it("resolves a built server from STIGMER_SERVER_DIR", () => {
-    const dir = builtServerDir();
-    process.env.STIGMER_SERVER_DIR = dir;
-
-    expect(resolveServerTs(fakeNode)).toEqual({
-      nodeBin: "/usr/bin/node",
-      entryPath: join(dir, "dist", "main.js"),
-      appDir: dir,
-    });
-  });
-
-  it("errors with build guidance when dist/main.js is missing", () => {
-    const dir = tempDir("stigmer-server-");
-    writeFileSync(join(dir, "package.json"), "{}");
-    process.env.STIGMER_SERVER_DIR = dir;
-
-    expect(() => resolveServerTs(fakeNode)).toThrow(/not built/);
-    // Remediation rides in hints, not the message.
-    const hints = captureHints(() => resolveServerTs(fakeNode));
-    expect(hints.join("\n")).toMatch(/make build-server/);
-  });
-
-  it("rejects an override that is not a server package", () => {
-    const dir = tempDir("stigmer-server-");
-    process.env.STIGMER_SERVER_DIR = join(dir, "no-package-here"); // no package.json
-    expect(() => resolveServerTs(fakeNode)).toThrow(/not a server package/);
-  });
-});
-
-describe("acquireServer", () => {
-  it("installs the slim package and resolves its main.js entry", () => {
-    const home = tempDir("stigmer-home-");
-    const installed: Array<{ dir: string; spec: string }> = [];
-    const install = (dir: string, spec: string): void => {
-      installed.push({ dir, spec });
-      // Simulate the npm install laying down the slim package.
-      const pkgDir = join(dir, "node_modules", "@stigmer", "server-slim");
-      mkdirSync(pkgDir, { recursive: true });
-      writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
-    };
-
-    const launch = acquireServer({
-      home,
-      version: "0.5.0",
-      node: fakeNode,
-      install,
-    });
-
-    const installDir = join(home, ".stigmer", "runtimes", "0.5.0");
-    expect(launch).toEqual({
-      nodeBin: "/usr/bin/node",
-      entryPath: join(
-        installDir,
-        "node_modules",
-        "@stigmer",
-        "server-slim",
-        "main.js",
-      ),
-      appDir: join(installDir, "node_modules", "@stigmer", "server-slim"),
-    });
-    expect(installed).toEqual([
-      { dir: installDir, spec: "@stigmer/server-slim@0.5.0" },
-    ]);
-  });
-
-  it("reuses a prior install without reinstalling", () => {
-    const home = tempDir("stigmer-home-");
-    const pkgDir = join(
-      home,
-      ".stigmer",
-      "runtimes",
-      "0.5.0",
-      "node_modules",
-      "@stigmer",
-      "server-slim",
-    );
-    mkdirSync(pkgDir, { recursive: true });
-    writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
-
-    const install = vi.fn();
-    const launch = acquireServer({
-      home,
-      version: "0.5.0",
-      node: fakeNode,
-      install,
-    });
-
-    expect(launch.nodeBin).toBe("/usr/bin/node");
-    expect(install).not.toHaveBeenCalled();
-  });
-
-  // The runner and the server share one per-version install root; acquiring
-  // the server after the runner must ADD to it, never clobber the root
-  // manifest the runner's install already wrote.
-  it("shares the runtimes install root with the runner without clobbering it", () => {
-    const home = tempDir("stigmer-home-");
-    const installDir = join(home, ".stigmer", "runtimes", "0.5.0");
-    mkdirSync(installDir, { recursive: true });
-    writeFileSync(
-      join(installDir, "package.json"),
-      '{"name":"stigmer-runtime","marker":"pre-existing"}\n',
-    );
-
-    const install = (dir: string): void => {
-      const pkgDir = join(dir, "node_modules", "@stigmer", "server-slim");
-      mkdirSync(pkgDir, { recursive: true });
-      writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
-    };
-    acquireServer({ home, version: "0.5.0", node: fakeNode, install });
-
-    expect(readFileSync(join(installDir, "package.json"), "utf8")).toContain(
-      "pre-existing",
-    );
-  });
-
-  // The hunted npm failure shape: the install runs but the platform-native
-  // package was skipped (unsupported OS/arch), so the entry never appears.
-  it("errors actionably when the install produces no entry", () => {
-    const home = tempDir("stigmer-home-");
-    const install = vi.fn(); // runs, lays down nothing
-    const attempt = (): unknown => acquireServer({ home, version: "0.5.0", node: fakeNode, install });
-    expect(attempt).toThrow(/install did not produce/);
-    expect(install).toHaveBeenCalledOnce();
-    const hints = captureHints(attempt).join("\n");
-    expect(hints).toMatch(/platform-native/);
-    expect(hints).toMatch(/Remove .* and retry/);
-  });
-
-  // Presence beats acquirability: the all-in-one image bakes a dev-stamped
-  // runtime npm never published; an installed runtime is usable whatever its
-  // version string, and only an install we would have to perform is refused.
-  it("uses an already-installed runtime even for a non-release (dev) build", () => {
-    const home = tempDir("stigmer-home-");
-    const pkgDir = join(home, ".stigmer", "runtimes", "0.0.0-dev.abc123", "node_modules", "@stigmer", "server-slim");
-    mkdirSync(pkgDir, { recursive: true });
-    writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
-
-    const install = vi.fn();
-    const launch = acquireServer({ home, version: "0.0.0-dev.abc123", node: fakeNode, install });
-
-    expect(launch.entryPath).toBe(join(pkgDir, "main.js"));
-    expect(install).not.toHaveBeenCalled();
-  });
-
-  // STIGMER_RUNTIMES_DIR relocates the whole acquired-runtimes root; the
-  // per-version layout under it is unchanged, so a pre-filled root is found
-  // exactly where an on-demand install would have put things.
-  it("reads the runtimes root from STIGMER_RUNTIMES_DIR, keeping the per-version layout", () => {
-    const home = tempDir("stigmer-home-");
-    const root = tempDir("stigmer-runtimes-");
-    process.env.STIGMER_RUNTIMES_DIR = root;
-    const pkgDir = join(root, "0.5.0", "node_modules", "@stigmer", "server-slim");
-    mkdirSync(pkgDir, { recursive: true });
-    writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
-
-    const install = vi.fn();
-    const launch = acquireServer({ home, version: "0.5.0", node: fakeNode, install });
-
-    expect(launch.entryPath).toBe(join(pkgDir, "main.js"));
-    expect(launch.appDir).toBe(pkgDir);
-    expect(install).not.toHaveBeenCalled();
-    expect(readFileSync(join(pkgDir, "main.js"), "utf8")).toBe("// slim bundle");
-  });
-
-  it("refuses to acquire for a non-release (dev) build, naming the fallback", () => {
-    const home = tempDir("stigmer-home-");
-    const attempt = (): unknown =>
-      acquireServer({
-        home,
-        version: "0.0.0-dev",
-        node: fakeNode,
-        install: vi.fn(),
-      });
-    expect(attempt).toThrow(/non-release build/);
-    // The escape hatch rides in the hints: the explicit server dir.
-    const hints = captureHints(attempt);
-    expect(hints.join("\n")).toMatch(/STIGMER_SERVER_DIR/);
-  });
-});
-
-function captureHints(attempt: () => unknown): readonly string[] {
-  try {
-    attempt();
-  } catch (err) {
-    return (err as { hints?: readonly string[] }).hints ?? [];
-  }
-  throw new Error("expected the attempt to throw");
-}

package/src/local/setup/wizard.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Config } from "../../config/config.js";
-import { readLlm } from "../llm-config.js";
-import { readOperator } from "../operator-config.js";
-import {
-  PROVIDER_CHOICES,
-  applyChoice,
-  applyOperatorIdentity,
-  buildLlmForChoice,
-  buildOperatorForInputs,
-} from "./wizard.js";
-
-function config(local?: unknown): Config {
-  return { backend: { type: "local", local } };
-}
-
-// Regression pin: every provider offered by `stigmer setup` promises an
-// execution path the native runner must actually serve. The runner constructs
-// Anthropic clients only and the registry's native-harness entries are all
-// Anthropic — so this list is anthropic + skip, full stop. If this test fails
-// because a provider was added, the native runner and model registry must gain
-// real support for it first (see sdk/react DISABLED_PROVIDERS for the same
-// decision on the UI side).
-describe("PROVIDER_CHOICES", () => {
-  it("offers exactly anthropic and skip", () => {
-    expect([...PROVIDER_CHOICES]).toEqual(["anthropic", "skip"]);
-  });
-});
-
-describe("buildLlmForChoice", () => {
-  it("persists provider and key only — there is no model concept, the registry owns it (oss#314)", () => {
-    expect(buildLlmForChoice("anthropic")).toEqual({ provider: "anthropic" });
-    expect(buildLlmForChoice("anthropic", { apiKey: "k" })).toEqual({
-      provider: "anthropic",
-      api_key: "k",
-    });
-  });
-
-  it("returns undefined for skip (clears config)", () => {
-    expect(buildLlmForChoice("skip")).toBeUndefined();
-  });
-});
-
-describe("applyChoice", () => {
-  it("writes the selection while preserving siblings", () => {
-    const cfg = config({ temporal: { managed: true }, llm: { provider: "anthropic", model: "stale" } });
-    const updated = applyChoice(cfg, "anthropic", { apiKey: "k" });
-    expect(readLlm(updated)).toEqual({ provider: "anthropic", api_key: "k" });
-    expect((updated.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });
-  });
-
-  it("skip clears the llm section", () => {
-    const updated = applyChoice(config({ llm: { provider: "anthropic" } }), "skip");
-    expect(readLlm(updated)).toBeUndefined();
-  });
-});
-
-describe("buildOperatorForInputs", () => {
-  it("persists email (and optional name), trimmed", () => {
-    expect(buildOperatorForInputs(" ada@example.com ", "")).toEqual({ email: "ada@example.com" });
-    expect(buildOperatorForInputs("ada@example.com", " Ada ")).toEqual({
-      email: "ada@example.com",
-      name: "Ada",
-    });
-  });
-
-  it("returns undefined for empty inputs — nothing to persist, identity stays anonymous", () => {
-    expect(buildOperatorForInputs("", "")).toBeUndefined();
-    expect(buildOperatorForInputs("  ", "")).toBeUndefined();
-  });
-
-  // The server's boot rules, surfaced at setup time (oss#796): a malformed
-  // identity must never be persisted only to fail the next `stigmer up`.
-  it("refuses what the server's boot check would refuse", () => {
-    expect(() => buildOperatorForInputs("not-an-email", "")).toThrow(/missing '@'/);
-    expect(() => buildOperatorForInputs("", "Ada")).toThrow(/set both or neither/);
-  });
-});
-
-describe("applyOperatorIdentity", () => {
-  it("writes the identity while preserving siblings", () => {
-    const cfg = config({ temporal: { managed: true }, llm: { provider: "anthropic" } });
-    const updated = applyOperatorIdentity(cfg, "ada@example.com", "Ada");
-    expect(readOperator(updated)).toEqual({ email: "ada@example.com", name: "Ada" });
-    expect(readLlm(updated)).toEqual({ provider: "anthropic" });
-    expect((updated.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });
-  });
-
-  it("empty inputs leave the config unchanged (skip, not clear)", () => {
-    const cfg = config({ operator: { email: "keep@example.com" } });
-    const updated = applyOperatorIdentity(cfg, "", "");
-    expect(readOperator(updated)).toEqual({ email: "keep@example.com" });
-  });
-});