@zenithfoundry/slm-gate 1.2.1

package/dist/setup/local-models.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Are the local models slm-gate is configured to use actually there? Used by `slm-gate doctor`
+ * and by the MCP server's start-up check. It only reports, each problem with its exact fix; it never starts
+ * Ollama or downloads a model.
+ */
+import { CONFIG } from '../config.js';
+import { howToStartOllama } from './ollama-install.js';
+import { modelsFor } from './required-models.js';
+/** The models this process's settings use, and what each one is for. */
+export function requiredModels() {
+    return modelsFor(CONFIG);
+}
+/** Ollama lists `name:tag`; a setting without a tag means `:latest`. */
+function isPulled(name, pulled) {
+    return pulled.includes(name) || (!name.includes(':') && pulled.includes(`${name}:latest`));
+}
+/** Connection failures that mean nothing is listening, as opposed to a slow or wrong answer. */
+const UNREACHABLE = new Set(['ECONNREFUSED', 'ENOTFOUND', 'EHOSTUNREACH', 'ENETUNREACH', 'EAI_AGAIN', 'ECONNRESET']);
+/** fetch reports the underlying error as `cause`, or as an AggregateError when it tried IPv6 and IPv4. */
+function causeCodes(err) {
+    const cause = err?.cause;
+    if (cause instanceof AggregateError)
+        return cause.errors.map(one => one?.code ?? '');
+    const code = cause?.code;
+    return code ? [code] : [];
+}
+/**
+ * Asks Ollama what it has downloaded, and distinguishes the ways that can fail.
+ *
+ * @param params.timeoutMs How long to wait for an answer (default 3000)
+ */
+export async function probeOllama(params = {}) {
+    const timeoutMs = params.timeoutMs ?? 3000;
+    const host = CONFIG.OLLAMA_HOST;
+    let url;
+    try {
+        // Keep any path prefix in OLLAMA_HOST (a reverse proxy may serve Ollama under one).
+        url = new URL(`${host.replace(/\/+$/, '')}/api/tags`);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            throw new Error(`scheme ${url.protocol}`);
+    }
+    catch {
+        return { kind: 'bad-host', detail: host };
+    }
+    let res;
+    try {
+        res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    }
+    catch (err) {
+        // A timeout here can be self-inflicted: an AbortSignal armed before a busy stretch fires as soon as
+        // the event loop frees, sometimes before the request touches the network. Never read it as "down".
+        if (err instanceof Error && (err.name === 'TimeoutError' || err.name === 'AbortError')) {
+            return { kind: 'no-answer', detail: `no answer within ${timeoutMs} ms` };
+        }
+        const codes = causeCodes(err);
+        if (codes.some(code => UNREACHABLE.has(code)))
+            return { kind: 'unreachable', detail: codes.join(', ') };
+        return { kind: 'no-answer', detail: err instanceof Error ? err.message : String(err) };
+    }
+    if (!res.ok)
+        return { kind: 'not-ollama', detail: `answered ${res.status}` };
+    try {
+        const data = await res.json();
+        if (!Array.isArray(data.models))
+            return { kind: 'not-ollama', detail: 'answered without a model list' };
+        return { kind: 'ok', pulled: data.models.map(model => model.name) };
+    }
+    catch {
+        return { kind: 'not-ollama', detail: 'answered with something that is not JSON' };
+    }
+}
+/** The one problem to report when Ollama's model list could not be read. */
+function probeProblem(probe) {
+    const host = CONFIG.OLLAMA_HOST;
+    switch (probe.kind) {
+        case 'unreachable':
+            return {
+                message: `Ollama is not running at ${host}, so nothing is answered or shrunk locally (requests still reach the cloud).`,
+                fix: howToStartOllama(),
+            };
+        case 'no-answer':
+            return {
+                message: `Ollama did not answer at ${host} (${probe.detail}), so slm-gate could not check the local models. This does not mean Ollama is down.`,
+                fix: 'Usually nothing: it is often just busy while everything starts. If it keeps happening, run `slm-gate doctor`.',
+                transient: true,
+            };
+        case 'bad-host':
+            return {
+                message: `OLLAMA_HOST is "${probe.detail}", which is not an http address, so slm-gate never asked Ollama anything.`,
+                fix: 'Set OLLAMA_HOST to a full URL, e.g. http://localhost:11434. Ollama\'s own OLLAMA_HOST variable is a bare host:port, but slm-gate needs the http:// in front.',
+            };
+        case 'not-ollama':
+            return {
+                message: `Something is listening at ${host} but it is not Ollama (${probe.detail}).`,
+                fix: 'Point OLLAMA_HOST at the address Ollama is really on, or stop the other program. `slm-gate doctor` names what holds the port.',
+            };
+    }
+}
+/**
+ * @param params.timeoutMs How long to wait for Ollama (default 3000)
+ * @param params.gateModels The models the running model gate uses (from its health answer). The gate reads
+ *   only slm-gate's .env, which can name other models than the MCP env block this process was started with.
+ *   A process whose own SLM_PROVIDER is not ollama checks nothing (its OLLAMA_HOST then points elsewhere);
+ *   sessions on Ollama and `slm-gate doctor`, which reads the same .env as the gate, still check them.
+ * @returns The problems found (empty when all is well) and the models Ollama has
+ */
+export async function checkLocalModels(params = {}) {
+    if (CONFIG.SLM_PROVIDER !== 'ollama')
+        return { problems: [], pulled: [] };
+    const probe = await probeOllama({ timeoutMs: params.timeoutMs });
+    if (probe.kind !== 'ok')
+        return { problems: [probeProblem(probe)], pulled: [] };
+    const pulled = probe.pulled;
+    const gateModels = (params.gateModels ?? []).map(model => ({ ...model, setting: `${model.setting} in slm-gate's .env` }));
+    const problems = [...requiredModels(), ...gateModels]
+        .filter((model, index, all) => all.findIndex(other => other.name === model.name) === index) // two settings, one model
+        .filter(model => !isPulled(model.name, pulled))
+        .map(model => ({
+        message: `The local model ${model.name} (${model.setting}, used for ${model.purpose}) is not downloaded.`,
+        fix: `ollama pull ${model.name}`,
+    }));
+    return { problems, pulled };
+}

package/dist/setup/model-gate.js

@@ -0,0 +1,220 @@
+/**
+ * @fileoverview Keeps the model gate (the HTTP server on LLM_GATE_PORT that coding tools send every model
+ * request to) running without anyone starting it by hand. slm-gate's MCP server — which every coding tool
+ * starts on its own — probes it at start-up and every minute, and launches it in the background when
+ * nothing is listening. Several MCP servers run at once (one per IDE window / CLI session); they agree
+ * through two marker files: a shared launch cooldown, and a "stopped by you" marker from `slm-gate stop`.
+ */
+import { execFileSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CONFIG, CONFIG_ENV_KEYS } from '../config.js';
+import { claimWindow } from './claim.js';
+/** Answered by the gate itself, never forwarded (src/llm-gate/server.ts). */
+export const HEALTH_PATH = '/slm-gate/health';
+export const GATE_LOG_FILE = path.join(CONFIG.OUTPUT_DIR, 'llm-gate.log');
+const STOPPED_MARKER = path.join(CONFIG.OUTPUT_DIR, '.gate-stopped');
+const LAUNCH_MARKER = path.join(CONFIG.OUTPUT_DIR, '.gate-launch');
+const LAUNCH_COOLDOWN_MS = 60_000;
+/**
+ * The command for an slm-gate CLI action on this install, e.g. `node /path/dist/cli.js restart`. Messages
+ * print this rather than `slm-gate restart`, which only works once the command has been linked onto the PATH.
+ */
+export function cliCommand(action) {
+    const cli = path.join(CONFIG.ROOT_DIR, 'dist', 'cli.js');
+    return `node ${cli.includes(' ') ? JSON.stringify(cli) : cli} ${action}`;
+}
+/** A newer slm-gate build is installed than the one the running gate was started from. */
+function isStale(health) {
+    try {
+        return String(Math.round(fs.statSync(health.entry).mtimeMs)) !== health.build;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Asks whatever listens on the port who it is. Nothing listening is known at once (connection refused);
+ * anything that is not the gate — another program, or one that does not answer in time — is 'other'.
+ */
+export function probeGate(params = {}) {
+    const port = params.port ?? CONFIG.MODEL_GATE_PORT;
+    return new Promise(resolve => {
+        const req = http.get({ host: '127.0.0.1', port, path: HEALTH_PATH, timeout: params.timeoutMs ?? 1000 }, res => {
+            const chunks = [];
+            res.on('data', chunk => chunks.push(chunk));
+            res.on('end', () => {
+                try {
+                    const health = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                    resolve(res.statusCode === 200 && health.service === 'slm-gate' ? { kind: 'slm-gate', health, stale: isStale(health) } : { kind: 'other' });
+                }
+                catch {
+                    resolve({ kind: 'other' });
+                }
+            });
+            res.on('error', () => resolve({ kind: 'other' }));
+        });
+        req.on('timeout', () => req.destroy(new Error('timeout')));
+        req.on('error', err => resolve(err.code === 'ECONNREFUSED' ? { kind: 'nothing' } : { kind: 'other' }));
+    });
+}
+/**
+ * Minutes since the epoch at which this machine booted, computed from the clock: a new value means a reboot,
+ * but a clock change shifts it too. Used only where the OS gives no boot ID.
+ */
+function bootMinute() {
+    return Math.round((Date.now() - os.uptime() * 1000) / 60_000);
+}
+let cachedBootId;
+/**
+ * The ID the OS gives this boot (macOS kern.bootsessionuuid, Linux boot_id); a clock change cannot alter it.
+ * Null on other systems, or when it cannot be read right now (not remembered, so the next call retries).
+ */
+function osBootId() {
+    if (cachedBootId)
+        return cachedBootId;
+    try {
+        const id = process.platform === 'darwin'
+            ? execFileSync('sysctl', ['-n', 'kern.bootsessionuuid'], { encoding: 'utf8', timeout: 2000 }).trim()
+            : process.platform === 'linux'
+                ? fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim()
+                : '';
+        if (id)
+            cachedBootId = id;
+        return id || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** `slm-gate stop` was run since the last boot, and no `slm-gate start` since. */
+export function isStoppedByUser() {
+    let marker;
+    try {
+        marker = fs.readFileSync(STOPPED_MARKER, 'utf8').trim();
+    }
+    catch {
+        return false;
+    }
+    // A number is a boot minute (no OS boot ID, or written by an older slm-gate): allow a minute of drift.
+    if (/^\d+$/.test(marker))
+        return Math.abs(Number(marker) - bootMinute()) <= 1;
+    // A boot ID. If this boot's ID cannot be read right now, keep the stop rather than end it by mistake.
+    const current = osBootId();
+    return current === null || marker === current;
+}
+function setStoppedByUser(stopped) {
+    if (stopped) {
+        fs.mkdirSync(path.dirname(STOPPED_MARKER), { recursive: true });
+        fs.writeFileSync(STOPPED_MARKER, osBootId() ?? String(bootMinute()));
+    }
+    else {
+        fs.rmSync(STOPPED_MARKER, { force: true });
+    }
+}
+/** The gate's entry file in this install, next to this module (built `.js` or source `.ts`). */
+function gateEntry() {
+    const here = fileURLToPath(import.meta.url);
+    return path.join(path.dirname(here), '..', 'llm-gate', `index${path.extname(here)}`);
+}
+/**
+ * The environment the gate is launched with: this process's, minus every variable slm-gate's config
+ * reads, so the one shared gate takes its settings only from slm-gate's own .env — never from the MCP env
+ * block of whichever coding tool started it first.
+ */
+export function gateEnvironment(env = process.env) {
+    return Object.fromEntries(Object.entries(env).filter(([name]) => !CONFIG_ENV_KEYS.includes(name)));
+}
+/**
+ * Starts the gate in the background and returns at once, unless another session already launched it this
+ * minute (so a crash-looping gate is relaunched at most once a minute, however many windows are open).
+ *
+ * @param params.port Port to start it on (default LLM_GATE_PORT from slm-gate's .env)
+ * @param params.envOverrides Extra variables after the clean-up (tests use it for a throwaway ledger)
+ * @param params.execArgv Node flags for the child (default this process's, e.g. `--import tsx` from source)
+ * @param params.ignoreCooldown For `slm-gate start` / `restart`, which the person asked for explicitly
+ */
+export function launchModelGate(params = {}) {
+    if (!params.ignoreCooldown && !claimWindow({ file: LAUNCH_MARKER, windowMs: LAUNCH_COOLDOWN_MS })) {
+        return { launched: false, reason: 'another slm-gate session already launched it this minute' };
+    }
+    fs.mkdirSync(path.dirname(GATE_LOG_FILE), { recursive: true });
+    const log = fs.openSync(GATE_LOG_FILE, 'a');
+    try {
+        const child = spawn(process.execPath, [...(params.execArgv ?? process.execArgv), gateEntry()], {
+            cwd: CONFIG.ROOT_DIR,
+            env: { ...gateEnvironment(), LLM_GATE_PORT: String(params.port ?? CONFIG.MODEL_GATE_PORT), ...params.envOverrides },
+            detached: true,
+            stdio: ['ignore', log, log],
+        });
+        child.on('error', err => fs.appendFileSync(GATE_LOG_FILE, `[slm-gate] could not start the model gate: ${err.message}\n`));
+        child.unref();
+        return { launched: true };
+    }
+    finally {
+        fs.closeSync(log);
+    }
+}
+/** Waits until the gate answers its health check; null when it does not within the time. */
+export async function waitForModelGate(params = {}) {
+    const deadline = Date.now() + (params.timeoutMs ?? 10_000);
+    while (Date.now() < deadline) {
+        const probe = await probeGate({ port: params.port, timeoutMs: 500 });
+        if (probe.kind === 'slm-gate')
+            return probe.health;
+        await new Promise(resolve => setTimeout(resolve, 250));
+    }
+    return null;
+}
+/** The last lines of the gate's log, for a failure message. */
+export function gateLogTail(lines = 5) {
+    try {
+        return fs.readFileSync(GATE_LOG_FILE, 'utf8').trim().split('\n').slice(-lines).join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+/** Which program listens on the port (macOS/Linux, via lsof), e.g. "node (pid 123)"; null when unknown. */
+export function portOwner(port = CONFIG.MODEL_GATE_PORT) {
+    try {
+        const out = execFileSync('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-Fpc'], { encoding: 'utf8', timeout: 2000 });
+        const pid = /^p(\d+)/m.exec(out)?.[1];
+        const command = /^c(.+)$/m.exec(out)?.[1];
+        return pid ? `${command ?? 'a program'} (pid ${pid})` : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** `slm-gate start`: clears "stopped by you" and launches the gate unless it already runs. */
+export async function startModelGate(params = {}) {
+    setStoppedByUser(false);
+    const probe = await probeGate({ port: params.port });
+    if (probe.kind !== 'nothing')
+        return probe;
+    launchModelGate({ port: params.port, ignoreCooldown: true });
+    const health = await waitForModelGate({ port: params.port });
+    return health ? { kind: 'slm-gate', health, stale: false } : { kind: 'nothing' };
+}
+/** `slm-gate stop`: stops the gate and keeps it stopped until `slm-gate start`/`restart` or a reboot. */
+export async function stopModelGate(params = {}) {
+    setStoppedByUser(true);
+    const probe = await probeGate({ port: params.port });
+    if (probe.kind !== 'slm-gate')
+        return null;
+    try {
+        process.kill(probe.health.pid, 'SIGTERM');
+    }
+    catch {
+        // Already gone.
+    }
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline && (await probeGate({ port: params.port, timeoutMs: 300 })).kind === 'slm-gate') {
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    return probe.health;
+}

package/dist/setup/notify.js

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview Desktop notifications for slm-gate problems (macOS; Linux when notify-send exists; nothing
+ * on other systems — the log line and the notice to the AI still carry the message). Each message is shown
+ * at most once per 10 minutes across every running slm-gate process, so ten IDE windows opening together
+ * give one pop-up, not ten.
+ */
+import { spawn } from 'node:child_process';
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { CONFIG } from '../config.js';
+import { claimWindow } from './claim.js';
+const REPEAT_AFTER_MS = 10 * 60 * 1000;
+/** True for exactly one caller per problem per 10 minutes, across processes. */
+export function claimNotice(params) {
+    const dir = params.dir ?? path.join(CONFIG.OUTPUT_DIR, '.notices');
+    const file = path.join(dir, crypto.createHash('sha256').update(params.key).digest('hex').slice(0, 16));
+    return claimWindow({ file, windowMs: REPEAT_AFTER_MS, now: params.now });
+}
+/**
+ * Shows a desktop notification, unless the same problem was already shown in this 10-minute window.
+ *
+ * @param params.key A stable name for the problem (e.g. 'gate-launch-failed'), so two sessions describing
+ *   the same failure in slightly different words still show one pop-up
+ */
+export function notifyUser(params) {
+    const title = params.title ?? 'slm-gate';
+    let command = null;
+    if (process.platform === 'darwin') {
+        // JSON string literals are valid AppleScript string literals (same quote and backslash escapes).
+        command = ['osascript', ['-e', `display notification ${JSON.stringify(params.message)} with title ${JSON.stringify(title)}`]];
+    }
+    else if (process.platform === 'linux') {
+        command = ['notify-send', [title, params.message]];
+    }
+    if (!command || !claimNotice({ key: params.key }))
+        return;
+    try {
+        const child = spawn(command[0], command[1], { stdio: 'ignore', detached: true });
+        child.on('error', () => { }); // e.g. notify-send not installed: the log line still has the message
+        child.unref();
+    }
+    catch {
+        // Same: never let a notification problem affect slm-gate itself.
+    }
+}

package/dist/setup/ollama-install.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview How Ollama is installed on this machine, so that "start Ollama" can name the command
+ * that actually works here. Telling somebody to run `ollama serve` when Homebrew or systemd already
+ * keeps Ollama running gets them "address already in use", which reads like a second fault and sends
+ * them looking for one. This only looks at the filesystem: it never runs Ollama and never starts it.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/** Homebrew starts Ollama through this LaunchAgent, and then owns the port. */
+const BREW_AGENT = 'Library/LaunchAgents/homebrew.mxcl.ollama.plist';
+const MACOS_APP = '/Applications/Ollama.app';
+const SYSTEMD_UNITS = [
+    '/etc/systemd/system/ollama.service',
+    '/usr/lib/systemd/system/ollama.service',
+    '/lib/systemd/system/ollama.service',
+];
+const INSTALL = 'Install Ollama from https://ollama.com/download, then start it.';
+/**
+ * The sentence telling somebody how to start Ollama on this machine.
+ *
+ * Every input is injectable so this stays a pure function of the machine's state, which is also how
+ * the tests cover installs the test machine does not have.
+ *
+ * @param params.platform Defaults to the running platform
+ * @param params.home Defaults to the current user's home directory
+ * @param params.pathDirs Directories to look for the `ollama` binary in; defaults to PATH
+ * @param params.exists Defaults to checking the real filesystem
+ * @returns A sentence naming the command to run, ready to use as a problem's fix
+ */
+export function howToStartOllama(params = {}) {
+    const platform = params.platform ?? process.platform;
+    const exists = params.exists ?? fs.existsSync;
+    const home = params.home ?? os.homedir();
+    const pathDirs = params.pathDirs ?? (process.env.PATH ?? '').split(path.delimiter);
+    const onPath = pathDirs.some(dir => dir !== '' && exists(path.join(dir, 'ollama')));
+    const serve = 'Run `ollama serve`.';
+    if (platform === 'darwin') {
+        if (exists(path.join(home, BREW_AGENT))) {
+            return 'Run `brew services start ollama` (Homebrew keeps Ollama running on this machine, so `ollama serve` would only report that the address is already in use).';
+        }
+        if (exists(MACOS_APP))
+            return 'Open the Ollama app.';
+        return onPath ? serve : INSTALL;
+    }
+    if (platform === 'linux') {
+        if (SYSTEMD_UNITS.some(exists)) {
+            return 'Run `sudo systemctl start ollama` (systemd keeps Ollama running on this machine, so `ollama serve` would only report that the address is already in use).';
+        }
+        return onPath ? serve : INSTALL;
+    }
+    return onPath ? serve : INSTALL;
+}

package/dist/setup/parent-watch.js

@@ -0,0 +1,84 @@
+/**
+ * @fileoverview Stops this MCP server when the coding tool that started it goes away.
+ *
+ * A stdio MCP server is owned by the editor that spawned it, but nothing in the operating system
+ * enforces that: when the editor is force-quit or crashes, the server it started keeps running, is
+ * reparented to init, and stays up until the machine reboots. Those orphans are not idle — each one
+ * goes on probing Ollama and showing desktop notifications, from whatever build it was started with,
+ * so a fault fixed weeks ago can still pop up on screen.
+ *
+ * Closed input is the quick, ordinary signal, but it only arrives once something is reading stdin, so
+ * it is no help if start-up hangs before the transport attaches. Losing our parent is the signal that
+ * always arrives, whatever went wrong and whichever transport is in use.
+ */
+import { execFileSync } from 'node:child_process';
+/** A process line from `ps`: pid, parent pid, then the command. */
+const PS_LINE = /^\s*(\d+)\s+(\d+)\s+(.*)$/;
+/** Our MCP server's entry point as a whole argument, built or from source. */
+const MCP_ENTRY = /mcp-gate[/\\]index\.[mc]?[jt]s$/;
+/**
+ * What a JavaScript process is started by. The command has to be one of these AND the entry has to be
+ * one of its arguments, because a command line is text: a shell running a script that merely mentions
+ * the path, or a `grep` for it, otherwise counts as a server and gets offered up to be killed.
+ */
+const RUNTIME = /(^|[/\\])(node|npm|npx|pnpm|yarn|tsx|bun|deno)$/;
+/** True when this command line is a JavaScript runtime actually running our MCP server. */
+function isOurServer(command) {
+    const [runtime, ...args] = command.trim().split(/\s+/);
+    return RUNTIME.test(runtime) && args.some(arg => MCP_ENTRY.test(arg));
+}
+/**
+ * slm-gate MCP servers still running with nothing to own them, for `slm-gate doctor` to name.
+ *
+ * Builds from before this file existed have no way to notice their coding tool has gone, so they stay
+ * up until the machine reboots. Only reports them: which processes to end is the user's call, and a
+ * server belonging to an editor this check cannot see would be the wrong thing to kill.
+ *
+ * @param params.ps Reads the process table; defaults to running `ps`
+ * @param params.self This process, never reported; defaults to the real pid
+ * @returns The pids, empty when there are none or the process table cannot be read
+ */
+export function findStrandedServers(params = {}) {
+    const self = params.self ?? process.pid;
+    let table;
+    try {
+        table = params.ps ? params.ps() : execFileSync('ps', ['-Ao', 'pid=,ppid=,command='], { encoding: 'utf8', timeout: 2000 });
+    }
+    catch {
+        return []; // no ps, or not allowed to run it: this is a convenience, never a failure
+    }
+    return table
+        .split('\n')
+        .map(line => PS_LINE.exec(line))
+        .filter((parts) => parts !== null)
+        // Parent 1 means the process that started it is gone and init has taken it over.
+        .filter(parts => parts[2] === '1' && Number(parts[1]) !== self && isOurServer(parts[3]))
+        .map(parts => Number(parts[1]));
+}
+/**
+ * Calls `onGone` when the process that started this one has exited.
+ *
+ * Reparenting is the test: every process keeps its parent until that parent dies, at which point the
+ * operating system hands it to init. A process that already belongs to init was started by a service
+ * manager and has no parent to lose, so it is left alone.
+ *
+ * @param params.everyMs How often to look (default 30 s; this is one syscall)
+ * @param params.ppid Reads the current parent process id; defaults to the real one
+ * @param params.onGone Defaults to asking ourselves to shut down the same way a `slm-gate stop` would
+ * @returns Stops watching (tests, and shutdown paths that no longer need it)
+ */
+export function exitWithParent(params = {}) {
+    const readPpid = params.ppid ?? (() => process.ppid);
+    const startedUnder = readPpid();
+    if (startedUnder <= 1)
+        return () => { }; // already owned by init: nothing to watch for
+    const onGone = params.onGone ?? (() => process.kill(process.pid, 'SIGTERM'));
+    const timer = setInterval(() => {
+        if (readPpid() === startedUnder)
+            return;
+        clearInterval(timer);
+        onGone();
+    }, params.everyMs ?? 30_000);
+    timer.unref(); // never keep the process alive just to watch for its parent
+    return () => clearInterval(timer);
+}

package/dist/setup/required-models.js

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Which local models a set of settings needs, and what each one is for. One rule for the
+ * start-up check (the running settings, src/setup/local-models.ts) and `slm-gate init` (the settings file
+ * it writes, src/setup/init.ts). No side effects, so init can use it without loading the configuration.
+ */
+/**
+ * @param settings The model settings, and the two features that use the embedding model
+ * @returns The models to have in Ollama: both SLM models, plus EMBED_MODEL when either feature is on
+ */
+export function modelsFor(settings) {
+    const models = [
+        { name: settings.SLM_GATE_MODEL, setting: 'SLM_GATE_MODEL', purpose: 'sorting requests and shrinking tool output' },
+        { name: settings.SLM_BRAIN_MODEL, setting: 'SLM_BRAIN_MODEL', purpose: 'answering first messages locally' },
+    ];
+    if (settings.SEMCACHE || settings.DISTILL_ADAPTIVE) {
+        const uses = [settings.SEMCACHE && 'the semantic cache', settings.DISTILL_ADAPTIVE && 'adaptive tool-output shrinking'].filter(Boolean);
+        models.push({ name: settings.EMBED_MODEL, setting: 'EMBED_MODEL', purpose: uses.join(' and ') });
+    }
+    return models;
+}