afucontext 0.0.0-stage → 0.1.17

package/src/afu_host_integrations/shared/runtime-client/dist/host-worker.js

@@ -0,0 +1,170 @@
+import { journal } from "./telemetry.js";
+import { createServer } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import { CompactWorkerClient, workerOptionsFromEnv } from "./index.js";
+export function bindingKey(value) {
+    return createHash("sha256").update((JSON.stringify(value) ?? "null")).digest("hex");
+}
+/** Private in-process callback: provider credentials stay inside the host. */
+export class HostCompactPool {
+    options;
+    server;
+    starting;
+    base = "";
+    capability = randomBytes(32).toString("hex");
+    entries = new Map();
+    controllers = new Set();
+    closed = false;
+    constructor(options = workerOptionsFromEnv()) {
+        this.options = options;
+    }
+    async compact(request, binding, signal) {
+        const override = this.options.env?.AFU_HOST_CONTEXT_WINDOW_OVERRIDE ?? process.env.AFU_HOST_CONTEXT_WINDOW_OVERRIDE;
+        if (override && override !== "auto") {
+            const window = Number(override);
+            if (!Number.isSafeInteger(window) || window < 1)
+                throw new Error("Invalid context window");
+            binding = { ...binding, contextWindow: window, key: bindingKey([binding.key, window]) };
+        }
+        if (this.closed || !await binding.current())
+            throw new Error("Host model changed");
+        this.starting ??= this.start();
+        await this.starting;
+        if (this.closed)
+            throw new Error("Host worker closed");
+        for (const [key, old] of this.entries) {
+            let active = true;
+            if (key !== binding.key) {
+                try {
+                    active = await old.binding.current();
+                }
+                catch {
+                    active = false;
+                }
+            }
+            if (!active) {
+                this.entries.delete(key);
+                const closing = old.client.close({ drain: false }).catch(() => undefined);
+                if (process.platform === "win32")
+                    await closing;
+            }
+        }
+        if (this.closed)
+            throw new Error("Host worker closed");
+        let entry = this.entries.get(binding.key);
+        if (!entry) {
+            // Do not evict or interrupt another active session to admit a new one.
+            if (this.entries.size >= 16)
+                throw new Error("Host model binding limit reached");
+            const args = [...(this.options.args ?? ["compact", "worker"])];
+            const factory = args.indexOf("--factory");
+            if (factory >= 0 && args[factory + 1] !== "afu_context.local_worker:create_plugin")
+                throw new Error("Host binding requires the local worker factory");
+            if (factory < 0)
+                args.push("--factory", "afu_context.local_worker:create_plugin");
+            // Above the 600 s background summary limit, so the worker reports its own timeout.
+            const client = new CompactWorkerClient({ ...this.options, timeoutMs: this.options.timeoutMs ?? 630_000, args, env: {
+                    ...this.options.env,
+                    ...(binding.contextWindow === undefined ? {} : { AFU_CONTEXT_WINDOW: String(binding.contextWindow) }),
+                    AFU_HOST_SUMMARY_URL: `${this.base}/${this.capability}/${binding.key}`,
+                    AFU_HOST_SUMMARY_TOKEN: this.capability,
+                    NO_PROXY: [process.env.NO_PROXY, "127.0.0.1"].filter(Boolean).join(","),
+                    no_proxy: [process.env.no_proxy, "127.0.0.1"].filter(Boolean).join(","),
+                }, onStderr: () => undefined });
+            entry = { binding, client };
+            this.entries.set(binding.key, entry);
+        }
+        entry.binding = binding;
+        if (this.closed)
+            throw new Error("Host worker closed");
+        const result = await entry.client.compact({ ...request, ...(binding.contextWindow === undefined ? {} : { token_budget: binding.contextWindow }), session_id: bindingKey([request.session_id, binding.key]) }, signal);
+        if (!await binding.current())
+            throw new Error("Host model changed");
+        return result;
+    }
+    async start() {
+        const server = createServer(async (req, res) => {
+            const key = req.url?.split("/")[2];
+            const entry = key ? this.entries.get(key) : undefined;
+            // COSEC: loopback alone is not authentication; check a random capability,
+            // exact route and method. Never log provider errors, headers or bodies.
+            if (req.method !== "POST" || !entry || req.url !== `/${this.capability}/${key}/chat/completions` || req.headers.authorization !== `Bearer ${this.capability}`) {
+                res.writeHead(403).end();
+                return;
+            }
+            let artifactId;
+            let started;
+            const controller = new AbortController();
+            this.controllers.add(controller);
+            const timer = setTimeout(() => controller.abort(), 120_000);
+            res.on("close", () => { if (!res.writableEnded)
+                controller.abort(); });
+            try {
+                const chunks = [];
+                let size = 0;
+                for await (const chunk of req) {
+                    size += chunk.length;
+                    if (size > 16 * 1024 * 1024)
+                        throw new Error("Summary too large");
+                    chunks.push(chunk);
+                }
+                const body = JSON.parse(Buffer.concat(chunks).toString());
+                const prompt = body?.messages?.[0]?.content;
+                if (typeof prompt !== "string" || !await entry.binding.current())
+                    throw new Error("Invalid summary request");
+                const diag = entry.binding.diagnostics;
+                artifactId = typeof body.afu_summary_id === "string" && /^[a-f0-9]{24}$/.test(body.afu_summary_id) ? body.afu_summary_id : undefined;
+                const ids = body.afu_source_item_ids;
+                // COSEC: source coverage is validated before any host-provider call.
+                if (ids !== undefined && (!Array.isArray(ids) || ids.some((id) => typeof id !== "string") || new Set(ids).size !== ids.length))
+                    throw new Error("Invalid source coverage");
+                const binding = entry.binding;
+                started = performance.now();
+                if (diag)
+                    journal(diag.host)("summary_started", { session: diag.session, artifact_id: artifactId });
+                const text = await binding.complete(prompt, controller.signal, ids);
+                if (!text.trim() || !await binding.current())
+                    throw new Error("Stale summary");
+                if (diag)
+                    journal(diag.host)("summary_ready", { session: diag.session, artifact_id: artifactId, duration_ms: performance.now() - started, ...diag.usage?.() });
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ choices: [{ message: { content: text }, finish_reason: "stop" }] }));
+            }
+            catch (error) {
+                const diag = entry.binding.diagnostics;
+                // A short, fixed reason code from the binding (never provider text).
+                const code = typeof error?.afuReason === "string" ? error.afuReason : "host_summary_unavailable";
+                if (diag)
+                    journal(diag.host)("summary_failed", { session: diag.session, artifact_id: artifactId, duration_ms: started === undefined ? undefined : performance.now() - started, reason: controller.signal.aborted ? "summary_cancelled" : code });
+                if (!res.destroyed)
+                    res.writeHead(502).end('{"error":"host_summary_unavailable"}');
+            }
+            finally {
+                clearTimeout(timer);
+                this.controllers.delete(controller);
+            }
+        });
+        this.server = server;
+        await new Promise((resolve, reject) => { server.once("error", reject); server.listen(0, "127.0.0.1", resolve); });
+        const address = server.address();
+        if (!address || typeof address === "string")
+            throw new Error("Host bridge unavailable");
+        this.base = `http://127.0.0.1:${address.port}`;
+    }
+    async close() {
+        this.closed = true;
+        await this.starting?.catch(() => undefined);
+        for (const controller of this.controllers)
+            controller.abort();
+        // Entries registered by a compact() racing with close are closed here too.
+        while (this.entries.size) {
+            const entries = [...this.entries.values()];
+            this.entries.clear();
+            await Promise.allSettled(entries.map(e => e.client.close({ drain: false })));
+        }
+        this.server?.closeAllConnections();
+        if (this.server)
+            await new Promise(resolve => this.server.close(() => resolve()));
+    }
+}
+//# sourceMappingURL=host-worker.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/index.js

@@ -0,0 +1,243 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+export * from "./protocol.js";
+export class CompactWorkerError extends Error {
+    name = "CompactWorkerError";
+}
+export class CompactWorkerClient {
+    options;
+    child;
+    lines;
+    nextId = 1;
+    pending = new Map();
+    closing = false;
+    constructor(options = {}) {
+        this.options = {
+            ...options,
+            command: options.command ?? "afu-context",
+            args: options.args ?? ["compact", "worker"],
+            timeoutMs: options.timeoutMs ?? 30_000,
+        };
+    }
+    async ping(signal) {
+        await this.call("ping", {}, signal);
+    }
+    async compact(request, signal) {
+        const value = await this.call("compact", { request: request }, signal);
+        if (!isCompactResult(value)) {
+            throw new CompactWorkerError("worker returned an invalid CompactResult");
+        }
+        return value;
+    }
+    async drain(signal) {
+        await this.call("drain", {}, signal);
+    }
+    async close(options = {}) {
+        if (this.child === undefined)
+            return;
+        this.closing = true;
+        const child = this.child;
+        let stopped = false;
+        try {
+            await this.call("shutdown", { drain: options.drain ?? true }, undefined, true);
+            stopped = true;
+        }
+        finally {
+            this.lines?.close();
+            child.stdin.end();
+            if (!stopped && child.exitCode === null && !child.killed)
+                child.kill();
+            this.child = undefined;
+            this.lines = undefined;
+            this.rejectAll(new CompactWorkerError("worker closed"));
+            if (process.platform === "win32" && child.pid !== undefined && child.exitCode === null && child.signalCode === null) {
+                // Windows keeps the worker's cwd/files locked until the process exits.
+                await new Promise((resolve, reject) => {
+                    const finished = () => { clearTimeout(kill); clearTimeout(deadline); resolve(); };
+                    const kill = setTimeout(() => child.kill(), 5000);
+                    const deadline = setTimeout(() => {
+                        child.off("exit", finished);
+                        reject(new CompactWorkerError("worker did not exit after shutdown"));
+                    }, 10000);
+                    child.once("exit", finished);
+                });
+            }
+        }
+    }
+    call(method, params, signal, allowWhileClosing = false) {
+        if (this.closing && !allowWhileClosing) {
+            return Promise.reject(new CompactWorkerError("worker is closing"));
+        }
+        if (signal?.aborted) {
+            return Promise.reject(abortError(signal));
+        }
+        const child = this.ensureStarted();
+        const id = `${process.pid}-${this.nextId++}`;
+        return new Promise((resolve, reject) => {
+            const pending = { resolve, reject };
+            if (this.options.timeoutMs > 0) {
+                pending.timer = setTimeout(() => {
+                    this.pending.delete(id);
+                    pending.removeAbort?.();
+                    reject(new CompactWorkerError(`worker request timed out after ${this.options.timeoutMs}ms`));
+                }, this.options.timeoutMs);
+            }
+            if (signal !== undefined) {
+                const onAbort = () => {
+                    this.pending.delete(id);
+                    if (pending.timer !== undefined)
+                        clearTimeout(pending.timer);
+                    reject(abortError(signal));
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+                pending.removeAbort = () => signal.removeEventListener("abort", onAbort);
+            }
+            this.pending.set(id, pending);
+            const payload = JSON.stringify({ id, method, params });
+            child.stdin.write(`${payload}\n`, (error) => {
+                if (error === null || error === undefined)
+                    return;
+                this.finishPending(id, undefined, new CompactWorkerError(error.message));
+            });
+        });
+    }
+    ensureStarted() {
+        if (this.child !== undefined)
+            return this.child;
+        const child = spawn(this.options.command, this.options.args, {
+            cwd: this.options.cwd,
+            env: { ...process.env, ...this.options.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        // A worker that dies mid-write emits EPIPE on stdin; without a listener
+        // Node treats that as fatal and takes the host process down with it.
+        child.stdin.on("error", (error) => {
+            this.rejectAll(new CompactWorkerError(`worker input closed: ${error.message}`));
+        });
+        this.lines = createInterface({ input: child.stdout });
+        this.lines.on("line", (line) => this.handleLine(line));
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            if (this.options.onStderr !== undefined)
+                this.options.onStderr(text);
+            else
+                process.stderr.write(`[afu_context compact worker] ${text}`);
+        });
+        child.on("error", (error) => {
+            // A spawn failure emits "error" without "exit": forget this child so
+            // the next call starts a fresh worker instead of writing to a dead pipe.
+            if (this.child === child) {
+                this.child = undefined;
+                this.lines?.close();
+                this.lines = undefined;
+            }
+            this.rejectAll(new CompactWorkerError(`worker failed to start: ${error.message}`));
+        });
+        child.on("exit", (code, signal) => {
+            const expected = this.closing && code === 0;
+            if (!expected || this.pending.size > 0) {
+                this.rejectAll(new CompactWorkerError(`worker exited (code=${String(code)}, signal=${String(signal)})`));
+            }
+            if (this.child === child) {
+                this.child = undefined;
+                this.lines = undefined;
+            }
+        });
+        return child;
+    }
+    handleLine(line) {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            this.rejectAll(new CompactWorkerError("worker wrote non-JSON data to stdout"));
+            return;
+        }
+        if (!isWorkerResponse(value)) {
+            this.rejectAll(new CompactWorkerError("worker wrote an invalid response envelope"));
+            return;
+        }
+        if (value.ok && value.result !== undefined) {
+            this.finishPending(value.id, value.result);
+            return;
+        }
+        const message = value.error?.message ?? "worker request failed";
+        const type = value.error?.type;
+        this.finishPending(value.id, undefined, new CompactWorkerError(type === undefined ? message : `${type}: ${message}`));
+    }
+    finishPending(id, value, error) {
+        const pending = this.pending.get(id);
+        if (pending === undefined)
+            return;
+        this.pending.delete(id);
+        if (pending.timer !== undefined)
+            clearTimeout(pending.timer);
+        pending.removeAbort?.();
+        if (error !== undefined)
+            pending.reject(error);
+        else
+            pending.resolve(value ?? null);
+    }
+    rejectAll(error) {
+        for (const id of this.pending.keys())
+            this.finishPending(id, undefined, error);
+    }
+}
+export function workerOptionsFromEnv(env = process.env) {
+    const encodedArgs = env.AFU_CONTEXT_COMPACT_WORKER_ARGS;
+    let args;
+    if (encodedArgs !== undefined) {
+        const decoded = JSON.parse(encodedArgs);
+        if (!Array.isArray(decoded) || !decoded.every((value) => typeof value === "string")) {
+            throw new CompactWorkerError("AFU_CONTEXT_COMPACT_WORKER_ARGS must be a JSON string array");
+        }
+        args = decoded;
+    }
+    const encodedTimeout = env.AFU_CONTEXT_COMPACT_WORKER_TIMEOUT_MS;
+    const timeoutMs = encodedTimeout === undefined ? undefined : Number(encodedTimeout);
+    if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
+        throw new CompactWorkerError("AFU_CONTEXT_COMPACT_WORKER_TIMEOUT_MS must be a non-negative number");
+    }
+    return {
+        ...(env.AFU_CONTEXT_COMPACT_WORKER_COMMAND === undefined ? {} : { command: env.AFU_CONTEXT_COMPACT_WORKER_COMMAND }),
+        ...(args === undefined ? {} : { args }),
+        ...(env.AFU_CONTEXT_COMPACT_WORKER_CWD === undefined ? {} : { cwd: env.AFU_CONTEXT_COMPACT_WORKER_CWD }),
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    };
+}
+function abortError(signal) {
+    return signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+}
+function isWorkerResponse(value) {
+    if (!isRecord(value) || typeof value.id !== "string" || typeof value.ok !== "boolean")
+        return false;
+    if (value.result !== undefined && !isJsonValue(value.result))
+        return false;
+    return value.error === undefined || isRecord(value.error);
+}
+function isCompactResult(value) {
+    return (isRecord(value) &&
+        value.schema_version === "1" &&
+        Array.isArray(value.items) &&
+        Array.isArray(value.logical_items) &&
+        isRecord(value.usage) &&
+        isRecord(value.async_job));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    return isRecord(value) && Object.values(value).every(isJsonValue);
+}
+export { HostCompactPool, bindingKey } from "./host-worker.js";
+export { journal, sessionHash, afuTrigger } from "./telemetry.js";
+export { summaryPrefix } from "./prefix.js";
+export { afuStatus, afuDashboard, STATUS_COMMAND, DASHBOARD_COMMAND } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/prefix.js

@@ -0,0 +1,12 @@
+/** Keep the host prefix unchanged; coverage instructions are appended at its end. */
+export function summaryPrefix(entries, ids, prompt) {
+    if (!ids?.length)
+        return { messages: [], prompt }; // artifact-only consolidation
+    const start = entries.findIndex(entry => entry.id === ids[0]);
+    if (start < 0 || ids.some((id, i) => entries[start + i]?.id !== id))
+        throw new Error("Summary source no longer matches host history");
+    const before = entries.slice(0, start).flatMap(e => [...e.messages]).length;
+    const messages = entries.slice(0, start + ids.length).flatMap(e => [...e.messages]);
+    return { messages, prompt: before === 0 ? prompt : `${prompt}\nSource scope: use only messages ${before + 1} through ${messages.length} (one-based) as new source, together with any previous summary supplied in this request. Earlier messages are context only; do not import additional facts from them. Return one replacement summary.` };
+}
+//# sourceMappingURL=prefix.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/protocol.js

@@ -0,0 +1,79 @@
+export function findAppliedArtifact(result) {
+    for (const item of result.items) {
+        const replaced = item.metadata?.replaced_item_ids;
+        if (item.kind !== "artifact" || !Array.isArray(replaced))
+            continue;
+        const replacedItemIds = replaced.filter((value) => typeof value === "string");
+        if (replacedItemIds.length === 0)
+            continue;
+        const artifactId = item.metadata?.artifact_id;
+        return {
+            item,
+            replacedItemIds,
+            ...(typeof artifactId === "string" ? { artifactId } : {}),
+        };
+    }
+    return undefined;
+}
+export function normalizeContent(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value) && value.every(isJsonObject)) {
+        return structuredClone(value);
+    }
+    return safeStringify(value);
+}
+/** Same weights as the Python HeuristicTokenEstimator. */
+function characterWeight(code) {
+    if ((code >= 0x4e00 && code <= 0x9fff) || (code >= 0x3400 && code <= 0x4dbf))
+        return 1;
+    if ((code >= 0xac00 && code <= 0xd7af) || (code >= 0x1100 && code <= 0x11ff))
+        return 1;
+    if (code >= 0x3040 && code <= 0x30ff)
+        return 1;
+    if (code >= 0x1f000)
+        return 1;
+    if (code >= 0x0370)
+        return 0.5;
+    return 0.25;
+}
+export function estimateContentTokens(content) {
+    const text = typeof content === "string" ? content : JSON.stringify(content);
+    let units = 0;
+    for (const character of text)
+        units += characterWeight(character.codePointAt(0) ?? 0);
+    return text.length === 0 ? 0 : Math.max(1, Math.ceil(units));
+}
+function isJsonObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    return Object.values(value).every(isJsonValue);
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    return isJsonObject(value);
+}
+function safeStringify(value) {
+    try {
+        const encoded = JSON.stringify(value);
+        return encoded ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/** An opaque observation ID travels with the exact replacement artifact. */
+export function observationId(result) {
+    const applied = findAppliedArtifact(result);
+    if (!applied?.artifactId)
+        return undefined;
+    const artifact = result.artifacts.find(a => a.id === applied.artifactId);
+    const metadata = artifact?.metadata;
+    const id = metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata.observation_id : undefined;
+    return typeof id === "string" && /^[a-f0-9]{24}$/.test(id) ? id : undefined;
+}
+//# sourceMappingURL=protocol.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/telemetry.js

@@ -0,0 +1,78 @@
+import { appendFileSync, openSync, closeSync, mkdirSync, statSync, renameSync, constants, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID, createHash } from 'node:crypto';
+export const sessionHash = (value) => createHash('sha256').update(value).digest('hex').slice(0, 16);
+/**
+ * Context window and the token count at which AFU starts a background summary,
+ * matching the worker (afu_context.local_worker): an explicit window override,
+ * then AFU_TRIGGER_RATIO, else 0.5 for windows of 1M tokens or more and 0.6 below.
+ */
+export function afuTrigger(hostWindow, env = process.env, _platform = process.platform) {
+    const override = env.AFU_HOST_CONTEXT_WINDOW_OVERRIDE;
+    const window = override && override !== 'auto' ? Number(override) : hostWindow;
+    if (!Number.isSafeInteger(window) || !window || window < 1)
+        return {};
+    const configured = env.AFU_TRIGGER_RATIO && env.AFU_TRIGGER_RATIO !== 'auto' ? Number(env.AFU_TRIGGER_RATIO) : NaN;
+    const fallback = window >= 1_000_000 ? 0.5 : 0.6;
+    const ratio = configured > 0 && configured < 1 ? configured : fallback;
+    return { context_window: window, threshold: Math.floor(window * ratio) };
+}
+const journals = new Map();
+export function journal(host) {
+    let log = journals.get(host);
+    if (!log) {
+        const created = createJournal(host);
+        journals.set(host, created);
+        created('runtime_started');
+        // One runtime_stopped per process, however many times the host recycles
+        // the adapter (DSH disposes an engine per agent scope).
+        process.once('exit', () => created('runtime_stopped'));
+        log = created;
+    }
+    return (event, fields) => { if (event !== 'runtime_stopped')
+        log(event, fields); };
+}
+function createJournal(host) {
+    const root = join(process.env.AFU_STATE_DIR ?? join(homedir(), '.local/share/afu-context'), 'logs');
+    const id = randomUUID().replaceAll('-', '');
+    const file = join(root, `events-${process.pid}-${id}.jsonl`);
+    let version = '0.1.0', build = 'development';
+    try {
+        const m = JSON.parse(readFileSync(join(process.env.AFU_INSTALL_ROOT ?? process.cwd(), 'release.json'), 'utf8'));
+        if (/^[a-f0-9]{12,64}$/.test(m.build))
+            build = m.build;
+        if (/^[0-9.]+$/.test(m.version))
+            version = m.version;
+    }
+    catch { }
+    return (event, fields = {}) => {
+        try {
+            const row = { event, host, version, build, runtime_id: id, pid: process.pid, time: new Date().toISOString() };
+            // COSEC: diagnostics never include raw model IDs, credentials, prompts or errors.
+            for (const [k, v] of Object.entries(fields)) {
+                if (['session', 'artifact_id', 'phase', 'reason'].includes(k) && typeof v === 'string' && /^[A-Za-z0-9_.:+-]{1,100}$/.test(v))
+                    row[k] = v;
+                if (['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens', 'context_window', 'threshold', 'estimated_input_tokens', 'removed_tokens_estimate', 'duration_ms', 'host_compaction_ms'].includes(k) && typeof v === 'number' && Number.isFinite(v) && v >= 0)
+                    row[k] = v;
+                if (['cache_usage_known', 'applied', 'upstream_success'].includes(k) && typeof v === 'boolean')
+                    row[k] = v;
+            }
+            mkdirSync(root, { recursive: true, mode: 0o700 });
+            try {
+                if (statSync(file).size > 2 * 1024 * 1024)
+                    renameSync(file, file.replace('.jsonl', '.previous.jsonl'));
+            }
+            catch { }
+            const fd = openSync(file, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | (constants.O_NOFOLLOW ?? 0), 0o600);
+            try {
+                appendFileSync(fd, JSON.stringify(row) + '\n');
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+        catch { } // Logging must never break a host request.
+    };
+}
+//# sourceMappingURL=telemetry.js.map