antechamber 1.0.40 → 2.0.1

package/dist/catalog.js

@@ -1,7 +1,7 @@
 /**
  * Model/provider catalog: obtained from a throwaway `pi --mode rpc` process
  * (`get_available_models` + `get_state`), translated into OpenCode v2
- * Provider/Model shapes, cached for the adapter lifetime.
+ * Provider/Model shapes, refreshed from live agents or bounded cold reads.
  */
 import { PiRpcClient } from "./pi-rpc.js";
 import { thinkingVariants } from "./thinking-levels.js";
@@ -44,24 +44,95 @@ function toOCModel(m) {
         ...(variants !== undefined ? { variants } : {}),
     };
 }
-export async function loadCatalog(directory) {
-    const pi = new PiRpcClient({ cwd: directory, args: ["--no-session"] });
+function inventory(res) {
+    const providers = new Map();
+    if (res.success && res.data) {
+        for (const m of res.data.models) {
+            let p = providers.get(m.provider);
+            if (!p) {
+                p = { id: m.provider, name: m.provider, source: "config", env: [], options: {}, models: {} };
+                providers.set(m.provider, p);
+            }
+            p.models[m.id] = toOCModel(m);
+        }
+    }
+    return providers;
+}
+/**
+ * Apply the default to the inventory: list it even if get_available_models omitted it (the client drops a
+ * selection it cannot find), and put it first, because OpenChamber's picker defaults to the first listed
+ * provider/model. `active` is a model from a fresh agent's get_state, or the previous snapshot's default.
+ */
+function withDefault(providers, active, thinkingLevel) {
+    const defaults = {};
+    if (active !== null) {
+        defaults[active.providerID] = active.modelID;
+        let p = providers.get(active.providerID);
+        if (p === undefined) {
+            p = { id: active.providerID, name: active.providerID, source: "config", env: [], options: {}, models: {} };
+            providers.set(active.providerID, p);
+        }
+        if (p.models[active.modelID] === undefined)
+            p.models[active.modelID] = active.model;
+    }
+    const sorted = [...providers.values()].sort((a, b) => {
+        const aDef = defaults[a.id] !== undefined ? 0 : 1;
+        const bDef = defaults[b.id] !== undefined ? 0 : 1;
+        return aDef - bDef;
+    });
+    for (const p of sorted) {
+        const def = defaults[p.id];
+        if (!def)
+            continue;
+        const entries = Object.entries(p.models).sort(([a], [b]) => (a === def ? -1 : b === def ? 1 : 0));
+        p.models = Object.fromEntries(entries);
+    }
+    // exactOptionalPropertyTypes: omit `default` rather than set it undefined.
+    if (active === null)
+        return { providers: sorted, defaults };
+    const resolvedDefault = { providerID: active.providerID, modelID: active.modelID };
+    // Only a level the catalog offers as a variant is selectable in the picker.
+    const offered = sorted.find((p) => p.id === active.providerID)?.models[active.modelID]?.variants;
+    return thinkingLevel !== undefined && offered?.[thinkingLevel] !== undefined
+        ? { providers: sorted, defaults, default: resolvedDefault, defaultThinkingLevel: thinkingLevel }
+        : { providers: sorted, defaults, default: resolvedDefault };
+}
+/**
+ * The configured default plus the provider/model inventory in a fixed order, so a reordering alone is not
+ * reported as a catalog change but a new default is.
+ */
+export function catalogFingerprint(catalog) {
+    return JSON.stringify([
+        catalog.default ?? null,
+        catalog.defaultThinkingLevel ?? null,
+        [...catalog.providers]
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .map((p) => [
+            p.id,
+            Object.keys(p.models)
+                .sort()
+                .map((id) => [id, p.models[id]]),
+        ]),
+    ]);
+}
+/**
+ * `configured` is the previous snapshot when `client` is a live session's agent: that agent's `get_state.model`
+ * is the session's own selection, not the configured default, so only the model inventory is re-read and the
+ * snapshot's default is kept. Only a fresh `--no-session` agent defines the default.
+ */
+export async function loadCatalog(directory, client, configured) {
+    const pi = client ?? new PiRpcClient({ cwd: directory, args: ["--no-session"] });
     try {
+        if (configured !== undefined) {
+            const modelsRes = await pi.command({ type: "get_available_models" });
+            const def = configured.default;
+            const model = def && configured.providers.find((p) => p.id === def.providerID)?.models[def.modelID];
+            return withDefault(inventory(modelsRes), def && model ? { ...def, model } : null, configured.defaultThinkingLevel);
+        }
         const [modelsRes, firstState] = await Promise.all([
             pi.command({ type: "get_available_models" }),
             pi.command({ type: "get_state" }),
         ]);
-        const providers = new Map();
-        if (modelsRes.success && modelsRes.data) {
-            for (const m of modelsRes.data.models) {
-                let p = providers.get(m.provider);
-                if (!p) {
-                    p = { id: m.provider, name: m.provider, source: "config", env: [], options: {}, models: {} };
-                    providers.set(m.provider, p);
-                }
-                p.models[m.id] = toOCModel(m);
-            }
-        }
         // get_state occasionally races pi's own startup. One retry beats resolving
         // no active model, which is precisely what leaves the UI picker guessing.
         let active = firstState.success ? (firstState.data?.model ?? null) : null;
@@ -74,45 +145,10 @@ export async function loadCatalog(directory) {
         if (active === null) {
             console.error("[catalog] warning: pi reported no active model — /api/model/default will be null and the UI picker falls back to its own default");
         }
-        const defaults = {};
-        let resolvedDefault;
-        if (active !== null) {
-            defaults[active.provider] = active.id;
-            resolvedDefault = { providerID: active.provider, modelID: active.id };
-            // The client drops any selection it cannot find in this catalog and picks
-            // something else instead, so a model get_available_models omitted still
-            // has to be listed here — otherwise the active model is unselectable.
-            let p = providers.get(active.provider);
-            if (p === undefined) {
-                p = { id: active.provider, name: active.provider, source: "config", env: [], options: {}, models: {} };
-                providers.set(active.provider, p);
-            }
-            if (p.models[active.id] === undefined)
-                p.models[active.id] = toOCModel(active);
-        }
-        // OpenChamber's picker defaults to the first listed provider/model — put pi's active config there.
-        const sorted = [...providers.values()].sort((a, b) => {
-            const aDef = defaults[a.id] !== undefined ? 0 : 1;
-            const bDef = defaults[b.id] !== undefined ? 0 : 1;
-            return aDef - bDef;
-        });
-        for (const p of sorted) {
-            const def = defaults[p.id];
-            if (!def)
-                continue;
-            const entries = Object.entries(p.models).sort(([a], [b]) => (a === def ? -1 : b === def ? 1 : 0));
-            p.models = Object.fromEntries(entries);
-        }
-        // exactOptionalPropertyTypes: omit `default` rather than set it undefined.
-        if (resolvedDefault === undefined)
-            return { providers: sorted, defaults };
-        // Only a level the catalog offers as a variant is selectable in the picker.
-        const offered = sorted.find((p) => p.id === resolvedDefault.providerID)?.models[resolvedDefault.modelID]?.variants;
-        return thinkingLevel !== undefined && offered?.[thinkingLevel] !== undefined
-            ? { providers: sorted, defaults, default: resolvedDefault, defaultThinkingLevel: thinkingLevel }
-            : { providers: sorted, defaults, default: resolvedDefault };
+        return withDefault(inventory(modelsRes), active === null ? null : { providerID: active.provider, modelID: active.id, model: toOCModel(active) }, thinkingLevel);
     }
     finally {
-        await pi.dispose();
+        if (client === undefined)
+            await pi.dispose();
     }
 }

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 export {};

package/dist/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 /** CLI parsing and dispatch. Server code is loaded only for serve/default mode. */
 import { parseArgs } from "node:util";
 import { ADAPTER_VERSION, OPENCODE_API_VERSION } from "./version.js";

package/dist/commands/context.d.ts

@@ -7,7 +7,10 @@ export interface CommandContext {
     readonly exec: (binary: string, args: readonly string[]) => string;
     readonly now: () => Date;
     readonly platform: NodeJS.Platform;
-    readonly nodeVersion: string;
+    /** Bun's version, or undefined when this process is not running on Bun. */
+    readonly bunVersion: string | undefined;
+    /** The running Bun executable, or undefined when this process is not running on Bun. */
+    readonly bunBinary: string | undefined;
     readonly output: (line: string) => void;
     readonly cliPath: string;
     readonly launcherPath: string;
@@ -24,6 +27,6 @@ export declare function readSettings(path: string, ctx: CommandContext): Record<
 export declare function shellQuote(value: string): string;
 /** OpenChamber launcher written by `setup --auto-update`, kept beside the session registry. */
 export declare function autoUpdateLauncherPath(ctx: CommandContext): string;
-export declare function autoUpdateLauncherText(binary: string): string;
+export declare function autoUpdateLauncherText(binary: string, bunBinary?: string): string;
 export declare function autoUpdateLauncherTarget(text: string): string | undefined;
 export declare function isPackageBinary(binary: string, ctx: CommandContext): boolean;

package/dist/commands/context.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import { homedir } from "node:os";
-import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { defaultStateDir, envSetting } from "../config.js";
 export function createContext(overrides = {}) {
@@ -29,7 +29,8 @@ export function createContext(overrides = {}) {
         },
         now: () => new Date(),
         platform: process.platform,
-        nodeVersion: process.versions.node,
+        bunVersion: process.versions.bun,
+        bunBinary: process.versions.bun === undefined ? undefined : process.execPath,
         output: console.log,
         cliPath: packageCliPath,
         launcherPath: fileURLToPath(new URL("../../bin/opencode-antechamber", import.meta.url)),
@@ -85,13 +86,16 @@ export function shellQuote(value) {
 export function autoUpdateLauncherPath(ctx) {
     return resolve(ctx.cwd, envSetting("STATE_DIR", ctx.env) ?? defaultStateDir(ctx.home, ctx.fs.existsSync), "opencode-antechamber");
 }
-export function autoUpdateLauncherText(binary) {
+export function autoUpdateLauncherText(binary, bunBinary) {
+    const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
     return [
         "#!/bin/sh",
         "# Written by `antechamber setup --auto-update`; rerun `antechamber setup` without it to stop auto-updates.",
         "ANTECHAMBER_AUTO_UPDATE=1",
         "export ANTECHAMBER_AUTO_UPDATE",
-        `exec '${binary.replaceAll("'", "'\\''")}' "$@"`,
+        // The CLI's `env bun` shebang must find Bun even when OpenChamber's PATH lacks its directory.
+        ...(bunBinary === undefined ? [] : [`PATH=${quote(dirname(bunBinary))}:"$PATH"`, "export PATH"]),
+        `exec ${quote(binary)} "$@"`,
         "",
     ].join("\n");
 }

package/dist/commands/doctor.js

@@ -1,7 +1,7 @@
 import { dirname, resolve } from "node:path";
 import { piAgentDir } from "../agent-dir.js";
 import { detectAgentName } from "../agent-name.js";
-import { agentBinary, defaultStateDir, envSetting, isPlainPi } from "../config.js";
+import { agentBinary, defaultStateDir, envSetting, isPlainPi, managedByExtension } from "../config.js";
 import { findPidfdPython } from "../pidfd.js";
 import { readRunningServers } from "../running-servers.js";
 import { isNewerVersion } from "../self-update.js";
@@ -23,7 +23,8 @@ export function doctor(options = {}, ctx = createContext(), latestVersion) {
     const add = (name, status, message) => {
         checks.push({ name, status, message });
     };
-    add("node", Number(ctx.nodeVersion.split(".")[0]) >= 22 ? "PASS" : "FAIL", `Node ${ctx.nodeVersion}; requires >=22`);
+    const [bunMajor = 0, bunMinor = 0] = (ctx.bunVersion ?? "").split(".").map(Number);
+    add("bun", bunMajor > 1 || (bunMajor === 1 && bunMinor >= 4) ? "PASS" : "FAIL", ctx.bunVersion === undefined ? "not running on Bun; requires Bun >=1.4" : `Bun ${ctx.bunVersion}; requires >=1.4`);
     const backend = agentBinary(ctx.env);
     const binary = resolveBinary(backend, ctx);
     if (binary === undefined)
@@ -59,7 +60,7 @@ export function doctor(options = {}, ctx = createContext(), latestVersion) {
     if (latestVersion instanceof Error)
         add("version", "INFO", `${ADAPTER_VERSION}; latest unknown (${latestVersion.message})`);
     else if (latest !== undefined && isNewerVersion(latest, ADAPTER_VERSION))
-        add("version", "WARN", `${ADAPTER_VERSION} installed; ${latest} is released: run antechamber upgrade`);
+        add("version", "WARN", `${ADAPTER_VERSION} installed; ${latest} is released: ${managedByExtension(ctx.env) ? "update the antechamber extension in OpenChamber" : "run antechamber upgrade"}`);
     else
         add("version", "PASS", ADAPTER_VERSION);
     // A released fix is live only once OpenChamber relaunches the adapter.

package/dist/commands/setup.js

@@ -12,23 +12,12 @@ function writeAtomically(path, content, ctx) {
     ctx.fs.writeFileSync(temporary, content, { mode: 0o600, flag: "wx" });
     ctx.fs.renameSync(temporary, path);
 }
-/** The bundled OmO Graph extension folder, when this installation has its built files. */
-function omoGraphExtensionDir(ctx) {
-    const dir = resolve(dirname(ctx.cliPath), "..", "extensions", "omo-dag");
-    const built = ["package.json", "panel/main.js", "service/main.js"].every((file) => ctx.fs.existsSync(join(dir, file)));
+/** The bundled antechamber OpenChamber extension folder, when this installation has its built files. */
+function antechamberExtensionDir(ctx) {
+    const dir = resolve(dirname(ctx.cliPath), "..", "extensions", "antechamber");
+    const built = ["package.json", "panel/main.js", "status/main.js", "service/main.js", "runtime/launcher.js"].every((file) => ctx.fs.existsSync(join(dir, file)));
     return built ? dir : undefined;
 }
-/** The bundled OmO Work status-section extension folder, when this installation has its built files. */
-function omoWorkExtensionDir(ctx) {
-    const dir = resolve(dirname(ctx.cliPath), "..", "extensions", "omo-work");
-    const built = ["package.json", "status/main.js", "service/main.js"].every((file) => ctx.fs.existsSync(join(dir, file)));
-    return built ? dir : undefined;
-}
-/** The bundled OmO Compatibility extension folder; it is a manifest only, so it needs no build. */
-function omoCompatExtensionDir(ctx) {
-    const dir = resolve(dirname(ctx.cliPath), "..", "extensions", "omo-compat");
-    return ctx.fs.existsSync(join(dir, "package.json")) ? dir : undefined;
-}
 /** Plan all inputs before applying changes; dependencies are injected for hermetic tests. */
 export function setup(options, ctx = createContext()) {
     const lines = [];
@@ -49,8 +38,8 @@ export function setup(options, ctx = createContext()) {
             : ctx.cliPath;
     if (binary === undefined)
         throw new Error(`Cannot resolve executable --binary ${options.binary}`);
-    if (binary === ctx.cliPath && !ctx.fs.readFileSync(binary, "utf8").startsWith("#!/usr/bin/env node\n")) {
-        throw new Error(`Package CLI ${binary} is missing its node shebang; run npm run build`);
+    if (binary === ctx.cliPath && !ctx.fs.readFileSync(binary, "utf8").startsWith("#!/usr/bin/env bun\n")) {
+        throw new Error(`Package CLI ${binary} is missing its bun shebang; run npm run build`);
     }
     let launcher;
     let launcherText;
@@ -63,7 +52,7 @@ export function setup(options, ctx = createContext()) {
             realpath: (path) => ctx.fs.realpathSync(path),
         }, () => ctx.exec(npmBinaryFor(), ["root", "-g"]));
         launcher = autoUpdateLauncherPath(ctx);
-        launcherText = autoUpdateLauncherText(binary);
+        launcherText = autoUpdateLauncherText(binary, ctx.bunBinary);
         if (ctx.fs.existsSync(launcher))
             oldLauncher = ctx.fs.readFileSync(launcher, "utf8");
     }
@@ -181,17 +170,9 @@ export function setup(options, ctx = createContext()) {
     if (options.profile !== undefined && options.settings === undefined) {
         report(`OPENCHAMBER_DATA_DIR=${shellQuote(resolve(ctx.cwd, options.profile))} openchamber serve`);
     }
-    const extension = omoGraphExtensionDir(ctx);
+    const extension = antechamberExtensionDir(ctx);
     if (extension !== undefined) {
-        report(`Optional OmO Graph extension: in OpenChamber, Settings \u2192 Extensions \u2192 Add \u2192 Folder: ${extension}`);
-    }
-    const work = omoWorkExtensionDir(ctx);
-    if (work !== undefined) {
-        report(`Optional OmO Work section (todo phases, monitors, eval cells; OpenChamber 2.x): Settings \u2192 Extensions \u2192 Add \u2192 Folder: ${work}`);
-    }
-    const compat = omoCompatExtensionDir(ctx);
-    if (compat !== undefined) {
-        report(`Optional OmO Compatibility extension (eval card headers): Settings \u2192 Extensions \u2192 Add \u2192 Folder: ${compat}`);
+        report(`Optional antechamber extension (OmO Graph, OmO Work, OmO tool headers; OpenChamber 2.3.2+): Settings \u2192 Extensions \u2192 Add \u2192 Folder: ${extension}`);
     }
     return lines;
 }

package/dist/config.d.ts

@@ -12,7 +12,11 @@ export declare function envSetting(name: string, env?: NodeJS.ProcessEnv): strin
  * mappings survive the upgrade.
  */
 export declare function defaultStateDir(home?: string, exists?: typeof existsSync): string;
-/** Agent executable spawned per session: OmO by default, plain pi when configured. */
-export declare function agentBinary(env?: NodeJS.ProcessEnv): string;
+/** The OmO that antechamber's package.json pins, when it is installed beside antechamber. */
+export declare function bundledOmo(): string | undefined;
+/** Agent executable spawned per session: the pinned OmO by default, else `omo` on PATH, plain pi when configured. */
+export declare function agentBinary(env?: NodeJS.ProcessEnv, bundled?: () => string | undefined): string;
+/** Set by the OpenChamber extension's launcher: the extension, not npm, installs and updates antechamber. */
+export declare function managedByExtension(env?: NodeJS.ProcessEnv): boolean;
 /** True when the configured backend is upstream pi rather than OmO. */
 export declare function isPlainPi(env?: NodeJS.ProcessEnv): boolean;

package/dist/config.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
-import { basename, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 /** Environment variable prefix for all antechamber settings. */
 export const ENV_PREFIX = "ANTECHAMBER_";
 /** Prefix used before the project was renamed; still honoured as a fallback. */
@@ -30,9 +31,22 @@ export function defaultStateDir(home = homedir(), exists = existsSync) {
         return legacy;
     return current;
 }
-/** Agent executable spawned per session: OmO by default, plain pi when configured. */
-export function agentBinary(env = process.env) {
-    return envSetting("PI_BINARY", env) ?? "omo";
+/** The OmO that antechamber's package.json pins, when it is installed beside antechamber. */
+export function bundledOmo() {
+    try {
+        return join(dirname(createRequire(import.meta.url).resolve("omo-ai/package.json")), "bin", "omo.js");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Agent executable spawned per session: the pinned OmO by default, else `omo` on PATH, plain pi when configured. */
+export function agentBinary(env = process.env, bundled = bundledOmo) {
+    return envSetting("PI_BINARY", env) ?? bundled() ?? "omo";
+}
+/** Set by the OpenChamber extension's launcher: the extension, not npm, installs and updates antechamber. */
+export function managedByExtension(env = process.env) {
+    return envSetting("MANAGED", env) === "openchamber-extension";
 }
 /** True when the configured backend is upstream pi rather than OmO. */
 export function isPlainPi(env = process.env) {

package/dist/file-watch.d.ts

@@ -0,0 +1,35 @@
+import type { OCEvent } from "./types.js";
+export declare class FileWatchError extends Error {
+    readonly status: number;
+    readonly kind: string;
+    constructor(status: number, kind: string, message: string);
+}
+export declare class FileWatchRegistry {
+    private emit;
+    private watches;
+    constructor(emit: (directory: string, event: OCEvent) => void);
+    file(directory: string, path: string, required: boolean): Promise<string>;
+    watch(directory: string, file: string, reportedFile: string): void;
+    /**
+     * Watch the file itself, not its directory: on macOS a directory watch goes through FSEvents, which starts
+     * asynchronously and under load missed a write made right after the 204, and missed a delete-and-recreate for
+     * seconds (reproduced: every run failed with eight test processes in parallel). A file watch (kqueue there,
+     * inotify on Linux) starts within a tick. An editor's atomic save replaces the inode and ends the watch with
+     * "rename"; the replacement is watched. A removed file keeps its lease, as OpenCode's does: a stat watch looks for
+     * it until it exists again, then the native watch resumes.
+     */
+    private armFile;
+    /**
+     * Check for the missing file on a timer. Not fs.watchFile: it takes its baseline stat asynchronously and never
+     * reports a file that came back before that stat finished.
+     */
+    private awaitFile;
+    /**
+     * Runs inside a watch listener, where a throw would end the process: fs.watch throws synchronously for a
+     * replacement it cannot open (EACCES, a file gone again, ENOSPC/EMFILE). Such a lease is released instead.
+     */
+    private rearm;
+    private release;
+    unwatch(directory: string, file: string): void;
+    close(): void;
+}

package/dist/file-watch.js

@@ -0,0 +1,163 @@
+import { existsSync, watch } from "node:fs";
+import { realpath, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+export class FileWatchError extends Error {
+    status;
+    kind;
+    constructor(status, kind, message) {
+        super(message);
+        this.status = status;
+        this.kind = kind;
+    }
+}
+const LEASE_MS = 24 * 60 * 60 * 1000;
+const MAX_PER_DIRECTORY = 256;
+/** How often a missing watched file is checked for (existsSync, nothing spawned). */
+const MISSING_POLL_MS = 1000;
+export class FileWatchRegistry {
+    emit;
+    watches = new Map();
+    constructor(emit) {
+        this.emit = emit;
+    }
+    async file(directory, path, required) {
+        const root = await realpath(directory);
+        const target = resolve(root, path);
+        const inside = relative(root, target);
+        if (inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside))
+            throw new FileWatchError(400, "BadRequestError", "Path must remain inside the selected directory");
+        // Removal uses the registered path even when the file or symlink no longer exists.
+        if (!required)
+            return resolve(directory, path);
+        try {
+            const canonical = await realpath(target);
+            const rel = relative(root, canonical);
+            if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+                throw new FileWatchError(400, "BadRequestError", "Path must remain inside the selected directory");
+            if (!(await stat(canonical)).isFile())
+                throw new FileWatchError(404, "FileNotFoundError", `File not found: ${path}`);
+            return canonical;
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                throw new FileWatchError(404, "FileNotFoundError", `File not found: ${path}`);
+            throw error;
+        }
+    }
+    watch(directory, file, reportedFile) {
+        const files = this.watches.get(directory) ?? new Map();
+        const existing = files.get(reportedFile);
+        if (existing !== undefined) {
+            existing.expires = Date.now() + LEASE_MS;
+            clearTimeout(existing.timer);
+            existing.timer = setTimeout(() => this.unwatch(directory, reportedFile), LEASE_MS);
+            existing.timer.unref();
+            return;
+        }
+        if (files.size >= MAX_PER_DIRECTORY) {
+            const [soonest] = [...files].reduce((a, b) => (b[1].expires < a[1].expires ? b : a));
+            this.unwatch(directory, soonest);
+        }
+        const timer = setTimeout(() => this.unwatch(directory, reportedFile), LEASE_MS);
+        timer.unref();
+        const lease = { watcher: null, missing: null, expires: Date.now() + LEASE_MS, timer };
+        files.set(reportedFile, lease);
+        this.watches.set(directory, files);
+        lease.watcher = this.armFile(directory, file, reportedFile);
+    }
+    /**
+     * Watch the file itself, not its directory: on macOS a directory watch goes through FSEvents, which starts
+     * asynchronously and under load missed a write made right after the 204, and missed a delete-and-recreate for
+     * seconds (reproduced: every run failed with eight test processes in parallel). A file watch (kqueue there,
+     * inotify on Linux) starts within a tick. An editor's atomic save replaces the inode and ends the watch with
+     * "rename"; the replacement is watched. A removed file keeps its lease, as OpenCode's does: a stat watch looks for
+     * it until it exists again, then the native watch resumes.
+     */
+    armFile(directory, file, reportedFile) {
+        const watcher = watch(file, (event) => {
+            const exists = existsSync(file);
+            this.emit(directory, {
+                type: "filesystem.changed",
+                properties: { file: reportedFile, event: exists ? "change" : "unlink" },
+            });
+            const lease = this.watches.get(directory)?.get(reportedFile);
+            // A rename replaced the inode; an absent file ended the watch, whatever the event (macOS reports a write and
+            // a delete arriving together as one "change").
+            if (lease?.watcher !== watcher || (exists && event !== "rename"))
+                return;
+            watcher.close();
+            lease.watcher = null;
+            if (exists)
+                this.rearm(directory, file, reportedFile, lease);
+            else
+                this.awaitFile(directory, file, reportedFile, lease);
+        });
+        watcher.on("error", () => {
+            if (this.watches.get(directory)?.get(reportedFile)?.watcher === watcher)
+                this.unwatch(directory, reportedFile);
+            else
+                watcher.close();
+        });
+        return watcher;
+    }
+    /**
+     * Check for the missing file on a timer. Not fs.watchFile: it takes its baseline stat asynchronously and never
+     * reports a file that came back before that stat finished.
+     */
+    awaitFile(directory, file, reportedFile, lease) {
+        const check = () => {
+            if (!existsSync(file) || this.watches.get(directory)?.get(reportedFile) !== lease)
+                return;
+            if (lease.missing !== null)
+                clearInterval(lease.missing);
+            lease.missing = null;
+            this.emit(directory, { type: "filesystem.changed", properties: { file: reportedFile, event: "change" } });
+            this.rearm(directory, file, reportedFile, lease);
+        };
+        lease.missing = setInterval(check, MISSING_POLL_MS);
+        lease.missing.unref();
+        check();
+    }
+    /**
+     * Runs inside a watch listener, where a throw would end the process: fs.watch throws synchronously for a
+     * replacement it cannot open (EACCES, a file gone again, ENOSPC/EMFILE). Such a lease is released instead.
+     */
+    rearm(directory, file, reportedFile, lease) {
+        try {
+            lease.watcher = this.armFile(directory, file, reportedFile);
+        }
+        catch (error) {
+            // Gone again between the check and the watch: keep the lease and wait for it once more.
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                this.awaitFile(directory, file, reportedFile, lease);
+                return;
+            }
+            console.error(`[file-watch] stopped watching ${reportedFile}:`, error);
+            this.unwatch(directory, reportedFile);
+        }
+    }
+    release(lease) {
+        clearTimeout(lease.timer);
+        lease.watcher?.close();
+        if (lease.missing !== null)
+            clearInterval(lease.missing);
+    }
+    unwatch(directory, file) {
+        const files = this.watches.get(directory);
+        const entry = files?.get(file);
+        if (entry === undefined)
+            return;
+        this.release(entry);
+        files?.delete(file);
+        if (files?.size === 0)
+            this.watches.delete(directory);
+    }
+    close() {
+        for (const files of this.watches.values()) {
+            for (const entry of files.values()) {
+                this.release(entry);
+            }
+        }
+        this.watches.clear();
+    }
+}

package/dist/latency.d.ts

@@ -0,0 +1,10 @@
+/** Operator diagnostics. Route labels contain only literals and parameter names. */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare class LatencyMonitor {
+    private readonly lagThreshold;
+    private readonly requestThreshold;
+    private timer;
+    start(): void;
+    stop(): void;
+    request(req: IncomingMessage, res: ServerResponse, handle: () => Promise<void>): Promise<void>;
+}