byollm 0.1.0-alpha.0

package/dist/chunk-S5WHDSUF.js

@@ -0,0 +1,2358 @@
+// src/allowlist.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { z } from "zod";
+var AllowEntry = z.object({
+  /** Origin of the server that issued the id, e.g. `https://app.example.com`. */
+  origin: z.string().min(1),
+  /** The app's id for the user. */
+  owner: z.string().min(1),
+  /** Optional human label, so the list is readable a month later. */
+  note: z.string().optional(),
+  addedAt: z.number().int().positive()
+}).strict();
+var AllowFile = z.object({
+  version: z.literal(1),
+  entries: z.array(AllowEntry)
+}).strict();
+var Allowlist = class {
+  #path;
+  #entries = [];
+  #loaded = false;
+  constructor(path) {
+    this.#path = path;
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.#path, "utf8");
+      const parsed = AllowFile.safeParse(JSON.parse(raw));
+      this.#entries = parsed.success ? parsed.data.entries : [];
+    } catch {
+      this.#entries = [];
+    }
+    this.#loaded = true;
+  }
+  #assertLoaded() {
+    if (!this.#loaded) {
+      throw new Error("allowlist used before load()");
+    }
+  }
+  /** Does this list admit `owner` on `origin`? */
+  admits(origin, owner) {
+    this.#assertLoaded();
+    const normalized = normalizeOrigin(origin);
+    return this.#entries.some(
+      (entry) => normalizeOrigin(entry.origin) === normalized && entry.owner === owner
+    );
+  }
+  /** A predicate bound to one origin, for {@link matchAudience}. */
+  predicateFor(origin) {
+    return (owner) => this.admits(origin, owner);
+  }
+  list() {
+    this.#assertLoaded();
+    return [...this.#entries];
+  }
+  async add(entry, now) {
+    this.#assertLoaded();
+    const normalized = normalizeOrigin(entry.origin);
+    if (this.admits(normalized, entry.owner)) return;
+    this.#entries.push(
+      AllowEntry.parse({ ...entry, origin: normalized, addedAt: now })
+    );
+    await this.#save();
+  }
+  /** Remove an entry. Returns whether anything was removed. */
+  async remove(origin, owner) {
+    this.#assertLoaded();
+    const normalized = normalizeOrigin(origin);
+    const before = this.#entries.length;
+    this.#entries = this.#entries.filter(
+      (entry) => !(normalizeOrigin(entry.origin) === normalized && entry.owner === owner)
+    );
+    if (this.#entries.length === before) return false;
+    await this.#save();
+    return true;
+  }
+  async #save() {
+    await mkdir(dirname(this.#path), { recursive: true });
+    await writeFile(
+      this.#path,
+      `${JSON.stringify({ version: 1, entries: this.#entries }, null, 2)}
+`,
+      { mode: 384 }
+    );
+  }
+};
+function normalizeOrigin(input) {
+  try {
+    return new URL(input).origin;
+  } catch {
+    return input.replace(/\/+$/, "");
+  }
+}
+
+// src/cli.ts
+import { mkdir as mkdir5, rm as rm2, stat, writeFile as writeFile5 } from "fs/promises";
+import { hostname, userInfo } from "os";
+import { createInterface } from "readline/promises";
+
+// src/budgets.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { z as z2 } from "zod";
+var BudgetFile = z2.object({
+  version: z2.literal(1),
+  /** Epoch-ms timestamps of community jobs accepted, newest last. */
+  accepted: z2.array(z2.number().int().positive())
+}).strict();
+var Budgets = class {
+  #path;
+  #limits;
+  #accepted = [];
+  #loaded = false;
+  constructor(path, limits) {
+    this.#path = path;
+    this.#limits = limits;
+  }
+  async load(now) {
+    try {
+      const parsed = BudgetFile.safeParse(
+        JSON.parse(await readFile2(this.#path, "utf8"))
+      );
+      this.#accepted = parsed.success ? parsed.data.accepted : [];
+    } catch {
+      this.#accepted = [];
+    }
+    this.#prune(now);
+    this.#loaded = true;
+  }
+  /**
+   * May this community job run?
+   *
+   * @param payloadChars - total payload text length, checked against the
+   * stricter community limit rather than the protocol's absolute ceiling.
+   */
+  check(now, payloadChars) {
+    if (!this.#loaded) throw new Error("budgets used before load()");
+    this.#prune(now);
+    if (payloadChars > this.#limits.maxPayloadChars) {
+      return {
+        ok: false,
+        refusal: "payload-too-large",
+        detail: `community jobs are limited to ${String(this.#limits.maxPayloadChars)} characters; this one is ${String(payloadChars)}`
+      };
+    }
+    const hour = this.#countSince(now - 36e5);
+    if (hour >= this.#limits.maxJobsPerHour) {
+      return {
+        ok: false,
+        refusal: "hourly-cap",
+        detail: `already ran ${String(hour)} community jobs in the last hour`
+      };
+    }
+    const day = this.#countSince(now - 864e5);
+    if (day >= this.#limits.maxJobsPerDay) {
+      return {
+        ok: false,
+        refusal: "daily-cap",
+        detail: `already ran ${String(day)} community jobs today`
+      };
+    }
+    return { ok: true };
+  }
+  /** Count a community job as accepted. Call only after {@link check} passes. */
+  async record(now) {
+    this.#accepted.push(now);
+    this.#prune(now);
+    await mkdir2(dirname2(this.#path), { recursive: true });
+    await writeFile2(
+      this.#path,
+      JSON.stringify({ version: 1, accepted: this.#accepted }),
+      { mode: 384 }
+    );
+  }
+  /** Current usage, for `byollm status`. */
+  usage(now) {
+    this.#prune(now);
+    return {
+      hour: this.#countSince(now - 36e5),
+      day: this.#countSince(now - 864e5),
+      limits: this.#limits
+    };
+  }
+  #countSince(since) {
+    return this.#accepted.filter((at) => at >= since).length;
+  }
+  /** Anything older than a day can never affect either window again. */
+  #prune(now) {
+    const cutoff = now - 864e5;
+    this.#accepted = this.#accepted.filter((at) => at >= cutoff);
+  }
+};
+
+// src/client.ts
+import {
+  ClaimResponse,
+  HeartbeatResponse,
+  PROTOCOL_VERSION,
+  PairPollResponse,
+  PairStartResponse,
+  ReleaseResponse,
+  ResultResponse,
+  WireError
+} from "@byollm/protocol";
+import "zod";
+var ClientError = class extends Error {
+  constructor(kind, message, retryAfter) {
+    super(message);
+    this.kind = kind;
+    this.retryAfter = retryAfter;
+  }
+  kind;
+  retryAfter;
+  name = "ClientError";
+  /** Is retrying this same call plausibly useful? */
+  get retryable() {
+    return this.kind === "unreachable" || this.kind === "rate-limited" || this.kind === "server-error";
+  }
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var ProtocolClient = class _ProtocolClient {
+  #origin;
+  #token;
+  #timeoutMs;
+  #fetch;
+  constructor(options) {
+    this.#origin = options.origin.replace(/\/+$/, "");
+    this.#token = options.token;
+    this.#timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.#fetch = options.fetch ?? globalThis.fetch;
+  }
+  /** A client for the same origin carrying a token. */
+  withToken(token) {
+    return new _ProtocolClient({
+      origin: this.#origin,
+      token,
+      timeoutMs: this.#timeoutMs,
+      fetch: this.#fetch
+    });
+  }
+  get origin() {
+    return this.#origin;
+  }
+  async pairStart(input) {
+    return this.#post("pair", PairStartResponse, {
+      protocolVersion: PROTOCOL_VERSION,
+      action: "start",
+      daemon: {
+        version: input.version,
+        label: input.label,
+        platform: input.platform
+      },
+      capabilities: input.capabilities
+    });
+  }
+  async pairPoll(deviceCode) {
+    return this.#post("pair", PairPollResponse, {
+      protocolVersion: PROTOCOL_VERSION,
+      action: "poll",
+      deviceCode
+    });
+  }
+  async claim(input) {
+    return this.#post("claim", ClaimResponse, {
+      protocolVersion: PROTOCOL_VERSION,
+      runnerId: input.runnerId,
+      capabilities: input.capabilities,
+      max: input.max
+    });
+  }
+  async heartbeat(input) {
+    return this.#post("heartbeat", HeartbeatResponse, {
+      protocolVersion: PROTOCOL_VERSION,
+      runnerId: input.runnerId,
+      daemonVersion: input.daemonVersion,
+      capabilities: input.capabilities,
+      activeJobIds: input.activeJobIds,
+      paused: input.paused
+    });
+  }
+  async result(input) {
+    return this.#post("result", ResultResponse, {
+      protocolVersion: PROTOCOL_VERSION,
+      ...input
+    });
+  }
+  async release(input) {
+    return this.#post("release", ReleaseResponse, {
+      protocolVersion: PROTOCOL_VERSION,
+      runnerId: input.runnerId,
+      jobIds: input.jobIds,
+      reason: input.reason
+    });
+  }
+  async #post(endpoint, schema, body) {
+    const headers = {
+      "content-type": "application/json",
+      accept: "application/json"
+    };
+    if (this.#token !== void 0) {
+      headers["authorization"] = `Bearer ${this.#token}`;
+    }
+    let response;
+    try {
+      response = await this.#fetch(`${this.#origin}/byollm/${endpoint}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        redirect: "error",
+        signal: AbortSignal.timeout(this.#timeoutMs)
+      });
+    } catch (error) {
+      throw new ClientError(
+        "unreachable",
+        `could not reach ${this.#origin} (${error instanceof Error ? error.message : "unknown error"})`
+      );
+    }
+    const text = await response.text();
+    let parsed;
+    try {
+      parsed = text === "" ? {} : JSON.parse(text);
+    } catch {
+      throw new ClientError(
+        "malformed-response",
+        `${this.#origin} returned HTTP ${String(response.status)} with a body that is not JSON`
+      );
+    }
+    if (!response.ok) {
+      throw this.#toError(response, parsed);
+    }
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      throw new ClientError(
+        "malformed-response",
+        `${this.#origin} returned a ${endpoint} response that does not match protocol v${PROTOCOL_VERSION}`
+      );
+    }
+    return result.data;
+  }
+  #toError(response, body) {
+    const wire = WireError.safeParse(body);
+    const retryAfterHeader = response.headers.get("retry-after");
+    const retryAfter = wire.success && wire.data.retryAfter !== void 0 ? wire.data.retryAfter : retryAfterHeader !== null && /^\d+$/.test(retryAfterHeader) ? Number(retryAfterHeader) : void 0;
+    const message = wire.success ? wire.data.message : `${this.#origin} returned HTTP ${String(response.status)}`;
+    if (wire.success && wire.data.error === "revoked") {
+      return new ClientError("revoked", message, retryAfter);
+    }
+    switch (response.status) {
+      case 401:
+        return new ClientError("unauthorized", message, retryAfter);
+      case 403:
+        return new ClientError("revoked", message, retryAfter);
+      case 429:
+        return new ClientError("rate-limited", message, retryAfter);
+      case 400:
+      case 404:
+        return new ClientError("rejected", message, retryAfter);
+      default:
+        return response.status >= 500 ? new ClientError("server-error", message, retryAfter) : new ClientError("rejected", message, retryAfter);
+    }
+  }
+};
+
+// src/config.ts
+import { readFile as readFile3 } from "fs/promises";
+import {
+  BackendIdSchema,
+  JobKind,
+  OfferScope,
+  backendDescriptor,
+  effectiveOfferScope
+} from "@byollm/protocol";
+import { z as z3 } from "zod";
+
+// src/ssrf.ts
+import { isIP } from "net";
+var METADATA_HOSTS = /* @__PURE__ */ new Set([
+  "metadata.google.internal",
+  "metadata.goog",
+  "instance-data",
+  "metadata"
+]);
+var METADATA_ADDRESSES = /* @__PURE__ */ new Set([
+  "169.254.169.254",
+  "169.254.170.2",
+  "fd00:ec2::254"
+]);
+function checkBaseUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return {
+      ok: false,
+      refusal: "not-a-url",
+      detail: "base URL is not a valid absolute URL"
+    };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return {
+      ok: false,
+      refusal: "bad-scheme",
+      detail: `base URL scheme ${url.protocol} is not http or https`
+    };
+  }
+  if (url.username !== "" || url.password !== "") {
+    return {
+      ok: false,
+      refusal: "credentials-in-url",
+      detail: "base URL must not embed a username or password"
+    };
+  }
+  const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (METADATA_HOSTS.has(host) || METADATA_ADDRESSES.has(host)) {
+    return {
+      ok: false,
+      refusal: "cloud-metadata",
+      detail: `${host} is a cloud metadata endpoint`
+    };
+  }
+  if (isIP(host) === 4 && host.startsWith("169.254.")) {
+    return {
+      ok: false,
+      refusal: "link-local",
+      detail: `${host} is link-local`
+    };
+  }
+  if (isIP(host) === 6 && /^fe[89ab]/.test(host)) {
+    return {
+      ok: false,
+      refusal: "link-local",
+      detail: `${host} is link-local`
+    };
+  }
+  if (host === "0.0.0.0" || host === "::" || host === "") {
+    return {
+      ok: false,
+      refusal: "wildcard-address",
+      detail: `${host || "(empty)"} is not a destination address`
+    };
+  }
+  return { ok: true, url };
+}
+var BASE_URL_REFUSAL_MESSAGES = Object.freeze({
+  "not-a-url": "that base URL could not be parsed",
+  "bad-scheme": "a backend base URL must be http or https",
+  "credentials-in-url": "put credentials in the backend's auth config, not in the URL",
+  "cloud-metadata": "that address is a cloud metadata endpoint and would expose instance credentials",
+  "link-local": "link-local addresses are refused",
+  "wildcard-address": "that is an address to listen on, not one to connect to \u2014 use 127.0.0.1"
+});
+
+// src/config.ts
+var BackendConfig = z3.object({
+  backend: BackendIdSchema,
+  /** Required for HTTP-class backends; meaningless for process-class. */
+  baseUrl: z3.string().optional(),
+  /**
+   * What the owner is willing to run for others. Subscription-class
+   * backends ignore this and are locked to `self`
+   * ({@link MUSTS.SUBSCRIPTION_SELF_LOCK}).
+   */
+  offer: OfferScope.default("self"),
+  /**
+   * Name of an environment variable holding this backend's API key, for a
+   * remote OpenAI-compatible server that needs one. The *name*, never the
+   * value — a key does not belong in a config file the owner may share.
+   */
+  apiKeyEnv: z3.string().optional()
+}).strict();
+var RouteConfig = z3.object({
+  /** Key into {@link DaemonConfig.backends}. */
+  backend: z3.string().min(1),
+  /** The model name, owner-chosen. A payload can never influence this. */
+  model: z3.string().min(1)
+}).strict();
+var CommunityBudget = z3.object({
+  maxJobsPerHour: z3.number().int().positive().default(20),
+  maxJobsPerDay: z3.number().int().positive().default(100),
+  /** Wall-clock ceiling for one community job. */
+  maxWallClockMs: z3.number().int().positive().default(12e4),
+  /** Output-size ceiling for one community job. */
+  maxOutputBytes: z3.number().int().positive().default(256 * 1024),
+  /** Payload-size ceiling — stricter than the protocol's absolute limit. */
+  maxPayloadChars: z3.number().int().positive().default(1e5)
+}).strict();
+var IngressRetention = z3.object({
+  /**
+   * How long a `named`/`public` prompt is kept in full before being reduced
+   * to a hash. A volunteer must not indefinitely retain strangers' content.
+   */
+  communityPromptDays: z3.number().int().positive().default(7),
+  /** Whether the owner's own prompts are kept in full. Their call. */
+  keepSelfPrompts: z3.boolean().default(true)
+}).strict();
+var Limits = z3.object({
+  maxWallClockMs: z3.number().int().positive().default(6e5),
+  maxOutputBytes: z3.number().int().positive().default(4 * 1024 * 1024)
+}).strict();
+var DaemonConfig = z3.object({
+  backends: z3.record(z3.string().min(1), BackendConfig),
+  // `partialRecord`, not `record`: zod 4's `record` with an enum key
+  // demands every member be present, which would force an owner who only
+  // wants `llm.generate` to also configure `llm.chat`. Routing one kind and
+  // not the other is a legitimate setup — the unrouted kind is simply never
+  // advertised.
+  routes: z3.partialRecord(JobKind, RouteConfig),
+  /** How many jobs to run at once. */
+  concurrency: z3.number().int().min(1).max(32).default(2),
+  // `prefault`, not `default`: zod 4's `.default()` takes an *output* value,
+  // which would mean restating every nested default here where it could
+  // drift. `prefault` feeds `{}` through the schema so the nested defaults
+  // stay the single source of truth.
+  community: CommunityBudget.prefault({}),
+  ingress: IngressRetention.prefault({}),
+  limits: Limits.prefault({})
+}).strict();
+var DEFAULT_CONFIG = DaemonConfig.parse({
+  backends: {
+    ollama: { backend: "openai-http", baseUrl: "http://127.0.0.1:11434/v1" }
+  },
+  routes: {
+    "llm.generate": { backend: "ollama", model: "llama3.2" },
+    "llm.chat": { backend: "ollama", model: "llama3.2" }
+  }
+});
+async function loadConfig(path) {
+  let raw;
+  try {
+    raw = await readFile3(path, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) return resolveConfig(DEFAULT_CONFIG);
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `${path} is not valid JSON: ${error instanceof Error ? error.message : "unknown error"}`,
+      { cause: error }
+    );
+  }
+  const result = DaemonConfig.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => `  ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
+    throw new Error(`${path} is not a valid byollm config:
+${issues}`);
+  }
+  return resolveConfig(result.data);
+}
+function resolveConfig(config) {
+  const routes = [];
+  const problems = [];
+  for (const [kind, route] of Object.entries(config.routes)) {
+    const where = `routes.${kind}`;
+    const backend = config.backends[route.backend];
+    if (!backend) {
+      problems.push({
+        where,
+        message: `backend "${route.backend}" is not defined in backends`
+      });
+      continue;
+    }
+    const descriptor = backendDescriptor(backend.backend);
+    if (descriptor.class === "http") {
+      if (backend.baseUrl === void 0) {
+        problems.push({
+          where: `backends.${route.backend}`,
+          message: "an HTTP-class backend needs a baseUrl"
+        });
+        continue;
+      }
+      const check = checkBaseUrl(backend.baseUrl);
+      if (!check.ok) {
+        problems.push({
+          where: `backends.${route.backend}.baseUrl`,
+          message: check.detail
+        });
+        continue;
+      }
+    }
+    const configured = backend.offer;
+    const offerScope = effectiveOfferScope(configured, descriptor.account);
+    if (offerScope !== configured) {
+      problems.push({
+        where: `backends.${route.backend}.offer`,
+        message: `"${configured}" was ignored: ${descriptor.label} runs on your own subscription, so it is locked to your work only`
+      });
+    }
+    routes.push({
+      kind,
+      backendKey: route.backend,
+      backendId: backend.backend,
+      backendClass: descriptor.class,
+      model: route.model,
+      offerScope,
+      baseUrl: backend.baseUrl,
+      apiKeyEnv: backend.apiKeyEnv
+    });
+  }
+  return { config, routes, problems };
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/connect.ts
+import { platform } from "os";
+async function connect(options) {
+  const now = options.now ?? Date.now;
+  const sleep2 = options.sleep ?? defaultSleep;
+  const started = await options.client.pairStart({
+    version: options.daemonVersion,
+    label: options.label,
+    platform: currentPlatform(),
+    capabilities: options.capabilities
+  });
+  options.onCode({
+    userCode: started.userCode,
+    verificationUrl: started.verificationUrl,
+    expiresAt: started.expiresAt
+  });
+  for (; ; ) {
+    if (options.signal?.aborted === true) {
+      return { ok: false, reason: "aborted", message: "pairing was canceled" };
+    }
+    if (now() >= started.expiresAt) {
+      return {
+        ok: false,
+        reason: "expired",
+        message: "the pairing code expired before it was approved"
+      };
+    }
+    await sleep2(started.pollIntervalMs);
+    options.onPoll?.();
+    let polled;
+    try {
+      polled = await options.client.pairPoll(started.deviceCode);
+    } catch (error) {
+      if (error instanceof ClientError && error.retryable) continue;
+      throw error;
+    }
+    switch (polled.status) {
+      case "pending":
+        continue;
+      case "denied":
+        return {
+          ok: false,
+          reason: "denied",
+          message: "the pairing request was declined"
+        };
+      case "expired":
+        return {
+          ok: false,
+          reason: "expired",
+          message: "the pairing code expired before it was approved"
+        };
+      case "approved":
+        return {
+          ok: true,
+          pairing: {
+            origin: options.client.origin,
+            runnerId: polled.runnerId,
+            token: polled.runnerToken,
+            owner: polled.owner,
+            ...polled.ownerLabel === void 0 ? {} : { ownerLabel: polled.ownerLabel },
+            pairedAt: now()
+          }
+        };
+    }
+  }
+}
+function currentPlatform() {
+  const current = platform();
+  if (current === "darwin" || current === "linux" || current === "win32") {
+    return current;
+  }
+  return "linux";
+}
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/ingress.ts
+import { createHash } from "crypto";
+import { appendFile, mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+import { z as z4 } from "zod";
+var PromptEntry = z4.object({
+  type: z4.literal("prompt"),
+  at: z4.number().int().positive(),
+  /** Origin of the server that sent the job. */
+  origin: z4.string().min(1),
+  jobId: z4.string().min(1),
+  kind: z4.string().min(1),
+  audience: z4.string().min(1),
+  /** Who this prompt is *for* — which, for community work, is not you. */
+  owner: z4.string().min(1),
+  backendId: z4.string().min(1),
+  backendClass: z4.string().min(1),
+  model: z4.string().min(1),
+  /** Always present, including after retention drops the text. */
+  promptHash: z4.string().length(64),
+  promptChars: z4.number().int().nonnegative(),
+  /**
+   * The prompt itself. Absent means "not retained" — distinct from an empty
+   * prompt, which the protocol forbids anyway. Zero and unknown never look
+   * alike.
+   */
+  prompt: z4.string().optional()
+}).strict();
+var OutcomeEntry = z4.object({
+  type: z4.literal("outcome"),
+  at: z4.number().int().positive(),
+  jobId: z4.string().min(1),
+  outcome: z4.enum(["ok", "error", "canceled", "refused"]),
+  /** Present for a job that ran; absent for one refused before execution. */
+  durationMs: z4.number().int().nonnegative().optional(),
+  outputChars: z4.number().int().nonnegative().optional(),
+  /** Why, for `error` and `refused`. */
+  detail: z4.string().optional()
+}).strict();
+var IngressEntry = z4.discriminatedUnion("type", [
+  PromptEntry,
+  OutcomeEntry
+]);
+var IngressLog = class {
+  #options;
+  constructor(options) {
+    this.#options = options;
+  }
+  /** Record a prompt. Await this before starting the backend call. */
+  async recordPrompt(input) {
+    const keepText = input.audience === "self" ? this.#options.keepSelfPrompts : true;
+    await this.#append({
+      type: "prompt",
+      at: input.at,
+      origin: input.origin,
+      jobId: input.jobId,
+      kind: input.kind,
+      audience: input.audience,
+      owner: input.owner,
+      backendId: input.backendId,
+      backendClass: input.backendClass,
+      model: input.model,
+      promptHash: hashText(input.prompt),
+      promptChars: input.prompt.length,
+      ...keepText ? { prompt: input.prompt } : {}
+    });
+  }
+  /** Record how a job ended. */
+  async recordOutcome(input) {
+    await this.#append({
+      type: "outcome",
+      at: input.at,
+      jobId: input.jobId,
+      outcome: input.outcome,
+      ...input.durationMs === void 0 ? {} : { durationMs: input.durationMs },
+      ...input.outputChars === void 0 ? {} : { outputChars: input.outputChars },
+      ...input.detail === void 0 ? {} : { detail: input.detail }
+    });
+  }
+  async #append(entry) {
+    await mkdir3(dirname3(this.#options.path), { recursive: true });
+    await appendFile(this.#options.path, `${JSON.stringify(entry)}
+`, {
+      mode: 384
+    });
+  }
+  /** Read the log, oldest first. Malformed lines are skipped, not fatal. */
+  async read() {
+    let raw;
+    try {
+      raw = await readFile4(this.#options.path, "utf8");
+    } catch {
+      return [];
+    }
+    const entries = [];
+    for (const line of raw.split("\n")) {
+      if (line.trim() === "") continue;
+      try {
+        const parsed = IngressEntry.safeParse(JSON.parse(line));
+        if (parsed.success) entries.push(parsed.data);
+      } catch {
+      }
+    }
+    return entries;
+  }
+  /**
+   * Apply retention: drop the text of community prompts older than the
+   * window, keeping the hash, the metadata and the character count.
+   *
+   * byollm_004 Rev 1: a volunteer must not indefinitely retain strangers'
+   * content. The hash stays, so the owner can still prove what ran.
+   *
+   * @returns how many entries were reduced.
+   */
+  async applyRetention(now) {
+    const entries = await this.read();
+    const cutoff = now - this.#options.communityPromptDays * 864e5;
+    let reduced = 0;
+    const kept = entries.map((entry) => {
+      if (entry.type !== "prompt") return entry;
+      const isCommunity = entry.audience === "named" || entry.audience === "public";
+      if (!isCommunity || entry.prompt === void 0 || entry.at >= cutoff) {
+        return entry;
+      }
+      reduced += 1;
+      const { prompt: _dropped, ...rest } = entry;
+      return rest;
+    });
+    if (reduced > 0) {
+      await writeFile3(
+        this.#options.path,
+        `${kept.map((entry) => JSON.stringify(entry)).join("\n")}
+`,
+        { mode: 384 }
+      );
+    }
+    return reduced;
+  }
+};
+function hashText(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function stripControlChars(text) {
+  return text.replace(/[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g, "\uFFFD");
+}
+
+// src/pairings.ts
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+import { z as z5 } from "zod";
+var Pairing = z5.object({
+  origin: z5.string().min(1),
+  runnerId: z5.string().min(1),
+  /** Bearer token. This file is written 0600 for exactly this reason. */
+  token: z5.string().min(1),
+  /** The app's id for this daemon's owner. */
+  owner: z5.string().min(1),
+  ownerLabel: z5.string().optional(),
+  pairedAt: z5.number().int().positive()
+}).strict();
+var PairingFile = z5.object({ version: z5.literal(1), pairings: z5.array(Pairing) }).strict();
+var Pairings = class {
+  #path;
+  #pairings = [];
+  #loaded = false;
+  constructor(path) {
+    this.#path = path;
+  }
+  async load() {
+    try {
+      const parsed = PairingFile.safeParse(
+        JSON.parse(await readFile5(this.#path, "utf8"))
+      );
+      this.#pairings = parsed.success ? parsed.data.pairings : [];
+    } catch {
+      this.#pairings = [];
+    }
+    this.#loaded = true;
+  }
+  list() {
+    this.#assertLoaded();
+    return [...this.#pairings];
+  }
+  get(origin) {
+    this.#assertLoaded();
+    const normalized = normalizeOrigin(origin);
+    return this.#pairings.find(
+      (pairing) => normalizeOrigin(pairing.origin) === normalized
+    );
+  }
+  /** Add or replace the pairing for an origin. Re-pairing supersedes. */
+  async put(pairing) {
+    this.#assertLoaded();
+    const normalized = normalizeOrigin(pairing.origin);
+    this.#pairings = this.#pairings.filter(
+      (existing) => normalizeOrigin(existing.origin) !== normalized
+    );
+    this.#pairings.push({ ...pairing, origin: normalized });
+    await this.#save();
+  }
+  /** Forget a pairing. Returns whether one was removed. */
+  async remove(origin) {
+    this.#assertLoaded();
+    const normalized = normalizeOrigin(origin);
+    const before = this.#pairings.length;
+    this.#pairings = this.#pairings.filter(
+      (pairing) => normalizeOrigin(pairing.origin) !== normalized
+    );
+    if (this.#pairings.length === before) return false;
+    await this.#save();
+    return true;
+  }
+  #assertLoaded() {
+    if (!this.#loaded) throw new Error("pairings used before load()");
+  }
+  async #save() {
+    await mkdir4(dirname4(this.#path), { recursive: true });
+    await writeFile4(
+      this.#path,
+      `${JSON.stringify({ version: 1, pairings: this.#pairings }, null, 2)}
+`,
+      // Tokens live here. Nobody else on a shared machine gets to read them.
+      { mode: 384 }
+    );
+  }
+};
+
+// src/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function daemonPaths(root = defaultRoot()) {
+  return {
+    root,
+    config: join(root, "config.json"),
+    pairings: join(root, "pairings.json"),
+    allowlist: join(root, "allow.json"),
+    ingressLog: join(root, "ingress.log"),
+    budgets: join(root, "budgets.json"),
+    pauseFlag: join(root, "paused"),
+    scratch: join(root, "scratch")
+  };
+}
+function defaultRoot() {
+  return process.env["BYOLLM_HOME"] ?? join(homedir(), ".byollm");
+}
+
+// src/runner.ts
+import {
+  REFUSAL_MESSAGES,
+  backendDescriptor as backendDescriptor2,
+  matchAudience,
+  payloadTextLength
+} from "@byollm/protocol";
+
+// src/backends/index.ts
+import { BACKEND_IDS } from "@byollm/protocol";
+
+// src/backends/claude-cli.ts
+import { execFile, spawn } from "child_process";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+var FIXED_ARGV = Object.freeze([
+  "--print",
+  "--output-format",
+  "text",
+  "--tools",
+  "",
+  "--strict-mcp-config",
+  "--mcp-config",
+  '{"mcpServers":{}}',
+  "--no-session-persistence"
+]);
+var ENV_ALLOWLIST = Object.freeze([
+  "PATH",
+  "HOME",
+  "LANG",
+  "LC_ALL",
+  "TZ",
+  "TMPDIR"
+]);
+function childEnv(source = process.env) {
+  const env = {};
+  for (const name of ENV_ALLOWLIST) {
+    const value = source[name];
+    if (value !== void 0) env[name] = value;
+  }
+  env["CI"] = "1";
+  return env;
+}
+function claudeArgv(model) {
+  return Object.freeze([...FIXED_ARGV, "--model", model]);
+}
+var ClaudeCliBackend = class {
+  id = "claude-cli";
+  class = "process";
+  #binary;
+  /**
+   * @param binary - which executable to run. Defaults to `claude` and is
+   * **not reachable from configuration**: {@link createBackend} constructs
+   * this with no arguments, and {@link BackendInit} has no field for it. It
+   * exists so the adversarial suite can substitute a probe that reports the
+   * argv, environment, cwd and stdin it actually received — which is the only
+   * way to *prove* byollm_004 §2 rather than assert it.
+   */
+  constructor(binary = "claude") {
+    this.#binary = binary;
+  }
+  async health() {
+    const version = await new Promise((resolve) => {
+      execFile(
+        this.#binary,
+        ["--version"],
+        { timeout: 1e4, env: childEnv() },
+        (error, stdout) => {
+          resolve(error ? null : stdout.trim());
+        }
+      );
+    });
+    if (version === null) {
+      return {
+        healthy: false,
+        models: [],
+        detail: "the `claude` CLI is not installed or not on PATH (https://claude.com/claude-code)"
+      };
+    }
+    return { healthy: true, models: [] };
+  }
+  async execute(request) {
+    const started = Date.now();
+    const scratch = await mkdtemp(join2(tmpdir(), "byollm-job-"));
+    try {
+      return await this.#spawn(request, scratch, started);
+    } finally {
+      await rm(scratch, { recursive: true, force: true });
+    }
+  }
+  async #spawn(request, scratch, started) {
+    return new Promise((resolve) => {
+      if (request.signal.aborted) {
+        resolve({
+          ok: false,
+          code: "canceled",
+          message: "the job was canceled before it started",
+          retryable: false,
+          durationMs: Date.now() - started
+        });
+        return;
+      }
+      const child = spawn(this.#binary, claudeArgv(request.model), {
+        cwd: scratch,
+        env: childEnv(),
+        // Exactly the three std streams. Nothing else is inherited, so the
+        // child cannot reach a descriptor the daemon happens to hold open.
+        stdio: ["pipe", "pipe", "pipe"],
+        // No shell, ever. With `shell: false` the argv array is passed to
+        // execvp verbatim and metacharacters in it are just bytes.
+        shell: false,
+        detached: false
+      });
+      let stdout = "";
+      let stderr = "";
+      let outputBytes = 0;
+      let settled = false;
+      let exited = false;
+      let reason = null;
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        request.signal.removeEventListener("abort", onAbort);
+        resolve(result);
+      };
+      const kill = (why) => {
+        reason = why;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!exited) child.kill("SIGKILL");
+        }, 2e3).unref();
+      };
+      const timer = setTimeout(() => {
+        kill("timeout");
+      }, request.timeoutMs);
+      const onAbort = () => {
+        kill("canceled");
+      };
+      request.signal.addEventListener("abort", onAbort, { once: true });
+      child.stdout.on("data", (chunk) => {
+        outputBytes += chunk.byteLength;
+        if (outputBytes > request.maxOutputBytes) {
+          kill("output-too-large");
+          return;
+        }
+        stdout += chunk.toString("utf8");
+      });
+      child.stderr.on("data", (chunk) => {
+        if (stderr.length < 8192) stderr += chunk.toString("utf8");
+      });
+      child.on("error", (error) => {
+        finish({
+          ok: false,
+          code: "backend-unreachable",
+          message: `could not start the claude CLI: ${error.message}`,
+          retryable: false,
+          durationMs: Date.now() - started
+        });
+      });
+      child.on("close", (code) => {
+        exited = true;
+        const durationMs = Date.now() - started;
+        if (reason === "canceled") {
+          finish({
+            ok: false,
+            code: "canceled",
+            message: "the job was canceled",
+            retryable: false,
+            durationMs
+          });
+          return;
+        }
+        if (reason === "timeout") {
+          finish({
+            ok: false,
+            code: "timeout",
+            message: `the model did not answer within ${String(request.timeoutMs)}ms`,
+            retryable: true,
+            durationMs
+          });
+          return;
+        }
+        if (reason === "output-too-large") {
+          finish({
+            ok: false,
+            code: "output-too-large",
+            message: `the model produced more than ${String(request.maxOutputBytes)} bytes`,
+            retryable: false,
+            durationMs
+          });
+          return;
+        }
+        if (code !== 0) {
+          finish({
+            ok: false,
+            code: "backend-error",
+            message: stderr.trim() === "" ? `the claude CLI exited with status ${String(code)}` : `the claude CLI failed: ${firstLine(stderr)}`,
+            retryable: false,
+            durationMs
+          });
+          return;
+        }
+        finish({ ok: true, text: stdout, durationMs });
+      });
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(request.prompt, "utf8");
+    });
+  }
+};
+function firstLine(text) {
+  return text.trim().split("\n")[0] ?? "";
+}
+
+// src/backends/openai-http.ts
+var OpenAiHttpBackend = class {
+  id = "openai-http";
+  class = "http";
+  #baseUrl;
+  #apiKeyEnv;
+  constructor(init) {
+    if (init.baseUrl === void 0) {
+      throw new Error("openai-http backend requires a baseUrl");
+    }
+    const check = checkBaseUrl(init.baseUrl);
+    if (!check.ok) {
+      throw new Error(`refusing base URL: ${check.detail}`);
+    }
+    this.#baseUrl = check.url;
+    this.#apiKeyEnv = init.apiKeyEnv;
+  }
+  /**
+   * Build a URL under the configured base.
+   *
+   * The path is a hardcoded literal from this file — never anything derived
+   * from a job — and the result is re-checked against the base's origin so a
+   * surprising `baseUrl` (say, one with a `..` path) cannot walk elsewhere.
+   */
+  #endpoint(path) {
+    const base = this.#baseUrl.href.endsWith("/") ? this.#baseUrl.href : `${this.#baseUrl.href}/`;
+    const url = new URL(path, base);
+    if (url.origin !== this.#baseUrl.origin) {
+      throw new Error("computed endpoint left the configured origin");
+    }
+    return url;
+  }
+  #headers() {
+    const headers = {
+      "content-type": "application/json",
+      accept: "application/json"
+    };
+    if (this.#apiKeyEnv !== void 0) {
+      const key = process.env[this.#apiKeyEnv];
+      if (key !== void 0 && key !== "") {
+        headers["authorization"] = `Bearer ${key}`;
+      }
+    }
+    return headers;
+  }
+  async health() {
+    try {
+      const response = await fetch(this.#endpoint("models"), {
+        method: "GET",
+        headers: this.#headers(),
+        redirect: "error",
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!response.ok) {
+        return {
+          healthy: false,
+          models: [],
+          detail: `model list returned HTTP ${String(response.status)}`
+        };
+      }
+      const body = await response.json();
+      return { healthy: true, models: extractModelIds(body) };
+    } catch (error) {
+      return {
+        healthy: false,
+        models: [],
+        detail: describeFetchError(error, this.#baseUrl.origin)
+      };
+    }
+  }
+  async execute(request) {
+    const started = Date.now();
+    const timeout = AbortSignal.timeout(request.timeoutMs);
+    const signal = AbortSignal.any([request.signal, timeout]);
+    try {
+      const response = await fetch(this.#endpoint("chat/completions"), {
+        method: "POST",
+        headers: this.#headers(),
+        // The payload is a JSON string field. Nothing about it is parsed as
+        // configuration, and `model` comes from owner config.
+        body: JSON.stringify({
+          model: request.model,
+          messages: [{ role: "user", content: request.prompt }],
+          stream: false
+        }),
+        redirect: "error",
+        signal
+      });
+      if (response.status === 401 || response.status === 403) {
+        return this.#fail(
+          "unauthorized",
+          "the model server rejected our credentials",
+          false,
+          started
+        );
+      }
+      if (response.status === 404) {
+        return this.#fail(
+          "model-not-found",
+          `the model server does not know "${request.model}"`,
+          false,
+          started
+        );
+      }
+      if (!response.ok) {
+        return this.#fail(
+          "backend-error",
+          `the model server returned HTTP ${String(response.status)}`,
+          response.status >= 500,
+          started
+        );
+      }
+      const text = await readCapped(response, request.maxOutputBytes, signal);
+      if (text === null) {
+        return this.#fail(
+          "output-too-large",
+          `the model produced more than ${String(request.maxOutputBytes)} bytes`,
+          false,
+          started
+        );
+      }
+      const content = extractContent(text);
+      if (content === null) {
+        return this.#fail(
+          "backend-error",
+          "the model server's response was not in OpenAI chat-completion shape",
+          false,
+          started
+        );
+      }
+      return { ok: true, text: content, durationMs: Date.now() - started };
+    } catch (error) {
+      if (request.signal.aborted) {
+        return this.#fail("canceled", "the job was canceled", false, started);
+      }
+      if (isAbort(error)) {
+        return this.#fail(
+          "timeout",
+          `the model did not answer within ${String(request.timeoutMs)}ms`,
+          true,
+          started
+        );
+      }
+      return this.#fail(
+        "backend-unreachable",
+        describeFetchError(error, this.#baseUrl.origin),
+        true,
+        started
+      );
+    }
+  }
+  #fail(code, message, retryable, started) {
+    return {
+      ok: false,
+      code,
+      message,
+      retryable,
+      durationMs: Date.now() - started
+    };
+  }
+};
+async function readCapped(response, maxBytes, signal) {
+  const body = response.body;
+  if (body === null) return "";
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      signal.throwIfAborted();
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return new TextDecoder().decode(concat(chunks, total));
+}
+function concat(chunks, total) {
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+function extractContent(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const choices = parsed.choices;
+  if (!Array.isArray(choices) || choices.length === 0) return null;
+  const message = choices[0].message;
+  if (typeof message !== "object" || message === null) return null;
+  const content = message.content;
+  return typeof content === "string" ? content : null;
+}
+function extractModelIds(body) {
+  if (typeof body !== "object" || body === null) return [];
+  const data = body.data;
+  if (!Array.isArray(data)) return [];
+  return data.map(
+    (entry) => typeof entry === "object" && entry !== null ? entry.id : void 0
+  ).filter((id) => typeof id === "string");
+}
+function isAbort(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+function describeFetchError(error, origin) {
+  const cause = error instanceof Error && "cause" in error && error.cause instanceof Error ? error.cause.message : error instanceof Error ? error.message : "unknown error";
+  return `could not reach the model server at ${origin} (${cause})`;
+}
+
+// src/backends/index.ts
+function createBackend(id, init) {
+  switch (id) {
+    case "openai-http":
+      return new OpenAiHttpBackend(init);
+    case "claude-cli":
+      return new ClaudeCliBackend();
+  }
+}
+var IMPLEMENTED_BACKEND_IDS = BACKEND_IDS;
+
+// src/compose.ts
+function composePrompt(job) {
+  if (job.kind === "llm.generate") {
+    const payload2 = job.payload;
+    return joinSections([systemSection(payload2.system), payload2.prompt]);
+  }
+  const payload = job.payload;
+  const turns = payload.messages.map((message) => `${roleLabel(message.role)}: ${message.content}`).join("\n\n");
+  return joinSections([systemSection(payload.system), turns]);
+}
+function systemSection(system) {
+  if (system === void 0 || system.trim() === "") return void 0;
+  return `System instructions:
+${system}`;
+}
+function roleLabel(role) {
+  switch (role) {
+    case "assistant":
+      return "Assistant";
+    case "system":
+      return "System";
+    default:
+      return "User";
+  }
+}
+function joinSections(sections) {
+  return sections.filter((section) => section !== void 0).join("\n\n");
+}
+
+// src/runner.ts
+var DEFAULT_HEARTBEAT_MS = 1e4;
+var Runner = class {
+  #options;
+  #backends = /* @__PURE__ */ new Map();
+  #active = /* @__PURE__ */ new Map();
+  #now;
+  #capabilities = [];
+  #paused = false;
+  #revoked = false;
+  #stopped = false;
+  #lastError;
+  #completed = 0;
+  #refused = 0;
+  constructor(options) {
+    this.#options = options;
+    this.#now = options.now ?? Date.now;
+  }
+  status() {
+    return {
+      origin: this.#options.client.origin,
+      owner: this.#options.owner,
+      runnerId: this.#options.runnerId,
+      paused: this.#paused,
+      revoked: this.#revoked,
+      activeJobs: this.#active.size,
+      capabilities: [...this.#capabilities],
+      ...this.#lastError === void 0 ? {} : { lastError: this.#lastError },
+      completed: this.#completed,
+      refused: this.#refused
+    };
+  }
+  pause() {
+    this.#paused = true;
+  }
+  resume() {
+    this.#paused = false;
+  }
+  /**
+   * Build the capability matrix: owner config intersected with what is
+   * actually reachable and healthy right now
+   * ({@link MUSTS.CAPABILITY_IS_DETECTED}).
+   *
+   * A configured route whose backend is down simply does not appear. The
+   * daemon then receives no work for it, which is the correct outcome and one
+   * the owner can see in `byollm status`.
+   */
+  async detectCapabilities() {
+    const capabilities = [];
+    for (const route of this.#options.loaded.routes) {
+      const backend = this.#backendFor(route);
+      const health = await backend.health();
+      if (!health.healthy) continue;
+      if (health.models.length > 0 && !modelPresent(health.models, route.model)) {
+        continue;
+      }
+      capabilities.push({
+        kind: route.kind,
+        backendId: route.backendId,
+        backendClass: route.backendClass,
+        model: route.model,
+        offerScope: route.offerScope
+      });
+    }
+    this.#capabilities = capabilities;
+    return capabilities;
+  }
+  #backendFor(route) {
+    const key = `${route.backendKey}:${route.backendId}`;
+    let backend = this.#backends.get(key);
+    if (!backend) {
+      backend = this.#options.backendFactory?.(route) ?? createBackend(route.backendId, {
+        baseUrl: route.baseUrl,
+        apiKeyEnv: route.apiKeyEnv
+      });
+      this.#backends.set(key, backend);
+    }
+    return backend;
+  }
+  #routeFor(kind) {
+    return this.#options.loaded.routes.find((route) => route.kind === kind);
+  }
+  /**
+   * Decide whether this machine will run a claimed job.
+   *
+   * The server already applied its own version of the audience rules, and
+   * that is not what this checks. This is the daemon enforcing against the
+   * server: the local `named` allowlist
+   * ({@link MUSTS.NAMED_LOCAL_ALLOWLIST}), the subscription self-lock, and
+   * the owner's community budgets. A job that fails here is released with
+   * reason `refused`, which the server remembers so it is never offered back.
+   */
+  admit(job) {
+    const route = this.#routeFor(job.kind);
+    if (!route) {
+      return { ok: false, reason: REFUSAL_MESSAGES["no-capability"] };
+    }
+    const match = matchAudience(
+      {
+        owner: job.owner,
+        audience: job.audience,
+        audienceAllow: job.audienceAllow
+      },
+      {
+        owner: this.#options.owner,
+        offerScope: route.offerScope,
+        account: backendDescriptor2(route.backendId).account,
+        // The daemon's own list — the whole point of Rev 1 §B.
+        locallyAllows: this.#options.allowlist.predicateFor(
+          this.#options.client.origin
+        )
+      }
+    );
+    if (!match.ok) {
+      return { ok: false, reason: REFUSAL_MESSAGES[match.refusal] };
+    }
+    if (job.owner !== this.#options.owner) {
+      const decision = this.#options.budgets.check(
+        this.#now(),
+        payloadTextLength({
+          kind: job.kind,
+          payload: job.payload
+        })
+      );
+      if (!decision.ok) return { ok: false, reason: decision.detail };
+    }
+    return { ok: true };
+  }
+  /**
+   * Execute one admitted job.
+   *
+   * Order is load-bearing: the ingress write is awaited *before* the backend
+   * is touched ({@link MUSTS.INGRESS_LOGGED_BEFORE_EXECUTION}), so a job that
+   * hangs the machine still leaves a record of what it was.
+   */
+  async runJob(job) {
+    const route = this.#routeFor(job.kind);
+    if (!route) {
+      return {
+        outcome: "error",
+        code: "no-capability",
+        message: "this machine has no route for that job kind",
+        retryable: false
+      };
+    }
+    const controller = new AbortController();
+    this.#active.set(job.id, controller);
+    const prompt = composePrompt(job);
+    const community = job.owner !== this.#options.owner;
+    const limits = this.#options.loaded.config;
+    await this.#options.ingress.recordPrompt({
+      at: this.#now(),
+      origin: this.#options.client.origin,
+      jobId: job.id,
+      kind: job.kind,
+      audience: job.audience,
+      owner: job.owner,
+      backendId: route.backendId,
+      backendClass: route.backendClass,
+      model: route.model,
+      prompt
+    });
+    if (community) await this.#options.budgets.record(this.#now());
+    try {
+      const backend = this.#backendFor(route);
+      const result = await backend.execute({
+        prompt,
+        model: route.model,
+        // Community jobs run under the owner's tighter ceiling.
+        timeoutMs: community ? Math.min(
+          limits.community.maxWallClockMs,
+          limits.limits.maxWallClockMs
+        ) : limits.limits.maxWallClockMs,
+        maxOutputBytes: community ? Math.min(
+          limits.community.maxOutputBytes,
+          limits.limits.maxOutputBytes
+        ) : limits.limits.maxOutputBytes,
+        signal: controller.signal
+      });
+      const outcome = result.ok ? { outcome: "ok", text: result.text } : result.code === "canceled" ? { outcome: "canceled" } : {
+        outcome: "error",
+        code: result.code,
+        message: result.message,
+        retryable: result.retryable
+      };
+      await this.#options.ingress.recordOutcome({
+        at: this.#now(),
+        jobId: job.id,
+        outcome: outcome.outcome,
+        durationMs: result.durationMs,
+        outputChars: result.ok ? result.text.length : 0,
+        ...result.ok ? {} : { detail: result.message }
+      });
+      this.#completed += 1;
+      this.#options.onEvent?.({
+        type: "finished",
+        jobId: job.id,
+        outcome: outcome.outcome,
+        durationMs: result.durationMs
+      });
+      return outcome;
+    } finally {
+      this.#active.delete(job.id);
+    }
+  }
+  /** Abort a job's in-flight backend call ({@link MUSTS.CANCEL_HONORED}). */
+  cancelJob(jobId) {
+    this.#active.get(jobId)?.abort();
+  }
+  /** Abort everything — revocation, or shutdown. */
+  cancelAll() {
+    for (const controller of this.#active.values()) controller.abort();
+  }
+  /**
+   * Run until stopped.
+   *
+   * Resumable and idempotent by job id: a daemon that dies mid-job loses
+   * nothing, because the server reclaims the lease and offers the job again.
+   */
+  async run(signal) {
+    const heartbeatMs = this.#options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+    while (!signal.aborted && !this.#stopped) {
+      try {
+        await this.tick();
+        this.#lastError = void 0;
+      } catch (error) {
+        this.#lastError = error instanceof Error ? error.message : "unknown error";
+        this.#options.onEvent?.({
+          type: "error",
+          message: this.#lastError
+        });
+        if (error instanceof ClientError && error.kind === "revoked") {
+          this.#revoked = true;
+          this.cancelAll();
+          this.#options.onEvent?.({ type: "revoked" });
+          return;
+        }
+        const backoff = error instanceof ClientError && error.retryAfter !== void 0 ? error.retryAfter * 1e3 : heartbeatMs;
+        await sleep(backoff, signal);
+        continue;
+      }
+      await sleep(heartbeatMs * (0.85 + Math.random() * 0.3), signal);
+    }
+  }
+  /** One heartbeat-and-claim cycle. Exposed so tests can step deterministically. */
+  async tick() {
+    const capabilities = await this.detectCapabilities();
+    const heartbeat = await this.#options.client.heartbeat({
+      runnerId: this.#options.runnerId,
+      daemonVersion: this.#options.daemonVersion,
+      capabilities,
+      activeJobIds: [...this.#active.keys()],
+      paused: this.#paused
+    });
+    this.#options.onEvent?.({
+      type: "heartbeat",
+      capabilities: capabilities.length
+    });
+    if (heartbeat.revoked) {
+      this.#revoked = true;
+      this.cancelAll();
+      this.#options.onEvent?.({ type: "revoked" });
+      this.#stopped = true;
+      return;
+    }
+    for (const jobId of heartbeat.lost) this.cancelJob(jobId);
+    for (const jobId of heartbeat.cancel) this.cancelJob(jobId);
+    if (this.#paused || capabilities.length === 0) return;
+    const free = this.#options.loaded.config.concurrency - this.#active.size;
+    if (free <= 0) return;
+    const { jobs } = await this.#options.client.claim({
+      runnerId: this.#options.runnerId,
+      capabilities,
+      max: free
+    });
+    for (const job of jobs) {
+      void this.#handle(job).catch((error) => {
+        this.#lastError = error instanceof Error ? error.message : "unknown error";
+        this.#options.onEvent?.({ type: "error", message: this.#lastError });
+      });
+    }
+  }
+  async #handle(job) {
+    this.#options.onEvent?.({
+      type: "claimed",
+      jobId: job.id,
+      kind: job.kind
+    });
+    const admission = this.admit(job);
+    if (!admission.ok) {
+      this.#refused += 1;
+      await this.#options.ingress.recordOutcome({
+        at: this.#now(),
+        jobId: job.id,
+        outcome: "refused",
+        detail: admission.reason
+      });
+      this.#options.onEvent?.({
+        type: "refused",
+        jobId: job.id,
+        reason: admission.reason
+      });
+      await this.#safely(
+        () => this.#options.client.release({
+          runnerId: this.#options.runnerId,
+          jobIds: [job.id],
+          reason: "refused"
+        })
+      );
+      return;
+    }
+    const route = this.#routeFor(job.kind);
+    const outcome = await this.runJob(job);
+    await this.#safely(
+      () => this.#options.client.result({
+        runnerId: this.#options.runnerId,
+        jobId: job.id,
+        outcome,
+        model: route?.model ?? "unknown",
+        backendClass: route?.backendClass ?? "http",
+        durationMs: 0
+      })
+    );
+  }
+  /**
+   * Report-and-forget.
+   *
+   * A failed *report* must not crash the loop or re-run the job: the lease
+   * will lapse and the server will offer the work again, which is exactly the
+   * recovery the protocol is built around.
+   */
+  async #safely(action) {
+    try {
+      await action();
+    } catch (error) {
+      this.#lastError = error instanceof Error ? error.message : "unknown error";
+    }
+  }
+  /** Release everything on shutdown, so nothing waits for a lease to lapse. */
+  async shutdown(reason) {
+    this.#stopped = true;
+    const jobIds = [...this.#active.keys()];
+    this.cancelAll();
+    if (jobIds.length === 0) return;
+    await this.#safely(
+      () => this.#options.client.release({
+        runnerId: this.#options.runnerId,
+        jobIds,
+        reason
+      })
+    );
+  }
+};
+function modelPresent(models, wanted) {
+  const target = wanted.toLowerCase();
+  return models.some((model) => {
+    const id = model.toLowerCase();
+    return id === target || id === `${target}:latest` || `${id}:latest` === target;
+  });
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/cli.ts
+var USAGE = `byollm \u2014 run an app's LLM jobs on your own models.
+
+  byollm connect <url>        pair with an app and start running its jobs
+  byollm run [url]            run jobs for a paired app (or all of them)
+  byollm status               what is connected, what is running, what it cost
+  byollm log [--full] [-n N]  every prompt that has run on this machine
+  byollm pause                stop claiming new work
+  byollm resume               start claiming again
+  byollm allow <url> <user>   let someone else's jobs run here (named audience)
+  byollm allow --list         who can currently use this machine
+  byollm disallow <url> <user>
+  byollm forget <url>         drop a pairing
+  byollm backends             what is installed, healthy, and advertised
+
+Config lives in ~/.byollm/config.json. Everything this daemon has ever run is
+in ~/.byollm/ingress.log \u2014 it is yours to read and yours to delete.
+`;
+var defaultIo = {
+  out: (text) => process.stdout.write(text),
+  err: (text) => process.stderr.write(text),
+  confirm: confirmInteractively
+};
+async function runCli(argv, options = {}) {
+  const [command, ...rest] = argv;
+  const paths = options.paths ?? daemonPaths();
+  const io = { ...defaultIo, ...options.io };
+  const signal = options.signal;
+  switch (command) {
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      io.out(USAGE);
+      return 0;
+    case "--version":
+    case "version":
+      io.out(`${DAEMON_VERSION}
+`);
+      return 0;
+    case "connect":
+      return commandConnect(paths, rest, io, signal);
+    case "run":
+      return commandRun(paths, rest, io, signal);
+    case "status":
+      return commandStatus(paths, io);
+    case "log":
+      return commandLog(paths, rest, io);
+    case "pause":
+      return commandPause(paths, true, io);
+    case "resume":
+      return commandPause(paths, false, io);
+    case "allow":
+      return commandAllow(paths, rest, io);
+    case "disallow":
+      return commandDisallow(paths, rest, io);
+    case "forget":
+      return commandForget(paths, rest, io);
+    case "backends":
+      return commandBackends(paths, io);
+    default:
+      io.err(`unknown command: ${command}
+
+${USAGE}`);
+      return 2;
+  }
+}
+async function commandConnect(paths, args, io, signal) {
+  const target = args[0];
+  if (target === void 0) {
+    io.err("usage: byollm connect <url>\n");
+    return 2;
+  }
+  const origin = normalizeOrigin(target);
+  const { loaded, ingress, allowlist, budgets } = await context(paths);
+  for (const problem of loaded.problems) {
+    io.err(`config: ${problem.where}: ${problem.message}
+`);
+  }
+  const client = new ProtocolClient({ origin });
+  const runner = new Runner({
+    client,
+    runnerId: "pending",
+    owner: "pending",
+    daemonVersion: DAEMON_VERSION,
+    loaded,
+    allowlist,
+    budgets,
+    ingress
+  });
+  const capabilities = await runner.detectCapabilities();
+  if (capabilities.length === 0) {
+    io.err(
+      "No backend is reachable, so there is nothing to offer this app yet.\nRun `byollm backends` to see what is configured and what is wrong.\n"
+    );
+    return 1;
+  }
+  io.out(`
+Connecting to ${origin}
+`);
+  const result = await connect({
+    client,
+    daemonVersion: DAEMON_VERSION,
+    label: hostLabel(),
+    capabilities,
+    onCode: (info) => {
+      const minutes = Math.max(
+        1,
+        Math.round((info.expiresAt - Date.now()) / 6e4)
+      );
+      io.out(
+        `
+  Open:  ${info.verificationUrl}
+  Code:  ${info.userCode}      (expires in ${String(minutes)}m)
+
+  waiting for approval\u2026`
+      );
+    },
+    onPoll: () => {
+      io.out(".");
+    },
+    ...signal === void 0 ? {} : { signal }
+  });
+  if (!result.ok) {
+    io.out(`
+
+  ${result.message}
+`);
+    return 1;
+  }
+  const pairings = new Pairings(paths.pairings);
+  await pairings.load();
+  await pairings.put(result.pairing);
+  io.out(
+    ` paired as ${result.pairing.ownerLabel ?? result.pairing.owner}
+
+Now running jobs for ${origin}. Ctrl-C to stop.
+
+`
+  );
+  return runLoop(paths, [result.pairing.origin], io, signal);
+}
+async function commandRun(paths, args, io, signal) {
+  const pairings = new Pairings(paths.pairings);
+  await pairings.load();
+  const target = args[0];
+  const origins = target === void 0 ? pairings.list().map((pairing) => pairing.origin) : [normalizeOrigin(target)];
+  if (origins.length === 0) {
+    io.err("No apps are paired yet. Run `byollm connect <url>` first.\n");
+    return 2;
+  }
+  return runLoop(paths, origins, io, signal);
+}
+async function runLoop(paths, origins, io, signal) {
+  const { loaded, ingress, allowlist, budgets } = await context(paths);
+  const pairings = new Pairings(paths.pairings);
+  await pairings.load();
+  const controller = new AbortController();
+  signal?.addEventListener(
+    "abort",
+    () => {
+      controller.abort();
+    },
+    { once: true }
+  );
+  const runners = [];
+  for (const origin of origins) {
+    const pairing = pairings.get(origin);
+    if (!pairing) {
+      io.err(`not paired with ${origin}
+`);
+      continue;
+    }
+    const runner = new Runner({
+      client: new ProtocolClient({ origin, token: pairing.token }),
+      runnerId: pairing.runnerId,
+      owner: pairing.owner,
+      daemonVersion: DAEMON_VERSION,
+      loaded,
+      allowlist,
+      budgets,
+      ingress,
+      onEvent: (event) => {
+        report(origin, event, io);
+      }
+    });
+    runners.push(runner);
+  }
+  if (runners.length === 0) return 2;
+  if (signal === void 0) {
+    const stop = () => {
+      controller.abort();
+      void Promise.all(
+        runners.map((runner) => runner.shutdown("shutdown"))
+      ).then(() => process.exit(0));
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  }
+  await ingress.applyRetention(Date.now());
+  await Promise.all(runners.map((runner) => runner.run(controller.signal)));
+  await Promise.all(runners.map((runner) => runner.shutdown("shutdown")));
+  return 0;
+}
+function report(origin, event, io) {
+  const at = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+  const host = new URL(origin).host;
+  switch (event.type) {
+    case "claimed":
+      io.out(`${at} ${host} claimed ${event.kind} ${event.jobId}
+`);
+      break;
+    case "finished":
+      io.out(
+        `${at} ${host} ${event.outcome} ${event.jobId} (${String(event.durationMs)}ms)
+`
+      );
+      break;
+    case "refused":
+      io.out(
+        `${at} ${host} refused ${event.jobId}: ${stripControlChars(event.reason)}
+`
+      );
+      break;
+    case "revoked":
+      io.out(`${at} ${host} this runner was revoked. Stopping.
+`);
+      break;
+    case "error":
+      io.err(`${at} ${host} ${stripControlChars(event.message)}
+`);
+      break;
+    case "heartbeat":
+      break;
+  }
+}
+async function commandStatus(paths, io) {
+  const { loaded, ingress, allowlist, budgets } = await context(paths);
+  const pairings = new Pairings(paths.pairings);
+  await pairings.load();
+  const paused = await isPaused(paths);
+  const now = Date.now();
+  io.out(`byollm ${DAEMON_VERSION}
+`);
+  io.out(`state: ${paused ? "PAUSED" : "running"}
+
+`);
+  io.out("paired apps\n");
+  const list = pairings.list();
+  if (list.length === 0) {
+    io.out("  (none \u2014 run `byollm connect <url>`)\n");
+  }
+  for (const pairing of list) {
+    io.out(`  ${pairing.origin}  as ${pairing.ownerLabel ?? pairing.owner}
+`);
+  }
+  io.out("\nroutes\n");
+  if (loaded.routes.length === 0) {
+    io.out("  (none configured)\n");
+  }
+  for (const route of loaded.routes) {
+    io.out(
+      `  ${route.kind.padEnd(14)} ${route.backendId}:${route.model}  offered to: ${route.offerScope}
+`
+    );
+  }
+  for (const problem of loaded.problems) {
+    io.out(`  ! ${problem.where}: ${problem.message}
+`);
+  }
+  const allowed = allowlist.list();
+  io.out("\nwho can use this machine\n");
+  io.out(`  you, always
+`);
+  if (allowed.length === 0) {
+    io.out("  nobody else\n");
+  }
+  for (const entry of allowed) {
+    io.out(
+      `  ${entry.owner} on ${entry.origin}${entry.note === void 0 ? "" : ` (${stripControlChars(entry.note)})`}
+`
+    );
+  }
+  const usage = budgets.usage(now);
+  io.out("\ncommunity work done for others\n");
+  io.out(
+    `  ${String(usage.hour)} in the last hour (cap ${String(usage.limits.maxJobsPerHour)}), ${String(usage.day)} today (cap ${String(usage.limits.maxJobsPerDay)})
+`
+  );
+  const entries = await ingress.read();
+  const prompts = entries.filter((entry) => entry.type === "prompt");
+  const outcomes = entries.filter((entry) => entry.type === "outcome");
+  io.out("\nthis machine has run\n");
+  io.out(
+    `  ${String(prompts.length)} prompts, ${String(outcomes.filter((o) => o.outcome === "ok").length)} ok, ${String(outcomes.filter((o) => o.outcome === "error").length)} failed, ${String(outcomes.filter((o) => o.outcome === "refused").length)} refused
+`
+  );
+  io.out(
+    `  full log: ${paths.ingressLog}  (community prompts kept ${String(loaded.config.ingress.communityPromptDays)} days, then hashed)
+`
+  );
+  return 0;
+}
+async function commandLog(paths, args, io) {
+  const full = args.includes("--full");
+  const nIndex = args.findIndex((arg) => arg === "-n" || arg === "--lines");
+  const limit = nIndex === -1 ? 20 : Math.max(1, Number(args[nIndex + 1] ?? "20") || 20);
+  const { ingress } = await context(paths);
+  const entries = await ingress.read();
+  const shown = entries.slice(-limit);
+  if (shown.length === 0) {
+    io.out("nothing has run on this machine yet\n");
+    return 0;
+  }
+  for (const entry of shown) {
+    const at = new Date(entry.at).toISOString().replace("T", " ").slice(0, 19);
+    if (entry.type === "outcome") {
+      io.out(
+        `${at}  ${entry.outcome.padEnd(8)} ${entry.jobId}` + (entry.durationMs === void 0 ? "" : ` ${String(entry.durationMs)}ms`) + `${entry.detail === void 0 ? "" : `  ${stripControlChars(entry.detail)}`}
+`
+      );
+      continue;
+    }
+    io.out(
+      `${at}  ${entry.audience.padEnd(7)} ${entry.kind} via ${entry.backendId}:${entry.model}  for ${entry.owner} @ ${new URL(entry.origin).host}
+`
+    );
+    if (entry.prompt === void 0) {
+      io.out(
+        `           prompt not retained (${String(entry.promptChars)} chars, sha256 ${entry.promptHash.slice(0, 16)}\u2026)
+`
+      );
+    } else if (full) {
+      io.out(`${indent(stripControlChars(entry.prompt))}
+`);
+    } else {
+      const firstLine2 = entry.prompt.split("\n")[0] ?? "";
+      io.out(
+        `           ${stripControlChars(firstLine2.slice(0, 90))}${entry.prompt.length > 90 ? "\u2026" : ""}
+`
+      );
+    }
+  }
+  if (!full) {
+    io.out(`
+(${String(entries.length)} entries; --full for whole prompts)
+`);
+  }
+  return 0;
+}
+function indent(text) {
+  return text.split("\n").map((line) => `           ${line}`).join("\n");
+}
+async function commandPause(paths, pause, io) {
+  await mkdir5(paths.root, { recursive: true });
+  if (pause) {
+    await writeFile5(paths.pauseFlag, `${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+    io.out(
+      "paused \u2014 no new work will be claimed. `byollm resume` to start again.\n"
+    );
+  } else {
+    await rm2(paths.pauseFlag, { force: true });
+    io.out("resumed\n");
+  }
+  return 0;
+}
+async function isPaused(paths) {
+  try {
+    await stat(paths.pauseFlag);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function commandAllow(paths, args, io) {
+  const allowlist = new Allowlist(paths.allowlist);
+  await allowlist.load();
+  if (args[0] === "--list" || args.length === 0) {
+    const entries = allowlist.list();
+    if (entries.length === 0) {
+      io.out(
+        "Nobody but you can run work on this machine.\n`byollm allow <app-url> <user-id>` to change that.\n"
+      );
+      return 0;
+    }
+    for (const entry of entries) {
+      io.out(
+        `${entry.owner}  on ${entry.origin}${entry.note === void 0 ? "" : `  (${stripControlChars(entry.note)})`}
+`
+      );
+    }
+    return 0;
+  }
+  const [rawOrigin, owner, ...noteParts] = args;
+  if (rawOrigin === void 0 || owner === void 0) {
+    io.err("usage: byollm allow <app-url> <user-id> [note]\n");
+    return 2;
+  }
+  const origin = normalizeOrigin(rawOrigin);
+  const confirmed = await io.confirm(
+    `
+This lets jobs belonging to "${owner}" on ${origin} run on this machine,
+using your hardware and electricity, whenever your daemon is online.
+Your subscription-backed models are never included \u2014 those stay yours alone.
+
+Allow ${owner} to use this machine?`
+  );
+  if (!confirmed) {
+    io.out("nothing changed\n");
+    return 0;
+  }
+  await allowlist.add(
+    {
+      origin,
+      owner,
+      ...noteParts.length > 0 ? { note: noteParts.join(" ") } : {}
+    },
+    Date.now()
+  );
+  io.out(`allowed ${owner} on ${origin}
+`);
+  return 0;
+}
+async function commandDisallow(paths, args, io) {
+  const [rawOrigin, owner] = args;
+  if (rawOrigin === void 0 || owner === void 0) {
+    io.err("usage: byollm disallow <app-url> <user-id>\n");
+    return 2;
+  }
+  const allowlist = new Allowlist(paths.allowlist);
+  await allowlist.load();
+  const removed = await allowlist.remove(normalizeOrigin(rawOrigin), owner);
+  io.out(
+    removed ? `${owner} can no longer use this machine
+` : `${owner} was not on the list \u2014 nothing changed
+`
+  );
+  return 0;
+}
+async function commandForget(paths, args, io) {
+  const target = args[0];
+  if (target === void 0) {
+    io.err("usage: byollm forget <app-url>\n");
+    return 2;
+  }
+  const pairings = new Pairings(paths.pairings);
+  await pairings.load();
+  const removed = await pairings.remove(normalizeOrigin(target));
+  io.out(
+    removed ? `forgot ${normalizeOrigin(target)} \u2014 the app may still list this runner until you revoke it there too
+` : `not paired with ${normalizeOrigin(target)}
+`
+  );
+  return 0;
+}
+async function commandBackends(paths, io) {
+  const { loaded, ingress, allowlist, budgets } = await context(paths);
+  const runner = new Runner({
+    client: new ProtocolClient({ origin: "https://unused.invalid" }),
+    runnerId: "local",
+    owner: "local",
+    daemonVersion: DAEMON_VERSION,
+    loaded,
+    allowlist,
+    budgets,
+    ingress
+  });
+  const advertised = await runner.detectCapabilities();
+  const advertisedKinds = new Set(advertised.map((c) => c.kind));
+  io.out("configured routes\n");
+  for (const route of loaded.routes) {
+    const ok = advertisedKinds.has(route.kind);
+    io.out(
+      `  ${ok ? "\u2713" : "\u2717"} ${route.kind.padEnd(14)} ${route.backendId}:${route.model}${route.baseUrl === void 0 ? "" : ` @ ${route.baseUrl}`}
+`
+    );
+  }
+  for (const problem of loaded.problems) {
+    io.out(`  ! ${problem.where}: ${problem.message}
+`);
+  }
+  io.out(
+    `
+${String(advertised.length)} of ${String(loaded.routes.length)} routes are healthy and will be advertised.
+A route that is not healthy is never offered to an app \u2014 the daemon does
+not advertise what it cannot actually run.
+`
+  );
+  return advertised.length === 0 ? 1 : 0;
+}
+async function context(paths) {
+  const loaded = await loadConfig(paths.config);
+  const ingress = new IngressLog({
+    path: paths.ingressLog,
+    communityPromptDays: loaded.config.ingress.communityPromptDays,
+    keepSelfPrompts: loaded.config.ingress.keepSelfPrompts
+  });
+  const allowlist = new Allowlist(paths.allowlist);
+  await allowlist.load();
+  const budgets = new Budgets(paths.budgets, loaded.config.community);
+  await budgets.load(Date.now());
+  return { loaded, ingress, allowlist, budgets };
+}
+async function confirmInteractively(question) {
+  if (!process.stdin.isTTY) {
+    process.stderr.write(
+      "refusing to widen access without an interactive confirmation\n"
+    );
+    return false;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${question} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+function hostLabel() {
+  const override = process.env["BYOLLM_LABEL"];
+  if (override !== void 0 && override !== "") return override.slice(0, 120);
+  try {
+    return `${userInfo().username}@${hostname()}`.slice(0, 120);
+  } catch {
+    return hostname().slice(0, 120);
+  }
+}
+async function main(argv) {
+  try {
+    return await runCli(argv);
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof ClientError || error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 1;
+  }
+}
+
+// src/index.ts
+var DAEMON_VERSION = "0.1.0-alpha.0";
+
+export {
+  Allowlist,
+  normalizeOrigin,
+  Budgets,
+  ClientError,
+  ProtocolClient,
+  checkBaseUrl,
+  BASE_URL_REFUSAL_MESSAGES,
+  DaemonConfig,
+  DEFAULT_CONFIG,
+  loadConfig,
+  resolveConfig,
+  connect,
+  currentPlatform,
+  IngressLog,
+  hashText,
+  stripControlChars,
+  Pairings,
+  daemonPaths,
+  defaultRoot,
+  childEnv,
+  claudeArgv,
+  ClaudeCliBackend,
+  OpenAiHttpBackend,
+  createBackend,
+  IMPLEMENTED_BACKEND_IDS,
+  composePrompt,
+  Runner,
+  DAEMON_VERSION,
+  runCli,
+  main
+};
+//# sourceMappingURL=chunk-S5WHDSUF.js.map