@stigmer/cli 3.0.8

package/src/local/llm-config.ts

@@ -0,0 +1,107 @@
+// Typed view over the otherwise-opaque `backend.local` config section, scoped to
+// the LLM settings `setup` writes and `status` reads.
+//
+// The config module (config/config.ts) carries `backend.local` through verbatim
+// so the TS CLI never drops fields it does not model. This module adds a *typed
+// lens* for the one sub-tree T05 owns — `local.llm` — and ports the Go CLI's
+// `ResolveLLM*` precedence (env override > config file > provider default) so the
+// two CLIs agree on which provider/model is effectively in force. Writes merge
+// into a shallow copy of `local`, preserving every sibling key (temporal,
+// execution, …).
+
+import type { Config } from "../config/config.js";
+
+/** LLM settings as persisted under `backend.local.llm` (snake_case = YAML keys). */
+export interface LlmSettings {
+  provider?: string;
+  model?: string;
+  api_key?: string;
+  base_url?: string;
+}
+
+interface LocalSection {
+  llm?: LlmSettings;
+  [key: string]: unknown;
+}
+
+/** Default model per provider, matching the Go setup wizard's choices. */
+const DEFAULT_MODEL: Record<string, string> = {
+  ollama: "qwen2.5-coder:7b",
+  anthropic: "claude-sonnet-4.5",
+  openai: "gpt-4",
+};
+
+/** Default base URL per provider (only Ollama needs one). */
+const DEFAULT_BASE_URL: Record<string, string> = {
+  ollama: "http://localhost:11434",
+};
+
+function localSection(config: Config): LocalSection {
+  const local = config.backend.local;
+  return local !== null && typeof local === "object" ? (local as LocalSection) : {};
+}
+
+/** The persisted LLM settings, if any. */
+export function readLlm(config: Config): LlmSettings | undefined {
+  return localSection(config).llm;
+}
+
+/**
+ * Detect a provider from API keys present in the environment (Anthropic first,
+ * then OpenAI), matching the Go CLI's `DetectProviderFromAPIKeys`.
+ */
+export function detectProviderFromEnv(env: NodeJS.ProcessEnv = process.env): string {
+  if (env.ANTHROPIC_API_KEY) return "anthropic";
+  if (env.OPENAI_API_KEY) return "openai";
+  return "";
+}
+
+/** Effective provider: env override > config > API-key autodetect. */
+export function resolveProvider(config: Config, env: NodeJS.ProcessEnv = process.env): string {
+  if (env.STIGMER_LLM_PROVIDER) return env.STIGMER_LLM_PROVIDER;
+  const llm = readLlm(config);
+  if (llm?.provider) return llm.provider;
+  return detectProviderFromEnv(env);
+}
+
+/** Effective model: env override > config > provider default. */
+export function resolveModel(config: Config, env: NodeJS.ProcessEnv = process.env): string {
+  if (env.STIGMER_LLM_MODEL) return env.STIGMER_LLM_MODEL;
+  const llm = readLlm(config);
+  if (llm?.model) return llm.model;
+  return DEFAULT_MODEL[resolveProvider(config, env)] ?? "";
+}
+
+/** Effective API key: provider-specific env var > config. */
+export function resolveApiKey(config: Config, env: NodeJS.ProcessEnv = process.env): string {
+  const provider = resolveProvider(config, env);
+  const envKey = provider === "anthropic" ? env.ANTHROPIC_API_KEY : provider === "openai" ? env.OPENAI_API_KEY : "";
+  if (envKey) return envKey;
+  return readLlm(config)?.api_key ?? "";
+}
+
+/** Fill in provider-appropriate defaults for a partial selection. */
+export function withProviderDefaults(settings: LlmSettings): LlmSettings {
+  const provider = settings.provider ?? "";
+  const out: LlmSettings = { provider };
+  out.model = settings.model ?? DEFAULT_MODEL[provider];
+  if (settings.api_key) out.api_key = settings.api_key;
+  const baseUrl = settings.base_url ?? DEFAULT_BASE_URL[provider];
+  if (baseUrl) out.base_url = baseUrl;
+  return out;
+}
+
+/**
+ * Return a copy of `config` with the LLM section replaced, preserving every
+ * other key under `backend.local`. Passing `undefined` clears the LLM section
+ * (the wizard's "skip" path).
+ */
+export function setLlm(config: Config, settings: LlmSettings | undefined): Config {
+  const local: LocalSection = { ...localSection(config) };
+  if (settings === undefined) {
+    delete local.llm;
+  } else {
+    local.llm = settings;
+  }
+  return { ...config, backend: { ...config.backend, local } };
+}

package/src/local/logs/tail.test.ts

@@ -0,0 +1,70 @@
+import { appendFileSync, mkdtempSync, renameSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { followFile, tailLines } from "./tail.js";
+
+let dir: string;
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "stigmer-tail-"));
+});
+
+describe("tailLines", () => {
+  it("returns the last n lines, ignoring a trailing newline", () => {
+    const file = join(dir, "a.log");
+    writeFileSync(file, "l1\nl2\nl3\nl4\n");
+    expect(tailLines(file, 2)).toEqual(["l3", "l4"]);
+    expect(tailLines(file, 0)).toEqual(["l1", "l2", "l3", "l4"]);
+    expect(tailLines(file, 10)).toEqual(["l1", "l2", "l3", "l4"]);
+  });
+
+  it("returns empty for a missing file", () => {
+    expect(tailLines(join(dir, "nope.log"), 5)).toEqual([]);
+  });
+});
+
+describe("followFile", () => {
+  const tick = () => vi.advanceTimersByTimeAsync(250);
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    return () => vi.useRealTimers();
+  });
+
+  it("emits only newly appended lines", async () => {
+    const file = join(dir, "f.log");
+    writeFileSync(file, "old\n");
+    const seen: string[] = [];
+    const handle = followFile(file, (line) => seen.push(line), { pollMs: 200 });
+
+    appendFileSync(file, "new1\nnew2\n");
+    await tick();
+    expect(seen).toEqual(["new1", "new2"]);
+    handle.stop();
+  });
+
+  it("reopens after rotation (inode change)", async () => {
+    const file = join(dir, "r.log");
+    writeFileSync(file, "before\n");
+    const seen: string[] = [];
+    const handle = followFile(file, (line) => seen.push(line), { pollMs: 200 });
+
+    // Rotate: move the file aside and create a fresh one in its place.
+    renameSync(file, join(dir, "r.log.1"));
+    writeFileSync(file, "after-rotate\n");
+    await tick();
+
+    expect(seen).toContain("after-rotate");
+    handle.stop();
+  });
+
+  it("with fromStart, emits existing content too", async () => {
+    const file = join(dir, "s.log");
+    writeFileSync(file, "existing\n");
+    const seen: string[] = [];
+    const handle = followFile(file, (line) => seen.push(line), { pollMs: 200, fromStart: true });
+    await tick();
+    expect(seen).toContain("existing");
+    handle.stop();
+  });
+});

package/src/local/logs/tail.ts

@@ -0,0 +1,100 @@
+// Log tailing + following primitives, robust to the daemon's log rotation.
+//
+// Logs are bounded (rotated at daemon start), so `tailLines` reads the whole
+// file and slices — far simpler and less bug-prone than fd seeking, with no
+// meaningful cost at these sizes. `followFile` is a poll-based `tail -F`:
+// polling `stat` rather than `fs.watch` is deliberate, because `fs.watch`'s
+// rename/rotation semantics differ across platforms and silently miss events.
+// Rotation and truncation are detected by inode change and size shrink
+// respectively, and the reader reopens from the start so no lines are lost.
+
+import { closeSync, openSync, readFileSync, readSync, statSync } from "node:fs";
+
+/** Return the last `n` non-empty-trailing lines of a file (all lines if n<=0). */
+export function tailLines(file: string, n: number): string[] {
+  let content: string;
+  try {
+    content = readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = content.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return n <= 0 ? lines : lines.slice(-n);
+}
+
+export interface FollowHandle {
+  /** Stop polling and release resources. */
+  stop(): void;
+}
+
+export interface FollowOptions {
+  /** Poll interval; defaults to 200ms. */
+  pollMs?: number;
+  /** Start from byte 0 instead of the current end (emit existing content too). */
+  fromStart?: boolean;
+}
+
+/**
+ * Stream lines appended to `file`, invoking `onLine` per complete line. Survives
+ * rotation (inode change -> reopen from 0) and truncation (size shrink -> reset
+ * to 0). Returns a handle whose `stop()` ends the stream.
+ */
+export function followFile(file: string, onLine: (line: string) => void, options: FollowOptions = {}): FollowHandle {
+  const pollMs = options.pollMs ?? 200;
+  let inode = -1;
+  let offset = 0;
+  let buffer = "";
+  let started = false;
+
+  const drain = (): void => {
+    let newline: number;
+    while ((newline = buffer.indexOf("\n")) >= 0) {
+      onLine(buffer.slice(0, newline));
+      buffer = buffer.slice(newline + 1);
+    }
+  };
+
+  const tick = (): void => {
+    let stat: ReturnType<typeof statSync>;
+    try {
+      stat = statSync(file);
+    } catch {
+      return; // file not created yet, or briefly gone mid-rotation
+    }
+
+    if (stat.ino !== inode) {
+      // First sight of the file, or it was rotated out from under us.
+      inode = stat.ino;
+      offset = started || options.fromStart === true ? 0 : stat.size;
+      buffer = "";
+    } else if (stat.size < offset) {
+      offset = 0; // truncated in place
+      buffer = "";
+    }
+    started = true;
+
+    if (stat.size <= offset) return;
+
+    const length = stat.size - offset;
+    const chunk = Buffer.alloc(length);
+    const fd = openSync(file, "r");
+    try {
+      readSync(fd, chunk, 0, length, offset);
+    } finally {
+      closeSync(fd);
+    }
+    offset = stat.size;
+    buffer += chunk.toString("utf8");
+    drain();
+  };
+
+  tick();
+  const timer = setInterval(tick, pollMs);
+  timer.unref?.();
+  return {
+    stop(): void {
+      clearInterval(timer);
+    },
+  };
+}

package/src/local/logs/view.test.ts

@@ -0,0 +1,46 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { beforeEach, describe, expect, it } from "vitest";
+import { allComponents, componentByName, printTail } from "./view.js";
+
+let dir: string;
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "stigmer-logsview-"));
+});
+
+class CaptureSink {
+  chunks: string[] = [];
+  write(chunk: string): void {
+    this.chunks.push(chunk);
+  }
+  get text(): string {
+    return this.chunks.join("");
+  }
+}
+
+describe("componentByName / allComponents", () => {
+  it("knows the three daemon components", () => {
+    expect(allComponents(dir).map((c) => c.name)).toEqual(["stigmer-server", "runner", "temporal"]);
+    expect(componentByName(dir, "runner")?.file).toBe(join(dir, "runner.log"));
+    expect(componentByName(dir, "bogus")).toBeUndefined();
+  });
+});
+
+describe("printTail", () => {
+  it("does not prefix a single component", () => {
+    writeFileSync(join(dir, "runner.log"), "r1\nr2\n");
+    const sink = new CaptureSink();
+    printTail([componentByName(dir, "runner")!], 5, sink);
+    expect(sink.text).toBe("r1\nr2\n");
+  });
+
+  it("prefixes lines with the component name when showing several", () => {
+    writeFileSync(join(dir, "stigmer-server.log"), "s1\n");
+    writeFileSync(join(dir, "runner.log"), "r1\n");
+    writeFileSync(join(dir, "temporal.log"), "t1\n");
+    const sink = new CaptureSink();
+    printTail(allComponents(dir), 5, sink);
+    expect(sink.text).toBe("[stigmer-server] s1\n[runner] r1\n[temporal] t1\n");
+  });
+});

package/src/local/logs/view.ts

@@ -0,0 +1,65 @@
+// Multi-component log viewing for `stigmer logs`: print a tail snapshot and,
+// optionally, follow appended lines live.
+//
+// Divergence from the Go CLI (documented, not drift): the Go `--all` view merges
+// components by parsing each line's timestamp. That parse is fragile across the
+// server's and runner's different log formats and silently misorders lines it
+// cannot parse. The TS view instead prefixes every line with its component name
+// (kubectl-style), which is robust without any format coupling and reads clearly
+// in both snapshot and follow modes.
+
+import { join } from "node:path";
+import { type FollowHandle, followFile, tailLines } from "./tail.js";
+
+export interface LogComponent {
+  readonly name: string;
+  readonly file: string;
+}
+
+/** The components whose logs the daemon writes, in dependency order. */
+export function allComponents(logDir: string): LogComponent[] {
+  return [
+    { name: "stigmer-server", file: join(logDir, "stigmer-server.log") },
+    { name: "runner", file: join(logDir, "runner.log") },
+    { name: "temporal", file: join(logDir, "temporal.log") },
+  ];
+}
+
+/** One component by name, or undefined if not a known component. */
+export function componentByName(logDir: string, name: string): LogComponent | undefined {
+  return allComponents(logDir).find((component) => component.name === name);
+}
+
+export interface Sink {
+  write(chunk: string): unknown;
+}
+
+function format(line: string, name: string, prefix: boolean): string {
+  return prefix ? `[${name}] ${line}\n` : `${line}\n`;
+}
+
+/** Print the last `tail` lines of each component (grouped by component). */
+export function printTail(components: LogComponent[], tail: number, out: Sink): void {
+  const prefix = components.length > 1;
+  for (const component of components) {
+    for (const line of tailLines(component.file, tail)) {
+      out.write(format(line, component.name, prefix));
+    }
+  }
+}
+
+/**
+ * Follow appended lines from each component until the returned handle is
+ * stopped. New lines only (the caller prints the tail snapshot first).
+ */
+export function followAll(components: LogComponent[], out: Sink): FollowHandle {
+  const prefix = components.length > 1;
+  const handles = components.map((component) =>
+    followFile(component.file, (line) => out.write(format(line, component.name, prefix))),
+  );
+  return {
+    stop(): void {
+      for (const handle of handles) handle.stop();
+    },
+  };
+}

package/src/local/net/tcp.ts

@@ -0,0 +1,65 @@
+// TCP readiness probing — the "poll-don't-sleep" pattern shared by the Temporal
+// manager and the server gate.
+//
+// A single short-lived connection attempt tells us whether something is
+// listening; waitForTcp loops that probe until a deadline, failing fast (with a
+// log tail) if the process under watch exits first. This mirrors
+// `test/conformance/src/harness/temporal.ts` so the CLI and the harnesses share
+// one readiness model.
+
+import { connect } from "node:net";
+import { setTimeout as delay } from "node:timers/promises";
+
+/** Attempt a single TCP connection; resolves true if it connects in time. */
+export function tcpConnects(port: number, host = "127.0.0.1", timeoutMs = 200): Promise<boolean> {
+  return new Promise((resolveConnected) => {
+    const socket = connect({ port, host });
+    let settled = false;
+    const settle = (connected: boolean): void => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolveConnected(connected);
+    };
+    socket.setTimeout(timeoutMs, () => settle(false));
+    socket.once("connect", () => settle(true));
+    socket.once("error", () => settle(false));
+  });
+}
+
+export interface WaitForTcpOptions {
+  port: number;
+  host?: string;
+  /** Overall deadline. */
+  timeoutMs?: number;
+  /** Delay between probes. */
+  pollMs?: number;
+  /** If provided and it returns non-null, the watched process has exited — fail
+   * immediately rather than waiting out the deadline. */
+  getExit?: () => { code: number | null; signal: NodeJS.Signals | null } | null;
+  /** Diagnostic log tail, appended to the failure message. */
+  getLog?: () => string;
+  /** Human label for the thing being awaited (used in error text). */
+  label?: string;
+}
+
+/** Poll a TCP port until it accepts a connection or the deadline passes. */
+export async function waitForTcp(options: WaitForTcpOptions): Promise<void> {
+  const { port, host = "127.0.0.1", timeoutMs = 30_000, pollMs = 150, getExit, getLog, label = `port ${port}` } = options;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    const exit = getExit?.();
+    if (exit != null) {
+      throw new Error(`${label} exited before becoming ready (code=${exit.code}, signal=${exit.signal})${tail(getLog)}`);
+    }
+    if (await tcpConnects(port, host)) return;
+    await delay(pollMs);
+  }
+  throw new Error(`${label} did not become ready within ${timeoutMs}ms${tail(getLog)}`);
+}
+
+function tail(getLog?: () => string): string {
+  const log = getLog?.();
+  return log ? `\n--- log tail ---\n${log}` : "";
+}

package/src/local/paths.ts

@@ -0,0 +1,67 @@
+// Filesystem layout for the local stack, built on the CLI's config paths.
+//
+// The Go CLI deliberately splits state across two roots and the TS port
+// preserves it exactly:
+//   - the *data dir* (~/.stigmer/data) holds daemon/server/runner PID + state +
+//     logs + the runner workspace;
+//   - the *config dir* (~/.stigmer) holds config.yaml, the SQLite db, and the
+//     Temporal binary/data/lock.
+// Centralizing the asymmetry here keeps every call site honest. Each helper
+// takes the home dir (defaulting to os.homedir()) so tests can redirect the
+// whole tree to a temp directory.
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { configDir, dataDir } from "../config/paths.js";
+
+export { configDir, dataDir };
+
+/** Daemon/server/runner/temporal log directory (~/.stigmer/data/logs). */
+export function logDir(home: string = homedir()): string {
+  return join(dataDir(home), "logs");
+}
+
+/** Working directory the runner is launched in (~/.stigmer/data/workspace). */
+export function workspaceDir(home: string = homedir()): string {
+  return join(dataDir(home), "workspace");
+}
+
+/** Downloaded-binary directory for Temporal + stigmer-server (~/.stigmer/bin). */
+export function binDir(home: string = homedir()): string {
+  return join(configDir(home), "bin");
+}
+
+/**
+ * Root for on-demand-acquired npm runtimes (~/.stigmer/runtimes). Each release
+ * version installs into its own `<version>/` subtree so multiple CLI versions can
+ * coexist and a partial install never poisons another version's runner.
+ */
+export function runtimesDir(home: string = homedir()): string {
+  return join(configDir(home), "runtimes");
+}
+
+/** Temporal dev-server data directory (~/.stigmer/temporal-data). */
+export function temporalDataDir(home: string = homedir()): string {
+  return join(configDir(home), "temporal-data");
+}
+
+/** Temporal PID file (~/.stigmer/temporal.pid). Lives in the config dir, not
+ * the data dir — matching the Go CLI's Temporal manager layout. */
+export function temporalPidFile(home: string = homedir()): string {
+  return join(configDir(home), "temporal.pid");
+}
+
+/** Temporal single-instance lock file (~/.stigmer/temporal.lock). */
+export function temporalLockFile(home: string = homedir()): string {
+  return join(configDir(home), "temporal.lock");
+}
+
+/** Local SQLite database path (~/.stigmer/stigmer.db), the server's default. */
+export function databasePath(home: string = homedir()): string {
+  return join(configDir(home), "stigmer.db");
+}
+
+/** Server artifact storage path (~/.stigmer/storage), the server's default. */
+export function storagePath(home: string = homedir()): string {
+  return join(configDir(home), "storage");
+}

package/src/local/reset.test.ts

@@ -0,0 +1,53 @@
+import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { configPath } from "../config/paths.js";
+import { binDir, configDir, databasePath, dataDir, temporalDataDir } from "./paths.js";
+import { reset } from "./reset.js";
+
+let home: string;
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "stigmer-reset-"));
+});
+
+function seedState(): void {
+  mkdirSync(dataDir(home), { recursive: true });
+  mkdirSync(temporalDataDir(home), { recursive: true });
+  mkdirSync(binDir(home), { recursive: true });
+  writeFileSync(databasePath(home), "db");
+  writeFileSync(`${databasePath(home)}-wal`, "wal");
+  writeFileSync(join(dataDir(home), "runner.pid"), "1");
+  writeFileSync(configPath(home), "backend:\n  type: local\n");
+}
+
+const noopStop = vi.fn(async () => true);
+
+describe("reset", () => {
+  it("wipes state but preserves config by default", async () => {
+    seedState();
+    const result = await reset({}, home, noopStop);
+
+    expect(result.servicesStopped).toBe(true);
+    expect(existsSync(dataDir(home))).toBe(false);
+    expect(existsSync(databasePath(home))).toBe(false);
+    expect(existsSync(`${databasePath(home)}-wal`)).toBe(false);
+    expect(existsSync(temporalDataDir(home))).toBe(false);
+    expect(existsSync(binDir(home))).toBe(false);
+    // Config is preserved.
+    expect(existsSync(configPath(home))).toBe(true);
+    expect(result.removedPaths).toContain(dataDir(home));
+  });
+
+  it("removes config when includeConfig is set", async () => {
+    seedState();
+    await reset({ includeConfig: true }, home, noopStop);
+    expect(existsSync(configPath(home))).toBe(false);
+  });
+
+  it("reports services not stopped when nothing was running", async () => {
+    mkdirSync(configDir(home), { recursive: true });
+    const result = await reset({}, home, vi.fn(async () => false));
+    expect(result.servicesStopped).toBe(false);
+  });
+});

package/src/local/reset.ts

@@ -0,0 +1,90 @@
+// `stigmer reset` — stop the stack and wipe all persistent local state, so the
+// next `up` starts from a clean slate. Configuration (config.yaml) is preserved
+// by default so users do not lose API keys; `includeConfig` removes it too.
+//
+// The set of removed paths is a faithful port of the Go CLI's reset, spanning
+// both roots of the `~/.stigmer` layout (the SQLite db + Temporal state under
+// the config dir, and everything under the data dir).
+
+import { existsSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { configPath } from "../config/paths.js";
+import {
+  binDir,
+  configDir,
+  databasePath,
+  dataDir,
+  storagePath,
+  temporalDataDir,
+  temporalLockFile,
+  temporalPidFile,
+} from "./paths.js";
+import { down, isRunning } from "./daemon/launch.js";
+
+export interface ResetOptions {
+  /** Also remove config.yaml (the user must reconfigure on next start). */
+  includeConfig?: boolean;
+}
+
+export interface ResetResult {
+  servicesStopped: boolean;
+  removedPaths: string[];
+}
+
+/** Stop the stack if running. Returns whether anything was stopped. Injectable
+ * so reset's file-wiping can be tested without touching a real daemon. */
+export type StopFn = (home: string) => Promise<boolean>;
+
+const defaultStop: StopFn = async (home) => {
+  if (!(await isRunning(home))) return false;
+  await down(home);
+  return true;
+};
+
+/** Stop services (if running) and remove persistent state under `home`. */
+export async function reset(
+  options: ResetOptions = {},
+  home: string = homedir(),
+  stop: StopFn = defaultStop,
+): Promise<ResetResult> {
+  const servicesStopped = await stop(home);
+
+  const config = configDir(home);
+  const db = databasePath(home);
+
+  // Order: db (+ sidecars) first, then the data tree, then config-dir state.
+  const targets = [
+    db,
+    `${db}-wal`,
+    `${db}-shm`,
+    dataDir(home),
+    storagePath(home),
+    join(config, "sessions"),
+    join(config, "runtimes"),
+    temporalDataDir(home),
+    temporalPidFile(home),
+    temporalLockFile(home),
+    binDir(home),
+    join(config, "logs"),
+    join(config, "llm.pid"),
+  ];
+
+  const removedPaths: string[] = [];
+  for (const target of targets) {
+    if (existsSync(target)) {
+      rmSync(target, { recursive: true, force: true });
+      removedPaths.push(target);
+    }
+  }
+
+  if (options.includeConfig === true) {
+    const cfg = configPath(home);
+    if (existsSync(cfg)) {
+      rmSync(cfg, { force: true });
+      removedPaths.push(cfg);
+    }
+  }
+
+  return { servicesStopped, removedPaths };
+}

package/src/local/runtime/index.ts

@@ -0,0 +1,18 @@
+// Public surface of the runtime-acquisition seams (DD-002/003/007).
+
+export { MIN_NODE_MAJOR, resolveNode } from "./node.js";
+export {
+  type EnsureRunnerOptions,
+  type RunnerResolution,
+  acquireRunner,
+  ensureRunner,
+  resolveRunner,
+} from "./runner.js";
+export {
+  type EnsureServerOptions,
+  type ServerDownloadTarget,
+  downloadServerBinary,
+  ensureServerBinary,
+  resolveServerBinary,
+} from "./server.js";
+export { which } from "./which.js";