@stigmer/cli 3.35.0 → 3.37.0

package/src/errors/clierr.test.ts

@@ -1,172 +0,0 @@
-import { Code, ConnectError } from "@connectrpc/connect";
-import { StigmerError } from "@stigmer/sdk";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { setDebug } from "../runtime.js";
-import { classify } from "./classify.js";
-import { ExitCode } from "./exit-codes.js";
-import { formatError, handle } from "./handle.js";
-import { UsageError } from "./usage-error.js";
-
-afterEach(() => {
-  setDebug(false);
-  vi.restoreAllMocks();
-});
-
-describe("classify — gRPC code to exit code", () => {
-  // Drives both error sources: a raw ConnectError (direct transport usage) and
-  // an SDK StigmerError (typed client usage). Both must classify identically.
-  const cases: ReadonlyArray<{ code: number; exit: number; messageContains?: string }> = [
-    { code: Code.Unavailable, exit: ExitCode.Connection },
-    { code: Code.DeadlineExceeded, exit: ExitCode.Connection },
-    { code: Code.ResourceExhausted, exit: ExitCode.Connection },
-    { code: Code.NotFound, exit: ExitCode.NotFound },
-    { code: Code.InvalidArgument, exit: ExitCode.Usage },
-    { code: Code.FailedPrecondition, exit: ExitCode.Usage, messageContains: "Precondition failed" },
-    { code: Code.AlreadyExists, exit: ExitCode.Usage, messageContains: "Already exists" },
-    { code: Code.Unauthenticated, exit: ExitCode.Auth },
-    { code: Code.PermissionDenied, exit: ExitCode.Auth, messageContains: "Permission denied" },
-    { code: Code.Internal, exit: ExitCode.General },
-    { code: Code.Aborted, exit: ExitCode.General, messageContains: "Operation aborted" },
-    { code: Code.Canceled, exit: ExitCode.General },
-    { code: Code.Unimplemented, exit: ExitCode.General, messageContains: "Unimplemented" },
-    { code: Code.OutOfRange, exit: ExitCode.General, messageContains: "OutOfRange" },
-    { code: Code.DataLoss, exit: ExitCode.General, messageContains: "DataLoss" },
-  ];
-
-  for (const { code, exit, messageContains } of cases) {
-    it(`maps ConnectError ${Code[code]} -> exit ${exit}`, () => {
-      const result = classify(new ConnectError("boom", code));
-      expect(result?.exitCode).toBe(exit);
-      expect(result?.code).toBe(code);
-      if (messageContains) expect(result?.message).toContain(messageContains);
-    });
-
-    it(`maps StigmerError ${Code[code]} -> exit ${exit}`, () => {
-      const result = classify(new StigmerError("unknown", "boom", code));
-      expect(result?.exitCode).toBe(exit);
-    });
-  }
-
-  it("preserves the server message verbatim for NotFound", () => {
-    const result = classify(new ConnectError("agent 'foo' not found", Code.NotFound));
-    expect(result?.message).toBe("agent 'foo' not found");
-  });
-
-  it("attaches remediation hints for auth failures", () => {
-    const result = classify(new ConnectError("nope", Code.Unauthenticated));
-    expect(result?.hints).toEqual(["Please sign in:", "  stigmer auth login"]);
-  });
-});
-
-describe("classify — non-RPC and edge cases", () => {
-  it("returns null for null/undefined", () => {
-    expect(classify(null)).toBeNull();
-    expect(classify(undefined)).toBeNull();
-  });
-
-  it("classifies a plain Error as a general failure", () => {
-    const result = classify(new Error("disk full"));
-    expect(result?.exitCode).toBe(ExitCode.General);
-    expect(result?.message).toBe("disk full");
-    expect(result?.code).toBeUndefined();
-  });
-
-  it("unwraps a wrapped RPC error via the cause chain", () => {
-    const inner = new ConnectError("not found", Code.NotFound);
-    const wrapped = new Error("while fetching agent", { cause: inner });
-    const result = classify(wrapped);
-    expect(result?.exitCode).toBe(ExitCode.NotFound);
-  });
-
-  it("maps a local UsageError to the usage exit code", () => {
-    const result = classify(new UsageError("invalid --output value"));
-    expect(result?.exitCode).toBe(ExitCode.Usage);
-    expect(result?.message).toBe("invalid --output value");
-  });
-});
-
-describe("classify — local abort vs remote cancel", () => {
-  it("treats a local AbortError as a clean exit 0 with no message", () => {
-    const abort = new Error("aborted");
-    abort.name = "AbortError";
-    const result = classify(abort);
-    expect(result?.exitCode).toBe(ExitCode.Success);
-    expect(result?.message).toBe("");
-  });
-
-  it("treats an aborted RPC (Canceled wrapping AbortError) as exit 0", () => {
-    const abort = new Error("aborted");
-    abort.name = "AbortError";
-    const cancelled = new ConnectError("canceled", Code.Canceled, undefined, undefined, abort);
-    const result = classify(cancelled);
-    expect(result?.exitCode).toBe(ExitCode.Success);
-  });
-
-  it("treats a remote Canceled (no local abort) as exit 1", () => {
-    const result = classify(new ConnectError("server canceled", Code.Canceled));
-    expect(result?.exitCode).toBe(ExitCode.General);
-    expect(result?.message).toBe("Operation cancelled");
-  });
-});
-
-describe("formatError", () => {
-  it("renders message and hints", () => {
-    const out = formatError(
-      { exitCode: ExitCode.Auth, message: "Not authenticated", hints: ["Please sign in:", "  stigmer auth login"] },
-      false,
-    );
-    expect(out).toBe("Error: Not authenticated\n\nPlease sign in:\n  stigmer auth login\n");
-  });
-
-  it("returns empty string for a silent (empty message) error", () => {
-    expect(formatError({ exitCode: ExitCode.Success, message: "" }, false)).toBe("");
-  });
-
-  it("appends the raw chain and numeric code in debug mode", () => {
-    const cause = new ConnectError("boom", Code.NotFound);
-    const out = formatError(
-      { exitCode: ExitCode.NotFound, message: "missing", cause, code: Code.NotFound },
-      true,
-    );
-    expect(out).toContain("--- debug ---");
-    expect(out).toContain(`gRPC code: NotFound (${Code.NotFound})`);
-  });
-
-  it("omits the debug block when debug mode is off", () => {
-    const cause = new Error("boom");
-    const out = formatError({ exitCode: ExitCode.General, message: "x", cause }, false);
-    expect(out).not.toContain("--- debug ---");
-  });
-});
-
-describe("handle", () => {
-  it("exits with the mapped code and writes to stderr", () => {
-    const exitSpy = vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
-      throw new Error(`__exit__:${code}`);
-    }) as never);
-    const stderrSpy = vi.spyOn(process.stderr, "write").mockReturnValue(true);
-
-    expect(() => handle(new ConnectError("agent missing", Code.NotFound))).toThrow("__exit__:5");
-    expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining("Error: agent missing"));
-    expect(exitSpy).toHaveBeenCalledWith(ExitCode.NotFound);
-  });
-
-  it("exits 0 silently for a local abort", () => {
-    const exitSpy = vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
-      throw new Error(`__exit__:${code}`);
-    }) as never);
-    const stderrSpy = vi.spyOn(process.stderr, "write").mockReturnValue(true);
-
-    const abort = new Error("aborted");
-    abort.name = "AbortError";
-    expect(() => handle(abort)).toThrow("__exit__:0");
-    expect(stderrSpy).not.toHaveBeenCalled();
-  });
-
-  it("exits 0 when there is no error", () => {
-    vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
-      throw new Error(`__exit__:${code}`);
-    }) as never);
-    expect(() => handle(null)).toThrow("__exit__:0");
-  });
-});

package/src/local/artifact.test.ts

@@ -1,54 +0,0 @@
-import { createHash } from "node:crypto";
-import { describe, expect, it } from "vitest";
-import { mapReleaseArch, mapReleaseOs, parseShasum, sha256Hex } from "./artifact.js";
-
-describe("mapReleaseOs", () => {
-  it("maps Node platforms to release OS tokens", () => {
-    expect(mapReleaseOs("darwin")).toBe("darwin");
-    expect(mapReleaseOs("win32")).toBe("windows");
-    expect(mapReleaseOs("linux")).toBe("linux");
-    expect(mapReleaseOs("freebsd")).toBe("linux"); // default bucket
-  });
-});
-
-describe("mapReleaseArch", () => {
-  it("maps Node arch names to release arch tokens", () => {
-    expect(mapReleaseArch("arm64")).toBe("arm64");
-    expect(mapReleaseArch("x64")).toBe("amd64");
-    expect(mapReleaseArch("ppc64")).toBe("ppc64"); // passthrough
-  });
-});
-
-describe("sha256Hex", () => {
-  it("computes a lowercase hex digest matching node:crypto", () => {
-    const bytes = new Uint8Array([1, 2, 3, 4, 5]);
-    const expected = createHash("sha256").update(bytes).digest("hex");
-    expect(sha256Hex(bytes)).toBe(expected);
-  });
-});
-
-// A release-wide `sha256sum` file is matched by filename, never by position,
-// and the binary-mode "*" prefix is not part of a name.
-describe("parseShasum", () => {
-  const A = "a".repeat(64);
-  const B = "b".repeat(64);
-
-  it("returns the digest on the line naming the file, wherever the line is", () => {
-    const file = `${A}  first.tar.gz\n${B}  second.tar.gz\n`;
-    expect(parseShasum(file, "second.tar.gz")).toBe(B);
-    expect(parseShasum(file, "first.tar.gz")).toBe(A);
-  });
-
-  it("returns an empty string when no line names the file", () => {
-    expect(parseShasum(`${A}  first.tar.gz\n`, "missing.tar.gz")).toBe("");
-    expect(parseShasum("", "missing.tar.gz")).toBe("");
-  });
-
-  it("accepts sha256sum's binary-mode marker and normalises the hex to lowercase", () => {
-    expect(parseShasum(`${A.toUpperCase()} *first.tar.gz\n`, "first.tar.gz")).toBe(A);
-  });
-
-  it("ignores blank and malformed lines", () => {
-    expect(parseShasum(`\n\nnot-a-digest\n${B}  x.tar.gz\n`, "x.tar.gz")).toBe(B);
-  });
-});

package/src/local/bootstrap.test.ts

@@ -1,166 +0,0 @@
-// Pins the bootstrap's one act over a real Connect backend: an org the
-// identity already sees is `present` with no create; an absent one is created
-// as the Organization as code (slug, name, self-managed) with NO label, since
-// a reserved `stigmer.ai/` label is refused by a self-hosted server with
-// authentication on (stigmer/stigmer#1192); a create that loses the race to
-// another launcher (ALREADY_EXISTS) is `present`, not an error; any other
-// refusal propagates with the server's sentence. And the local shape `up`
-// runs: it announces a created org, stays quiet on a present one, and turns
-// any failure into one warning naming the retry, never a throw.
-
-import {
-  createServer as createHttp2Server,
-  type Http2Server,
-  type ServerHttp2Session,
-} from "node:http2";
-import type { AddressInfo } from "node:net";
-import { create } from "@bufbuild/protobuf";
-import { Code, ConnectError, type ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import {
-  type Organization,
-  OrganizationSchema,
-} from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/api_pb";
-import { OrganizationCommandController } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/command_pb";
-import { ManagementMode } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/enum_pb";
-import { OrganizationsSchema } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/io_pb";
-import { OrganizationQueryController } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/query_pb";
-import { createNodeClient, normalizeEndpoint } from "@stigmer/sdk/node";
-import type { Stigmer } from "@stigmer/sdk";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import type { BackendClient } from "../client/index.js";
-import { DEFAULT_LOCAL_ORG } from "../config/resolve.js";
-import { bootstrapBackend, bootstrapLocalBackend } from "./bootstrap.js";
-
-let backend: Http2Server;
-let stigmer: Stigmer;
-const openSessions = new Set<ServerHttp2Session>();
-
-/** The orgs the backend holds, by slug. */
-let held: Map<string, Organization>;
-let creates: Organization[];
-/** What `create` answers with instead of creating, when set. */
-let refuseCreate: ConnectError | undefined;
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(OrganizationQueryController, {
-      findMyOrganizations: () =>
-        create(OrganizationsSchema, { entries: [...held.values()] }),
-    });
-    router.service(OrganizationCommandController, {
-      create: (org) => {
-        creates.push(org);
-        if (refuseCreate !== undefined) throw refuseCreate;
-        const slug = org.metadata?.slug ?? "";
-        const row = create(OrganizationSchema, org);
-        if (row.metadata !== undefined) row.metadata.id = `org_${slug}`;
-        held.set(slug, row);
-        return row;
-      },
-    });
-  };
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-  stigmer = createNodeClient({
-    baseUrl: normalizeEndpoint(`127.0.0.1:${port}`),
-  });
-});
-
-afterAll(async () => {
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-beforeEach(() => {
-  held = new Map();
-  creates = [];
-  refuseCreate = undefined;
-});
-
-describe("bootstrapBackend", () => {
-  it("is present, with no create, when the identity already sees the org", async () => {
-    held.set(
-      DEFAULT_LOCAL_ORG,
-      create(OrganizationSchema, { metadata: { slug: DEFAULT_LOCAL_ORG } }),
-    );
-    expect(await bootstrapBackend(stigmer)).toBe("present");
-    expect(creates).toHaveLength(0);
-  });
-
-  it("creates the Organization as code, with no label, when absent", async () => {
-    held.set("acme", create(OrganizationSchema, { metadata: { slug: "acme" } }));
-    expect(await bootstrapBackend(stigmer)).toBe("created");
-    expect(creates).toHaveLength(1);
-    const sent = creates[0]!;
-    expect(sent.metadata?.slug).toBe(DEFAULT_LOCAL_ORG);
-    expect(sent.metadata?.org).toBe(DEFAULT_LOCAL_ORG);
-    expect(sent.metadata?.name).toBe("Stigmer");
-    expect(sent.metadata?.labels).toEqual({});
-    expect(sent.spec?.managementMode).toBe(ManagementMode.self_managed);
-    expect(sent.spec?.description).not.toBe("");
-  });
-
-  it("treats a create lost to another launcher as present", async () => {
-    refuseCreate = new ConnectError(
-      `organization '${DEFAULT_LOCAL_ORG}' already exists`,
-      Code.AlreadyExists,
-    );
-    expect(await bootstrapBackend(stigmer)).toBe("present");
-  });
-
-  it("propagates any other refusal with the server's sentence", async () => {
-    refuseCreate = new ConnectError("organization creation is disabled", Code.PermissionDenied);
-    await expect(bootstrapBackend(stigmer)).rejects.toThrow(
-      /organization creation is disabled/,
-    );
-  });
-});
-
-describe("bootstrapLocalBackend", () => {
-  const client = { stigmer: {} as unknown as Stigmer } as unknown as BackendClient;
-
-  it("runs the act over the local client and announces a created org", async () => {
-    const said: string[] = [];
-    let seen: Stigmer | undefined;
-    await bootstrapLocalBackend({
-      client,
-      say: (line) => said.push(line),
-      bootstrap: async (s) => {
-        seen = s;
-        return "created";
-      },
-    });
-    expect(seen).toBe(client.stigmer);
-    expect(said).toEqual([`Created the '${DEFAULT_LOCAL_ORG}' organization`]);
-  });
-
-  it("says nothing when the org is already present", async () => {
-    const said: string[] = [];
-    await bootstrapLocalBackend({
-      client,
-      say: (line) => said.push(line),
-      bootstrap: async () => "present",
-    });
-    expect(said).toEqual([]);
-  });
-
-  it("contains a failure in one warning naming the retry", async () => {
-    const said: string[] = [];
-    await bootstrapLocalBackend({
-      client,
-      say: (line) => said.push(line),
-      bootstrap: async () => {
-        throw new Error("backend unreachable");
-      },
-    });
-    expect(said).toEqual([
-      "Warning: failed to bootstrap the local backend. Run 'stigmer up' again to retry.",
-    ]);
-  });
-});

package/src/local/daemon/components.test.ts

@@ -1,148 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { join } from "node:path";
-import { RUNNER_READY_MARKER, RUNNER_TASK_QUEUE } from "../constants.js";
-import type { DaemonConfig } from "./env.js";
-import { buildComponents, buildRunnerEnv, buildServerEnv } from "./components.js";
-
-const config: DaemonConfig = {
-  dataDir: "/home/u/.stigmer/data",
-  logDir: "/home/u/.stigmer/data/logs",
-  temporalManaged: true,
-  temporalAddress: "127.0.0.1:7233",
-  serverOnly: false,
-  noWeb: false,
-  server: { nodeBin: "/bin/node", entryPath: "/repo/server/dist/main.js", appDir: "/repo/server" },
-  runner: { nodeBin: "/bin/node", entryPath: "/repo/runner/dist/main.js", appDir: "/repo/runner" },
-};
-
-describe("buildServerEnv", () => {
-  it("pins ports, queues, and db/storage paths under ~/.stigmer", () => {
-    const env = buildServerEnv(config, {});
-    expect(env.GRPC_PORT).toBe("7234");
-    expect(env.TEMPORAL_HOST_PORT).toBe("127.0.0.1:7233");
-    expect(env.TEMPORAL_NAMESPACE).toBe("default");
-    expect(env.TEMPORAL_AGENT_EXECUTION_RUNNER_TASK_QUEUE).toBe(RUNNER_TASK_QUEUE);
-    expect(env.TEMPORAL_WORKFLOW_EXECUTION_RUNNER_TASK_QUEUE).toBe(RUNNER_TASK_QUEUE);
-    expect(env.DB_PATH).toBe("/home/u/.stigmer/stigmer.db");
-    expect(env.STORAGE_PATH).toBe("/home/u/.stigmer/storage");
-  });
-
-  it("forwards the operator identity only when set, resolved value winning over the base env (oss#796)", () => {
-    const bare = buildServerEnv(config, {});
-    expect(bare.STIGMER_OPERATOR_EMAIL).toBeUndefined();
-    expect(bare.STIGMER_OPERATOR_NAME).toBeUndefined();
-
-    // Contract value authoritative over a stale inherited export — the
-    // ANTHROPIC_API_KEY precedent in buildRunnerEnv.
-    const env = buildServerEnv(
-      { ...config, operatorEmail: "ada@example.com", operatorName: "Ada" },
-      { STIGMER_OPERATOR_EMAIL: "stale@example.com" },
-    );
-    expect(env.STIGMER_OPERATOR_EMAIL).toBe("ada@example.com");
-    expect(env.STIGMER_OPERATOR_NAME).toBe("Ada");
-  });
-
-  it("does not deliver the operator identity to the runner — it resolves identity from session data", () => {
-    const env = buildRunnerEnv({ ...config, operatorEmail: "ada@example.com" }, {});
-    expect(env.STIGMER_OPERATOR_EMAIL).toBeUndefined();
-  });
-});
-
-describe("buildRunnerEnv", () => {
-  it("configures static mode with the workspace and pinned queue", () => {
-    const env = buildRunnerEnv(config, {});
-    expect(env.MODE).toBe("local");
-    expect(env.STIGMER_RUNNER_MODE).toBeUndefined(); // static mode
-    expect(env.STIGMER_BACKEND_ENDPOINT).toBe("http://localhost:7234");
-    expect(env.TEMPORAL_SERVICE_ADDRESS).toBe("127.0.0.1:7233");
-    expect(env.TEMPORAL_NAMESPACE).toBe("default");
-    expect(env.WORKSPACE_ROOT_DIR).toBe("/home/u/.stigmer/data/workspace");
-    expect(env.STIGMER_TASK_QUEUE).toBe(RUNNER_TASK_QUEUE);
-    expect(env.LOG_LEVEL).toBe("info");
-  });
-
-  it("forwards CURSOR_API_KEY and activity routing only when set", () => {
-    expect(buildRunnerEnv(config, {}).CURSOR_API_KEY).toBeUndefined();
-    const withKey = buildRunnerEnv({ ...config, cursorApiKey: "ck", activityRouting: "session" }, {});
-    expect(withKey.CURSOR_API_KEY).toBe("ck");
-    expect(withKey.STIGMER_ACTIVITY_ROUTING).toBe("session");
-  });
-
-  it("forwards the Anthropic key only when set, resolved value winning over the base env", () => {
-    const bare = buildRunnerEnv(config, {});
-    expect(bare.ANTHROPIC_API_KEY).toBeUndefined();
-
-    // The contract value is authoritative: the launcher already applied the
-    // env > config precedence, so whatever sits in the child's base env must
-    // not override the resolved key.
-    const env = buildRunnerEnv(
-      { ...config, anthropicApiKey: "sk-ant-resolved" },
-      { ANTHROPIC_API_KEY: "sk-ant-other" },
-    );
-    expect(env.ANTHROPIC_API_KEY).toBe("sk-ant-resolved");
-  });
-
-  // Anthropic is the only key with a contract slot; other provider keys (for
-  // advanced per-agent overrides) flow through shell-env inheritance untouched.
-  it("passes other shell-exported provider keys through via the base env spread", () => {
-    const env = buildRunnerEnv(config, { OPENAI_API_KEY: "sk-oai-shell" });
-    expect(env.OPENAI_API_KEY).toBe("sk-oai-shell");
-  });
-
-  // The regression guard for the queue bug: the server dispatches to, and the
-  // runner polls, the exact same queue.
-  it("pins the runner's poll queue to the server's dispatch queue", () => {
-    const serverEnv = buildServerEnv(config, {});
-    const runnerEnv = buildRunnerEnv(config, {});
-    expect(runnerEnv.STIGMER_TASK_QUEUE).toBe(serverEnv.TEMPORAL_AGENT_EXECUTION_RUNNER_TASK_QUEUE);
-    expect(runnerEnv.STIGMER_TASK_QUEUE).toBe(serverEnv.TEMPORAL_WORKFLOW_EXECUTION_RUNNER_TASK_QUEUE);
-  });
-
-  // #285 regression guard: the server's artifact base and the runner's artifact
-  // path must be the SAME directory, or a storage-key attachment the server
-  // wrote fails to resolve when the runner reads it back. Both must be defined
-  // (a naive `runnerEnv.X === serverEnv.Y` would pass vacuously on
-  // undefined === undefined) and equal to the ~/.stigmer/data/artifacts root.
-  it("pins the runner's artifact path to the server's artifact base", () => {
-    const serverEnv = buildServerEnv(config, {});
-    const runnerEnv = buildRunnerEnv(config, {});
-    const expected = join(config.dataDir, "artifacts");
-
-    expect(serverEnv.ARTIFACT_LOCAL_BASE_PATH).toBe(expected);
-    expect(runnerEnv.LOCAL_ARTIFACT_PATH).toBe(expected);
-    expect(runnerEnv.LOCAL_ARTIFACT_PATH).toBe(serverEnv.ARTIFACT_LOCAL_BASE_PATH);
-    expect(runnerEnv.ARTIFACT_STORAGE_TYPE).toBe("local");
-    // Serve URL pinned to the server's artifact HTTP port (GRPC_PORT + 1).
-    expect(runnerEnv.LOCAL_ARTIFACT_SERVE_URL).toBe("http://localhost:7235");
-  });
-});
-
-describe("buildComponents", () => {
-  it("orders server (critical, gated) before runner (marker, not critical)", () => {
-    const components = buildComponents(config, {});
-    expect(components.map((c) => c.name)).toEqual(["stigmer-server", "runner"]);
-
-    const [server, runner] = components;
-    expect(server.critical).toBe(true);
-    expect(server.gate).toBeDefined();
-    expect(server.resolve().readinessMarker).toBeUndefined();
-
-    expect(runner.critical).toBe(false);
-    expect(runner.gate).toBeUndefined();
-    expect(runner.resolve().readinessMarker).toBe(RUNNER_READY_MARKER);
-    expect(runner.resolve().args).toEqual(["/repo/runner/dist/main.js"]);
-  });
-
-  // The TS server child is `node <entry>` — the runner's launch shape.
-  it("spawns the node-shape server as node + entry", () => {
-    const [server] = buildComponents(config, {});
-    const spawn = server.resolve();
-    expect(spawn.command).toBe("/bin/node");
-    expect(spawn.args).toEqual(["/repo/server/dist/main.js"]);
-  });
-
-  it("omits the runner in server-only mode", () => {
-    const components = buildComponents({ ...config, serverOnly: true }, {});
-    expect(components.map((c) => c.name)).toEqual(["stigmer-server"]);
-  });
-});