jevprune 0.1.0

package/dist/cli.js

@@ -0,0 +1,2969 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { realpathSync } from "fs";
+import { pathToFileURL } from "url";
+import { parseArgs } from "util";
+
+// src/config.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join, resolve } from "path";
+
+// src/core/errors.ts
+var JevCoreError = class extends Error {
+  name = "JevCoreError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+var JevConfigError = class extends JevCoreError {
+  name = "JevConfigError";
+};
+var JevInputError = class extends JevCoreError {
+  name = "JevInputError";
+};
+var JevBudgetError = class extends JevCoreError {
+  name = "JevBudgetError";
+};
+var JevRequestError = class extends JevCoreError {
+  name = "JevRequestError";
+  status;
+  retryable;
+  requestId;
+  constructor(message, details) {
+    super(message, { cause: details.cause });
+    this.status = details.status;
+    this.retryable = details.retryable;
+    this.requestId = details.requestId;
+  }
+};
+var JevTimeoutError = class extends JevCoreError {
+  name = "JevTimeoutError";
+  timeoutMs;
+  constructor(timeoutMs, message, options) {
+    super(message ?? `Jev request exceeded ${String(timeoutMs)} ms`, options);
+    this.timeoutMs = timeoutMs;
+  }
+};
+var JevAbortError = class extends JevCoreError {
+  name = "JevAbortError";
+  constructor(message = "Jev request aborted", options) {
+    super(message, options);
+  }
+};
+var JevResponseError = class extends JevCoreError {
+  name = "JevResponseError";
+};
+function describeError(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return String(error);
+}
+
+// node_modules/.pnpm/@typesafe-ai+sdk@0.6.0/node_modules/@typesafe-ai/sdk/dist/index.mjs
+var requestIdFrom = (headers) => headers.get("x-typesafe-request-id") ?? void 0;
+var APIPromise = class APIPromise2 extends Promise {
+  #responsePromise;
+  #parseResponse;
+  #parsed;
+  constructor(responsePromise, parseResponse) {
+    super((resolve2) => resolve2(void 0));
+    this.#responsePromise = responsePromise;
+    this.#parseResponse = parseResponse;
+  }
+  /**
+  * Resolves to the raw `Response` without parsing the body. SDK requests buffer the full
+  * body under the request timeout before handoff; reading it afterwards is caller-owned.
+  * The caller owns the body; don't also `await` the parsed result on the same promise.
+  */
+  asResponse() {
+    return this.#responsePromise;
+  }
+  /** Return the parsed result, HTTP response, and request ID. */
+  async withResponse() {
+    const [data, response] = await Promise.all([this.#parse(), this.#responsePromise]);
+    return {
+      data,
+      response,
+      requestId: requestIdFrom(response.headers)
+    };
+  }
+  /** Transform the parsed result, sharing the HTTP response and a single body parse. */
+  map(fn) {
+    return new APIPromise2(this.#responsePromise, () => this.#parse().then(fn));
+  }
+  #parse() {
+    this.#parsed ??= this.#responsePromise.then(this.#parseResponse);
+    return this.#parsed;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#parse().finally(onfinally);
+  }
+};
+var ENV = {
+  /** Required API key; used when `apiKey` is omitted. */
+  apiKey: "TYPESAFE_API_KEY",
+  /** API root; defaults to `https://api.typesafe.ai`. */
+  baseURL: "TYPESAFE_BASE_URL",
+  /** Default model name; defaults to `jev-latest`. */
+  defaultModel: "TYPESAFE_DEFAULT_MODEL",
+  /** Log level; defaults to `warn`. */
+  logLevel: "TYPESAFE_LOG_LEVEL"
+};
+var readEnv = (name) => {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  return process.env[name]?.trim() || void 0;
+};
+var fromCodeOrEnv = (fromCode, envVar) => fromCode ?? readEnv(envVar);
+var range = (from, to) => Array.from({ length: to - from }, (_, i) => from + i);
+var DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  backoffInitialMs: 500,
+  backoffMaxMs: 5e3,
+  backoffJitter: 0.25,
+  /** HTTP 408, 429, and 5xx responses. */
+  httpStatuses: /* @__PURE__ */ new Set([
+    408,
+    429,
+    ...range(500, 600)
+  ]),
+  respectRetryAfter: true,
+  /** Maximum server retry delay before falling back to backoff. */
+  maxRetryAfterMs: 6e4,
+  apiConnectionError: true,
+  apiTimeoutError: true
+};
+DEFAULT_RETRY_POLICY.maxRetries;
+var isRetryableStatus = (status, policy = DEFAULT_RETRY_POLICY) => policy.httpStatuses.has(status);
+var parseRetryAfter = (headers, now = Date.now()) => {
+  const ms = Number(headers.get("retry-after-ms"));
+  if (headers.has("retry-after-ms") && Number.isFinite(ms) && ms >= 0) return ms;
+  const raw = headers.get("retry-after");
+  if (raw === null) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return seconds >= 0 ? seconds * 1e3 : void 0;
+  const date = Date.parse(raw);
+  if (!Number.isNaN(date)) return Math.max(0, date - now);
+};
+var retryDelayMs = (attempt, headers, policy = DEFAULT_RETRY_POLICY, random = Math.random) => {
+  if (policy.respectRetryAfter && headers !== void 0) {
+    const retryAfter = parseRetryAfter(headers);
+    if (retryAfter !== void 0 && retryAfter <= policy.maxRetryAfterMs) return retryAfter;
+  }
+  const exponential = Math.min(policy.backoffInitialMs * 2 ** attempt, policy.backoffMaxMs);
+  return Math.round(exponential * (1 - random() * policy.backoffJitter));
+};
+var sleep = (ms, signal) => new Promise((resolve2, reject) => {
+  if (signal?.aborted) return reject(signal.reason);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason);
+  };
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve2();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var TypeSafeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var isRecord = (value) => typeof value === "object" && value !== null;
+var extractMessage = (body) => {
+  if (typeof body === "string") return body || void 0;
+  if (!isRecord(body)) return void 0;
+  const { error, message, detail } = body;
+  if (typeof error === "string") return error;
+  if (isRecord(error) && typeof error.message === "string") return error.message;
+  if (typeof message === "string") return message;
+  if (typeof detail === "string") return detail;
+  if (isRecord(detail) && typeof detail.message === "string") return detail.message;
+  if (Array.isArray(detail)) return describeValidationErrors(detail);
+};
+var describeValidationErrors = (errors) => {
+  const parts = errors.flatMap((e) => {
+    if (!isRecord(e) || typeof e.msg !== "string") return [];
+    const loc = Array.isArray(e.loc) ? e.loc.filter((x) => x !== "body").join(".") : "";
+    return [loc ? `${loc}: ${e.msg}` : e.msg];
+  });
+  return parts.length > 0 ? parts.join("; ") : void 0;
+};
+var MAX_RAW_BODY_IN_MESSAGE = 200;
+var APIError = class APIError2 extends TypeSafeError {
+  /** HTTP response status code. */
+  status;
+  /** HTTP response headers. */
+  headers;
+  /** Parsed JSON, response text, or `undefined` for an empty body. */
+  body;
+  /** Request ID from `x-typesafe-request-id`, or `undefined` when absent. */
+  requestId;
+  constructor(status, body, headers, message) {
+    super(message ?? APIError2.describe(status, body));
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.requestId = requestIdFrom(headers);
+  }
+  static describe(status, body) {
+    const detail = extractMessage(body);
+    if (detail) return `${status} ${detail}`;
+    if (body === void 0) return `${status} status code (no body)`;
+    const raw = typeof body === "string" ? body : JSON.stringify(body);
+    return `${status} ${raw.length > MAX_RAW_BODY_IN_MESSAGE ? `${raw.slice(0, MAX_RAW_BODY_IN_MESSAGE)}\u2026` : raw}`;
+  }
+  /** Create the error subclass for an HTTP status code. */
+  static fromResponse(status, body, headers) {
+    if (status === 400) return new BadRequestError(status, body, headers);
+    if (status === 401) return new AuthenticationError(status, body, headers);
+    if (status === 403) return new PermissionDeniedError(status, body, headers);
+    if (status === 404) return new NotFoundError(status, body, headers);
+    if (status === 422) return new UnprocessableEntityError(status, body, headers);
+    if (status === 429) return new RateLimitError(status, body, headers);
+    if (status >= 500) return new InternalServerError(status, body, headers);
+    return new APIError2(status, body, headers);
+  }
+};
+var BadRequestError = class extends APIError {
+};
+var AuthenticationError = class extends APIError {
+};
+var PermissionDeniedError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+var UnprocessableEntityError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+  /** Server retry delay in milliseconds, or `undefined` when absent or invalid. */
+  retryAfterMs = parseRetryAfter(this.headers);
+};
+var InternalServerError = class extends APIError {
+};
+var APIConnectionError = class extends TypeSafeError {
+  constructor(message = "Connection error.", options) {
+    super(message, options);
+  }
+};
+var APITimeoutError = class extends APIConnectionError {
+  /** Configured timeout in milliseconds. */
+  timeoutMs;
+  constructor(timeoutMs, options) {
+    super(`Request timed out after ${timeoutMs}ms.`, options);
+    this.timeoutMs = timeoutMs;
+  }
+};
+var APIUserAbortError = class extends TypeSafeError {
+  constructor(message = "Request was aborted.", options) {
+    super(message, options);
+  }
+};
+var LOG_LEVELS = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "off"
+];
+var DEFAULT_LOG_LEVEL = "warn";
+var isLogLevel = (value) => LOG_LEVELS.includes(value);
+var parseLogLevel = (value, source) => {
+  if (isLogLevel(value)) return value;
+  throw new TypeSafeError(`Invalid log level "${value}" from ${source}. Expected one of: ${LOG_LEVELS.join(", ")}.`);
+};
+var PREFIX = "[typesafe-sdk]";
+var consoleLogger = {
+  debug: (message, ...args) => console.debug(`${PREFIX} ${message}`, ...args),
+  info: (message, ...args) => console.info(`${PREFIX} ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`${PREFIX} ${message}`, ...args),
+  error: (message, ...args) => console.error(`${PREFIX} ${message}`, ...args)
+};
+var RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  off: 4
+};
+var drop = () => {
+};
+var withLevel = (sink, level) => {
+  const enabled = (at) => RANK[at] >= RANK[level];
+  return {
+    debug: enabled("debug") ? (message, ...args) => sink.debug(message, ...args) : drop,
+    info: enabled("info") ? (message, ...args) => sink.info(message, ...args) : drop,
+    warn: enabled("warn") ? (message, ...args) => sink.warn(message, ...args) : drop,
+    error: enabled("error") ? (message, ...args) => sink.error(message, ...args) : drop
+  };
+};
+var KEY_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authorization",
+  "x-api-key"
+]);
+var OPAQUE_HEADERS = /* @__PURE__ */ new Set(["cookie", "set-cookie"]);
+var redactKey = (value) => {
+  const [scheme, secret] = value.includes(" ") ? value.split(/\s+/, 2) : [void 0, value];
+  const tail = secret && secret.length > 8 ? secret.slice(-4) : "";
+  return `${scheme ? `${scheme} ` : ""}***${tail}`;
+};
+var redact = (name, value) => {
+  const lower = name.toLowerCase();
+  if (KEY_HEADERS.has(lower)) return redactKey(value);
+  if (OPAQUE_HEADERS.has(lower)) return "***";
+  return value;
+};
+var redactHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, redact(name, value)]));
+var noul = (instructions = null, criteria) => ({
+  type: "noul",
+  instructions,
+  criteria
+});
+var choice = (instructions, criteria) => {
+  if (Array.isArray(criteria)) throw new TypeSafeError("Choice criteria must be a map of labels to descriptions, not a list.");
+  return {
+    type: "choice",
+    instructions,
+    criteria
+  };
+};
+var validateQuestions = (questions) => {
+  if (Object.keys(questions).length === 0) throw new TypeSafeError("At least one question is required.");
+  for (const [name, question] of Object.entries(questions)) {
+    if (question.type !== "score") continue;
+    if (!Array.isArray(question.criteria)) throw new TypeSafeError(`Score question "${name}" has criteria that are not a list; score criteria must be a list of descriptions indexed by score from zero.`);
+    if (question.criteria.length < 2) throw new TypeSafeError(`Score question "${name}" has ${question.criteria.length} criteria; at least two scores are required.`);
+  }
+};
+var Models = class {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  /** List the models available to the account. */
+  list(options = {}) {
+    return this.#transport.request("GET", "/v1/models", options).map(unwrapModels);
+  }
+};
+var unwrapModels = (wire) => {
+  if (Array.isArray(wire?.models)) return wire.models;
+  throw new TypeSafeError("Unexpected response shape from GET /v1/models; expected { models: [...] }.");
+};
+var g = globalThis;
+var isBrowser = () => typeof g.window !== "undefined" && typeof g.window.document !== "undefined" && typeof g.navigator !== "undefined";
+var describeRuntime = () => {
+  const platform = g.process?.platform && g.process?.arch ? ` (${g.process.platform}; ${g.process.arch})` : "";
+  if (g.Bun?.version) return `bun/${g.Bun.version}${platform}`;
+  if (g.Deno?.version?.deno) return `deno/${g.Deno.version.deno}${platform}`;
+  if (g.EdgeRuntime !== void 0) return "vercel-edge";
+  if (g.navigator?.userAgent === "Cloudflare-Workers") return "cloudflare-workers";
+  if (g.process?.versions?.node) return `node/${g.process.versions.node}${platform}`;
+  if (isBrowser()) return "browser";
+  return "unknown";
+};
+var VERSION = "0.6.0";
+var missingApiKey = () => {
+  throw new TypeSafeError(`No API key was provided. Pass \`apiKey\` to the TypeSafeClient constructor or set the ${ENV.apiKey} environment variable.`);
+};
+var missingFetch = () => {
+  throw new TypeSafeError("No global `fetch` is available in this runtime. Pass a `fetch` implementation to the TypeSafeClient constructor.");
+};
+var refuseBrowser = () => {
+  throw new TypeSafeError("TypeSafeClient is running in a browser, which would expose your API key to anyone using the page. Call the API from a server instead, or pass `dangerouslyAllowBrowser: true` if you understand the risk.");
+};
+var defaultFetch = (input, init) => globalThis.fetch(input, init);
+var assertNonNegativeInteger = (name, value) => {
+  if (!Number.isInteger(value) || value < 0) throw new TypeSafeError(`\`${name}\` must be a non-negative integer, got ${String(value)}.`);
+  return value;
+};
+var assertPositiveMs = (name, value) => {
+  if (!Number.isFinite(value) || value <= 0) throw new TypeSafeError(`\`${name}\` must be a positive number of milliseconds, got ${String(value)}.`);
+  return value;
+};
+var assertNonNegativeMs = (name, value) => {
+  if (!Number.isFinite(value) || value < 0) throw new TypeSafeError(`\`${name}\` must be a non-negative number of milliseconds, got ${String(value)}.`);
+  return value;
+};
+var assertFraction = (name, value) => {
+  if (!Number.isFinite(value) || value < 0 || value > 1) throw new TypeSafeError(`\`${name}\` must be between 0 and 1, got ${String(value)}.`);
+  return value;
+};
+var assertStatusSet = (name, statuses) => {
+  for (const status of statuses) if (!Number.isInteger(status) || status < 100 || status > 999) throw new TypeSafeError(`\`${name}\` must contain HTTP status codes, got ${String(status)}.`);
+  return statuses;
+};
+var resolveRetryPolicy = (base, overrides) => {
+  const o = overrides ?? {};
+  return {
+    maxRetries: o.maxRetries === void 0 ? base.maxRetries : assertNonNegativeInteger("retry.maxRetries", o.maxRetries),
+    backoffInitialMs: o.backoffInitialMs === void 0 ? base.backoffInitialMs : assertNonNegativeMs("retry.backoffInitialMs", o.backoffInitialMs),
+    backoffMaxMs: o.backoffMaxMs === void 0 ? base.backoffMaxMs : assertNonNegativeMs("retry.backoffMaxMs", o.backoffMaxMs),
+    backoffJitter: o.backoffJitter === void 0 ? base.backoffJitter : assertFraction("retry.backoffJitter", o.backoffJitter),
+    httpStatuses: new Set(o.httpStatuses === void 0 ? base.httpStatuses : assertStatusSet("retry.httpStatuses", o.httpStatuses)),
+    respectRetryAfter: o.respectRetryAfter ?? base.respectRetryAfter,
+    maxRetryAfterMs: o.maxRetryAfterMs === void 0 ? base.maxRetryAfterMs : assertNonNegativeMs("retry.maxRetryAfterMs", o.maxRetryAfterMs),
+    apiConnectionError: o.apiConnectionError ?? base.apiConnectionError,
+    apiTimeoutError: o.apiTimeoutError ?? base.apiTimeoutError
+  };
+};
+var isRetryableError = (err, policy) => {
+  if (err instanceof APITimeoutError) return policy.apiTimeoutError;
+  if (err instanceof APIConnectionError) return policy.apiConnectionError;
+  return false;
+};
+var resolveLogLevel = (fromCode) => {
+  if (fromCode !== void 0) return parseLogLevel(fromCode, "the `logLevel` option");
+  const fromEnv = readEnv(ENV.logLevel);
+  if (fromEnv !== void 0) return parseLogLevel(fromEnv, ENV.logLevel);
+  return DEFAULT_LOG_LEVEL;
+};
+var stripTrailingSlashes = (url) => url.replace(/\/+$/, "");
+var mergeHeaders = (...sources) => {
+  const entries = /* @__PURE__ */ new Map();
+  for (const source of sources) for (const [name, value] of Object.entries(source)) if (value === void 0) entries.delete(name.toLowerCase());
+  else entries.set(name.toLowerCase(), [name, value]);
+  return Object.fromEntries(entries.values());
+};
+var bufferResponse = async (response, signal) => {
+  const reader = response.clone().body?.getReader();
+  if (!reader) return;
+  const cancel = () => {
+    reader.cancel(signal.reason).catch(() => {
+    });
+    response.body?.cancel(signal.reason).catch(() => {
+    });
+  };
+  signal.addEventListener("abort", cancel, { once: true });
+  try {
+    if (signal.aborted) cancel();
+    signal.throwIfAborted();
+    while (!(await reader.read()).done) signal.throwIfAborted();
+    signal.throwIfAborted();
+  } finally {
+    signal.removeEventListener("abort", cancel);
+    reader.releaseLock();
+  }
+};
+var RUNTIME = describeRuntime();
+var TypeSafeClient = class {
+  /** API key excluded from serialization and public properties. */
+  #apiKey;
+  /** API root with trailing slashes removed. */
+  baseURL;
+  /** Model used when a request omits `model`. */
+  defaultModel;
+  /** Configured log verbosity. */
+  logLevel;
+  /** The configured logger, filtered to `logLevel`. */
+  logger;
+  /** Retry settings with constructor overrides applied. */
+  retry;
+  /** Timeout per attempt in milliseconds. */
+  timeout;
+  /** Additional headers sent with each request. */
+  defaultHeaders;
+  /** HTTP fetch implementation. */
+  fetch;
+  /** The models available to the account. */
+  models;
+  #requestCount = 0;
+  /**
+  * Create a client for the TypeSafe AI API.
+  *
+  * Explicit options take precedence over environment variables, then SDK defaults.
+  * Empty or whitespace-only environment values are ignored.
+  *
+  * @throws {TypeSafeError} The API key is missing, configuration is invalid, or the runtime is unsupported.
+  */
+  constructor(config = {}) {
+    if (isBrowser() && !config.dangerouslyAllowBrowser) refuseBrowser();
+    this.#apiKey = fromCodeOrEnv(config.apiKey, ENV.apiKey) ?? missingApiKey();
+    this.baseURL = stripTrailingSlashes(fromCodeOrEnv(config.baseURL, ENV.baseURL) ?? "https://api.typesafe.ai");
+    this.defaultModel = fromCodeOrEnv(config.defaultModel, ENV.defaultModel) ?? "jev-latest";
+    this.logLevel = resolveLogLevel(config.logLevel);
+    this.logger = withLevel(config.logger ?? consoleLogger, this.logLevel);
+    this.retry = resolveRetryPolicy(DEFAULT_RETRY_POLICY, config.retry);
+    this.timeout = assertPositiveMs("timeout", config.timeout ?? 1e4);
+    this.defaultHeaders = { ...config.defaultHeaders };
+    if (config.fetch === void 0 && typeof globalThis.fetch !== "function") missingFetch();
+    this.fetch = config.fetch ?? defaultFetch;
+    const transport = {
+      request: (method, path, options) => this.#request(method, path, options),
+      defaultModel: this.defaultModel
+    };
+    this.models = new Models(transport);
+  }
+  /**
+  * Answer named questions about text or structured state.
+  *
+  * @param request - State, questions, and an optional model override.
+  * @param options - Per-call timeout, retry, headers, and cancellation settings.
+  * @returns Answers typed by question name and criteria, with model and token usage.
+  * @throws {TypeSafeError} Questions are empty, or score criteria are not a list of at least two entries.
+  * @throws {APIError} The server returns a non-2xx response after retries.
+  * @throws {APIConnectionError} The request cannot connect or times out after retries.
+  * @throws {APIUserAbortError} The caller aborts the request.
+  *
+  * @example
+  * ```ts
+  * const { answers } = await client.systemOne({
+  *   state: "I was charged twice. Please help.",
+  *   questions: { billing: noul("Is this about billing?") },
+  * });
+  * console.log(answers.billing.noul);
+  * ```
+  */
+  systemOne(request, options = {}) {
+    validateQuestions(request.questions);
+    const body = {
+      ...request,
+      model: request.model ?? this.defaultModel
+    };
+    return this.#request("POST", "/v1/systemone", {
+      ...options,
+      body
+    });
+  }
+  /** Send a request and parse its response body. */
+  #request(method, path, options = {}) {
+    const resolved = {
+      method,
+      path,
+      body: options.body,
+      headers: mergeHeaders(this.defaultHeaders, options.headers ?? {}),
+      signal: options.signal,
+      timeout: options.timeout === void 0 ? this.timeout : assertPositiveMs("timeout", options.timeout),
+      retry: resolveRetryPolicy(this.retry, options.retry)
+    };
+    const tag = `#${++this.#requestCount} ${method} ${path}`;
+    return new APIPromise(this.fetchWithRetries(tag, resolved), async (res) => {
+      const parsed = await parseBody(res);
+      this.logger.debug(`${tag} <- body`, parsed);
+      return parsed;
+    });
+  }
+  /** Retry eligible failures, logging attempt summaries at `info` and headers and bodies at `debug`. */
+  async fetchWithRetries(tag, req) {
+    const url = `${this.baseURL}${req.path}`;
+    const headers = mergeHeaders(req.headers, {
+      Authorization: `Bearer ${this.#apiKey}`,
+      Accept: "application/json",
+      "User-Agent": `typesafe-sdk/${VERSION}`,
+      "X-TypeSafe-SDK": `typesafe-sdk/${VERSION}`,
+      "X-TypeSafe-Runtime": RUNTIME,
+      "Content-Type": req.body === void 0 ? void 0 : "application/json",
+      "X-TypeSafe-Retry-Count": void 0
+    });
+    const body = req.body === void 0 ? void 0 : JSON.stringify(req.body);
+    for (let attempt = 0; ; attempt++) {
+      const retriesLeft = req.retry.maxRetries - attempt;
+      const attemptHeaders = attempt === 0 ? headers : {
+        ...headers,
+        "X-TypeSafe-Retry-Count": String(attempt)
+      };
+      this.logger.debug(`${tag} -> ${url}`, {
+        headers: redactHeaders(attemptHeaders),
+        body: req.body
+      });
+      const started = Date.now();
+      let res;
+      try {
+        res = await this.attempt(tag, url, {
+          method: req.method,
+          headers: attemptHeaders,
+          body
+        }, req);
+      } catch (err) {
+        if (err instanceof APIUserAbortError || retriesLeft <= 0) throw err;
+        if (!isRetryableError(err, req.retry)) throw err;
+        await this.backOff(tag, attempt, retriesLeft, err.message, void 0, req);
+        continue;
+      }
+      const requestId = requestIdFrom(res.headers);
+      this.logger.info(`${tag} <- ${res.status} in ${Date.now() - started}ms${requestId ? ` (request ${requestId})` : ""}`);
+      if (res.ok) return res;
+      const errorBody = await parseBody(res);
+      this.logger.debug(`${tag} <- error body`, errorBody);
+      const error = APIError.fromResponse(res.status, errorBody, res.headers);
+      if (retriesLeft <= 0 || !isRetryableStatus(res.status, req.retry)) throw error;
+      await this.backOff(tag, attempt, retriesLeft, `${res.status}`, res.headers, req);
+    }
+  }
+  /**
+  * One HTTP round trip, including body delivery, with a timeout. The caller's signal and our
+  * timer both abort the same controller; we check which fired to choose the error class.
+  */
+  async attempt(tag, url, init, { signal, timeout }) {
+    const controller = new AbortController();
+    const abortFromCaller = () => controller.abort(signal?.reason);
+    if (signal?.aborted) abortFromCaller();
+    signal?.addEventListener("abort", abortFromCaller, { once: true });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+    const started = Date.now();
+    const elapsed = () => `${Date.now() - started}ms`;
+    try {
+      const response = await this.fetch(url, {
+        ...init,
+        signal: controller.signal
+      });
+      await bufferResponse(response, controller.signal);
+      return response;
+    } catch (err) {
+      if (signal?.aborted) {
+        this.logger.info(`${tag} aborted by caller after ${elapsed()}`);
+        throw new APIUserAbortError(void 0, { cause: err });
+      }
+      if (timedOut) {
+        this.logger.info(`${tag} timed out after ${elapsed()}`);
+        throw new APITimeoutError(timeout, { cause: err });
+      }
+      this.logger.info(`${tag} connection error after ${elapsed()}`, err);
+      throw new APIConnectionError(err instanceof Error ? `Connection error: ${err.message}` : void 0, { cause: err });
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abortFromCaller);
+    }
+  }
+  /** Wait before retrying; caller cancellation throws `APIUserAbortError`. */
+  async backOff(tag, attempt, retriesLeft, reason, headers, { retry, signal }) {
+    const delay = retryDelayMs(attempt, headers, retry);
+    const nth = attempt + 1;
+    const total = attempt + retriesLeft;
+    this.logger.info(`${tag} retrying in ${delay}ms (retry ${nth}/${total}) after ${reason}`);
+    try {
+      await sleep(delay, signal);
+    } catch (err) {
+      this.logger.info(`${tag} aborted by caller while waiting to retry`);
+      throw new APIUserAbortError(void 0, { cause: err });
+    }
+  }
+};
+var parseBody = async (res) => {
+  const text = await res.text();
+  if (text.length === 0) return void 0;
+  if ((res.headers.get("content-type") ?? "").includes("application/json")) try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+
+// src/core/jev-client.ts
+var DEFAULT_JEV_MODEL = "jev-latest";
+var DEFAULT_JEV_TIMEOUT_MS = 1e4;
+var DEFAULT_JEV_MAX_RETRIES = 1;
+var TYPESAFE_API_KEY_ENV = "TYPESAFE_API_KEY";
+var TYPESAFE_BASE_URL_ENV = "TYPESAFE_BASE_URL";
+var TypeSafeJevClient = class {
+  #client;
+  #timeoutMs;
+  constructor(config) {
+    const apiKey = config.apiKey.trim();
+    if (apiKey.length === 0) throw new JevConfigError("TypeSafe API key is empty");
+    const timeoutMs = config.timeoutMs ?? DEFAULT_JEV_TIMEOUT_MS;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new JevConfigError(`timeoutMs must be a positive number, got ${String(config.timeoutMs)}`);
+    }
+    const maxRetries = config.maxRetries ?? DEFAULT_JEV_MAX_RETRIES;
+    if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+      throw new JevConfigError(`maxRetries must be a non-negative integer, got ${String(config.maxRetries)}`);
+    }
+    this.#timeoutMs = timeoutMs;
+    try {
+      this.#client = new TypeSafeClient({
+        apiKey,
+        ...config.baseUrl !== void 0 ? { baseURL: config.baseUrl } : {},
+        defaultModel: config.model ?? DEFAULT_JEV_MODEL,
+        logLevel: "off",
+        timeout: timeoutMs,
+        retry: { maxRetries, backoffInitialMs: 250, backoffMaxMs: 1500, maxRetryAfterMs: 2e3 },
+        ...config.fetch !== void 0 ? { fetch: config.fetch } : {}
+      });
+    } catch (error) {
+      throw new JevConfigError(`TypeSafe client rejected its configuration: ${describeError(error)}`, {
+        cause: error
+      });
+    }
+  }
+  async noul(request, options = {}) {
+    const ids = requireIds(Object.keys(request.questions));
+    const questions = {};
+    for (const id of ids) {
+      const instructions = request.questions[id];
+      if (typeof instructions !== "string" || instructions.length === 0) {
+        throw new JevInputError(`question "${id}" has no instructions`);
+      }
+      questions[id] = noul(instructions);
+    }
+    const result = await this.#call(
+      () => this.#client.systemOne({ state: request.state, questions }, this.#requestOptions(options))
+    );
+    return {
+      model: readModel(result.model),
+      answers: validateNoulAnswers(ids, result.answers),
+      usage: readUsage(result.usage)
+    };
+  }
+  async choice(request, options = {}) {
+    const ids = requireIds(Object.keys(request.questions));
+    const questions = {};
+    for (const id of ids) {
+      const spec = request.questions[id];
+      if (spec === void 0) throw new JevInputError(`question "${id}" is undefined`);
+      validateChoiceSpec(id, spec);
+      const criteria = {};
+      for (const label of spec.labels) criteria[label] = spec.descriptions?.[label] ?? null;
+      questions[id] = choice(spec.instructions, criteria);
+    }
+    const result = await this.#call(
+      () => this.#client.systemOne({ state: request.state, questions }, this.#requestOptions(options))
+    );
+    return {
+      model: readModel(result.model),
+      answers: validateChoiceAnswers(request.questions, result.answers),
+      usage: readUsage(result.usage)
+    };
+  }
+  #requestOptions(options) {
+    const timeout = options.timeoutMs ?? this.#timeoutMs;
+    return options.signal !== void 0 ? { signal: options.signal, timeout } : { timeout };
+  }
+  async #call(send) {
+    try {
+      return await send();
+    } catch (error) {
+      throw toJevError(error);
+    }
+  }
+};
+function createJevClientFromEnv(env = process.env, overrides = {}) {
+  const apiKey = env[TYPESAFE_API_KEY_ENV]?.trim() ?? "";
+  if (apiKey.length === 0) throw new JevConfigError(`${TYPESAFE_API_KEY_ENV} is not set`);
+  const baseUrl = env[TYPESAFE_BASE_URL_ENV]?.trim();
+  return new TypeSafeJevClient({
+    apiKey,
+    ...baseUrl !== void 0 && baseUrl.length > 0 ? { baseUrl } : {},
+    ...overrides
+  });
+}
+function toJevError(error) {
+  if (error instanceof JevRequestError || error instanceof JevTimeoutError || error instanceof JevAbortError) {
+    return error;
+  }
+  if (error instanceof APIUserAbortError) return new JevAbortError(error.message, { cause: error });
+  if (error instanceof APITimeoutError) {
+    return new JevTimeoutError(error.timeoutMs, `Jev request timed out after ${String(error.timeoutMs)} ms`, {
+      cause: error
+    });
+  }
+  if (error instanceof APIError) {
+    const retryable = error instanceof RateLimitError || error.status >= 500 || error.status === 408;
+    const detail = error instanceof AuthenticationError ? "TypeSafe rejected the API key" : error.message;
+    return new JevRequestError(`Jev request failed with status ${String(error.status)}: ${detail}`, {
+      status: error.status,
+      retryable,
+      ...error.requestId !== void 0 ? { requestId: error.requestId } : {},
+      cause: error
+    });
+  }
+  if (error instanceof APIConnectionError) {
+    return new JevRequestError(`Jev request could not connect: ${error.message}`, { retryable: true, cause: error });
+  }
+  if (error instanceof TypeSafeError) {
+    return new JevConfigError(`TypeSafe SDK rejected the request: ${error.message}`, { cause: error });
+  }
+  if (error instanceof Error) return error;
+  return new JevRequestError(`Jev request failed: ${describeError(error)}`, { retryable: false, cause: error });
+}
+function requireIds(ids) {
+  if (ids.length === 0) throw new JevInputError("a Jev request needs at least one question");
+  for (const id of ids) {
+    if (id.length === 0) throw new JevInputError("question ids must be non-empty strings");
+  }
+  return ids;
+}
+function validateChoiceSpec(id, spec) {
+  if (typeof spec.instructions !== "string" || spec.instructions.length === 0) {
+    throw new JevInputError(`choice question "${id}" has no instructions`);
+  }
+  if (spec.labels.length < 2) throw new JevInputError(`choice question "${id}" needs at least two labels`);
+  if (new Set(spec.labels).size !== spec.labels.length) {
+    throw new JevInputError(`choice question "${id}" has duplicate labels`);
+  }
+  for (const label of spec.labels) {
+    if (label.length === 0) throw new JevInputError(`choice question "${id}" has an empty label`);
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnitInterval(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function readModel(model) {
+  return typeof model === "string" ? model : "";
+}
+function readUsage(usage) {
+  const record = isRecord2(usage) ? usage : {};
+  const input = record["input_tokens"];
+  const output = record["output_tokens"];
+  return {
+    inputTokens: typeof input === "number" && Number.isFinite(input) ? input : 0,
+    outputTokens: typeof output === "number" && Number.isFinite(output) ? output : 0
+  };
+}
+function rejectUnexpectedIds(expected, answers) {
+  const known = new Set(expected);
+  for (const key of Object.keys(answers)) {
+    if (!known.has(key)) throw new JevResponseError(`Jev answered an id that was not asked: "${key}"`);
+  }
+}
+function validateNoulAnswers(ids, answers) {
+  if (!isRecord2(answers)) throw new JevResponseError("Jev response has no answers object");
+  rejectUnexpectedIds(ids, answers);
+  const out = {};
+  for (const id of ids) {
+    const answer = answers[id];
+    if (!isRecord2(answer)) throw new JevResponseError(`Jev response is missing the answer for "${id}"`);
+    if (answer["type"] !== "noul") throw new JevResponseError(`Jev answer "${id}" is not a noul answer`);
+    const value = answer["noul"];
+    if (!isUnitInterval(value)) throw new JevResponseError(`Jev answer "${id}" has no noul value in [0, 1]`);
+    out[id] = value;
+  }
+  return out;
+}
+function validateChoiceAnswers(questions, answers) {
+  if (!isRecord2(answers)) throw new JevResponseError("Jev response has no answers object");
+  const ids = Object.keys(questions);
+  rejectUnexpectedIds(ids, answers);
+  const out = {};
+  for (const id of ids) {
+    const spec = questions[id];
+    if (spec === void 0) continue;
+    const answer = answers[id];
+    if (!isRecord2(answer)) throw new JevResponseError(`Jev response is missing the answer for "${id}"`);
+    if (answer["type"] !== "choice") throw new JevResponseError(`Jev answer "${id}" is not a choice answer`);
+    const chosen = answer["choice"];
+    if (typeof chosen !== "string" || !spec.labels.includes(chosen)) {
+      throw new JevResponseError(`Jev answer "${id}" chose an undeclared label: ${String(chosen)}`);
+    }
+    const confidence = answer["confidence"];
+    if (!isUnitInterval(confidence)) throw new JevResponseError(`Jev answer "${id}" has no confidence in [0, 1]`);
+    const rawProbabilities = answer["probabilities"];
+    if (!isRecord2(rawProbabilities)) throw new JevResponseError(`Jev answer "${id}" has no probabilities`);
+    const probabilities = {};
+    for (const label of spec.labels) probabilities[label] = 0;
+    for (const [label, value] of Object.entries(rawProbabilities)) {
+      if (!spec.labels.includes(label)) {
+        throw new JevResponseError(`Jev answer "${id}" reports a probability for an undeclared label: ${label}`);
+      }
+      if (!isUnitInterval(value)) throw new JevResponseError(`Jev answer "${id}" has a probability outside [0, 1]`);
+      probabilities[label] = value;
+    }
+    out[id] = { choice: chosen, confidence, probabilities };
+  }
+  return out;
+}
+
+// src/core/tokens.ts
+var CHARS_PER_TOKEN = 3;
+var DEFAULT_WINDOW_TOKENS = 25e3;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateJsonTokens(value) {
+  return estimateTokens(JSON.stringify(value) ?? "");
+}
+
+// src/core/windows.ts
+function planWindows(items, options = {}) {
+  const budget = options.budgetTokens ?? DEFAULT_WINDOW_TOKENS;
+  const overhead = options.overheadTokens ?? 0;
+  const itemOverhead = options.itemOverheadTokens ?? 0;
+  if (!Number.isInteger(budget) || budget <= 0) {
+    throw new JevBudgetError(`budgetTokens must be a positive integer, got ${String(options.budgetTokens)}`);
+  }
+  if (!Number.isFinite(overhead) || overhead < 0) {
+    throw new JevBudgetError(`overheadTokens must be a non-negative number, got ${String(options.overheadTokens)}`);
+  }
+  if (!Number.isFinite(itemOverhead) || itemOverhead < 0) {
+    throw new JevBudgetError(
+      `itemOverheadTokens must be a non-negative number, got ${String(options.itemOverheadTokens)}`
+    );
+  }
+  if (overhead >= budget) {
+    throw new JevBudgetError(
+      `overheadTokens (${String(overhead)}) leaves no room under budgetTokens (${String(budget)})`
+    );
+  }
+  const cost = options.costTokens ?? ((item) => estimateJsonTokens({ id: item.id, text: item.text }));
+  const windows = [];
+  const oversize = [];
+  let current = [];
+  let used = overhead;
+  for (const item of items) {
+    const itemCost = cost(item) + itemOverhead;
+    if (overhead + itemCost > budget) {
+      oversize.push(item);
+      continue;
+    }
+    if (used + itemCost > budget && current.length > 0) {
+      windows.push(current);
+      current = [];
+      used = overhead;
+    }
+    current.push(item);
+    used += itemCost;
+  }
+  if (current.length > 0) windows.push(current);
+  return { windows, oversize };
+}
+var DEFAULT_WINDOW_CONCURRENCY = 4;
+var DEFAULT_WINDOW_TIMEOUT_MS = 1e4;
+async function runWindows(windows, judge, options = {}) {
+  const concurrency = options.concurrency ?? DEFAULT_WINDOW_CONCURRENCY;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_WINDOW_TIMEOUT_MS;
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new JevBudgetError(`concurrency must be a positive integer, got ${String(options.concurrency)}`);
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new JevBudgetError(`timeoutMs must be a positive number, got ${String(options.timeoutMs)}`);
+  }
+  if (windows.length === 0) return [];
+  if (options.signal?.aborted === true) throw new JevAbortError();
+  const controller = new AbortController();
+  const onOuterAbort = () => {
+    controller.abort(options.signal?.reason);
+  };
+  options.signal?.addEventListener("abort", onOuterAbort, { once: true });
+  const results = new Array(windows.length);
+  let failure;
+  let next = 0;
+  const worker = async () => {
+    while (!controller.signal.aborted) {
+      const index = next;
+      next += 1;
+      if (index >= windows.length) return;
+      const window = windows[index];
+      if (window === void 0) return;
+      const timeout = AbortSignal.timeout(timeoutMs);
+      const signal = AbortSignal.any([controller.signal, timeout]);
+      try {
+        results[index] = await judge(window, index, { signal, timeoutMs });
+      } catch (error) {
+        if (failure === void 0) failure = classifyWindowFailure(error, index, timeout, options.signal, timeoutMs);
+        controller.abort();
+        return;
+      }
+    }
+  };
+  try {
+    await Promise.all(Array.from({ length: Math.min(concurrency, windows.length) }, worker));
+  } finally {
+    options.signal?.removeEventListener("abort", onOuterAbort);
+  }
+  if (failure !== void 0) throw failure;
+  return results;
+}
+function classifyWindowFailure(error, index, timeout, outer, timeoutMs) {
+  if (timeout.aborted) {
+    return new JevTimeoutError(timeoutMs, `Jev window ${String(index + 1)} exceeded ${String(timeoutMs)} ms`, {
+      cause: error
+    });
+  }
+  if (outer?.aborted === true) return new JevAbortError("Jev windows aborted by caller", { cause: error });
+  if (error instanceof Error) return error;
+  return new Error(String(error));
+}
+
+// src/errors.ts
+var JevpruneError = class extends Error {
+  name = "JevpruneError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+var ConfigError = class extends JevpruneError {
+  name = "ConfigError";
+};
+var UsageError = class extends JevpruneError {
+  name = "UsageError";
+};
+var RunStoreError = class extends JevpruneError {
+  name = "RunStoreError";
+  code;
+  constructor(message, details = {}) {
+    super(message, { cause: details.cause });
+    this.code = details.code;
+  }
+};
+var SpawnError = class extends JevpruneError {
+  name = "SpawnError";
+  executable;
+  code;
+  constructor(message, details) {
+    super(message, { cause: details.cause });
+    this.executable = details.executable;
+    this.code = details.code;
+  }
+};
+var TranscriptError = class extends JevpruneError {
+  name = "TranscriptError";
+  path;
+  constructor(message, details) {
+    super(message, { cause: details.cause });
+    this.path = details.path;
+  }
+};
+var RunNotFoundError = class extends JevpruneError {
+  name = "RunNotFoundError";
+  id;
+  constructor(id, options) {
+    super(`run ${id} was not found`, options);
+    this.id = id;
+  }
+};
+var LineRangeError = class extends JevpruneError {
+  name = "LineRangeError";
+};
+function errorCode(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const code = error.code;
+  return typeof code === "string" ? code : void 0;
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : "Error";
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return String(error);
+}
+
+// src/config.ts
+var HOME_ENV = "JEVPRUNE_HOME";
+var TASK_ENV = "JEVPRUNE_TASK";
+var CONFIG_FILE = "config.json";
+var DEFAULT_ALLOWLIST = [
+  "cd",
+  "ls",
+  "pwd",
+  "echo",
+  "git status",
+  "git add",
+  "git commit",
+  "git log",
+  "git diff --stat",
+  "which",
+  "mkdir",
+  "touch",
+  "true",
+  "test",
+  "["
+];
+var DEFAULT_CONFIG = {
+  threshold: 0.3,
+  fastPathLines: 60,
+  tailLines: 40,
+  headLines: 40,
+  contextLines: 3,
+  minCollapseLines: 3,
+  windowTokens: DEFAULT_WINDOW_TOKENS,
+  windowTimeoutMs: 1e4,
+  concurrency: 4,
+  maxPruneBytes: 16777216,
+  retention: { maxRuns: 200, maxBytes: 268435456 },
+  autoWrap: true,
+  allowlist: DEFAULT_ALLOWLIST
+};
+function resolveHome(env = process.env) {
+  const override = env[HOME_ENV]?.trim() ?? "";
+  if (override.length > 0) return resolve(override);
+  return join(homedir(), ".jevprune");
+}
+async function loadConfig(env = process.env) {
+  const home = resolveHome(env);
+  const path = join(home, CONFIG_FILE);
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return { ...DEFAULT_CONFIG, home };
+    throw new ConfigError(`config file ${path} could not be read: ${errorMessage(error)}`, { cause: error });
+  }
+  return { ...parseConfig(raw, path), home };
+}
+function parseConfig(raw, path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new ConfigError(`config file ${path} is not valid JSON: ${errorMessage(error)}`, { cause: error });
+  }
+  if (!isRecord3(parsed)) {
+    throw new ConfigError(`config file ${path} must contain a JSON object, got ${describeValue(parsed)}`);
+  }
+  for (const key of Object.keys(parsed)) {
+    if (!(key in DEFAULT_CONFIG)) throw new ConfigError(`unknown config key "${key}" in ${path}`);
+  }
+  return {
+    threshold: readNumber(parsed, "threshold", DEFAULT_CONFIG.threshold, 0, 1),
+    fastPathLines: readInteger(parsed, "fastPathLines", DEFAULT_CONFIG.fastPathLines, 0),
+    tailLines: readInteger(parsed, "tailLines", DEFAULT_CONFIG.tailLines, 0),
+    headLines: readInteger(parsed, "headLines", DEFAULT_CONFIG.headLines, 0),
+    contextLines: readInteger(parsed, "contextLines", DEFAULT_CONFIG.contextLines, 0),
+    minCollapseLines: readInteger(parsed, "minCollapseLines", DEFAULT_CONFIG.minCollapseLines, 1),
+    windowTokens: readInteger(parsed, "windowTokens", DEFAULT_CONFIG.windowTokens, 1),
+    windowTimeoutMs: readInteger(parsed, "windowTimeoutMs", DEFAULT_CONFIG.windowTimeoutMs, 1),
+    concurrency: readInteger(parsed, "concurrency", DEFAULT_CONFIG.concurrency, 1),
+    maxPruneBytes: readInteger(parsed, "maxPruneBytes", DEFAULT_CONFIG.maxPruneBytes, 1),
+    retention: readRetention(parsed["retention"]),
+    autoWrap: readBoolean(parsed, "autoWrap", DEFAULT_CONFIG.autoWrap),
+    allowlist: readStringArray(parsed, "allowlist", DEFAULT_CONFIG.allowlist)
+  };
+}
+function parseThreshold(value) {
+  const parsed = Number(value);
+  if (value.trim().length === 0 || !Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+    throw new ConfigError(`--threshold must be a number in [0, 1], got ${describeValue(value)}`);
+  }
+  return parsed;
+}
+function readNumber(source, key, fallback, min, max) {
+  const value = source[key];
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    throw new ConfigError(
+      `config key "${key}" must be a number in [${String(min)}, ${String(max)}], got ${describeValue(value)}`
+    );
+  }
+  return value;
+}
+function readInteger(source, key, fallback, min, label = key) {
+  const value = source[key];
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min) {
+    throw new ConfigError(
+      `config key "${label}" must be an integer >= ${String(min)}, got ${describeValue(value)}`
+    );
+  }
+  return value;
+}
+function readBoolean(source, key, fallback) {
+  const value = source[key];
+  if (value === void 0) return fallback;
+  if (typeof value !== "boolean") {
+    throw new ConfigError(`config key "${key}" must be a boolean, got ${describeValue(value)}`);
+  }
+  return value;
+}
+function readStringArray(source, key, fallback) {
+  const value = source[key];
+  if (value === void 0) return fallback;
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new ConfigError(`config key "${key}" must be an array of strings, got ${describeValue(value)}`);
+  }
+  return value;
+}
+function readRetention(value) {
+  if (value === void 0) return DEFAULT_CONFIG.retention;
+  if (!isRecord3(value)) {
+    throw new ConfigError(`config key "retention" must be an object, got ${describeValue(value)}`);
+  }
+  for (const key of Object.keys(value)) {
+    if (key !== "maxRuns" && key !== "maxBytes") {
+      throw new ConfigError(`unknown config key "retention.${key}"`);
+    }
+  }
+  return {
+    maxRuns: readInteger(value, "maxRuns", DEFAULT_CONFIG.retention.maxRuns, 1, "retention.maxRuns"),
+    maxBytes: readInteger(value, "maxBytes", DEFAULT_CONFIG.retention.maxBytes, 1, "retention.maxBytes")
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeValue(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value) ?? typeof value;
+  } catch {
+    return typeof value;
+  }
+}
+
+// src/footer.ts
+import { homedir as homedir2 } from "os";
+import { sep } from "path";
+var LF = 10;
+function formatFooter(input) {
+  if (input.mode === "fast-path") return "";
+  const parts = [];
+  if (input.mode === "passthrough") {
+    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
+    const note = input.passthroughNote === void 0 ? "" : ` (${input.passthroughNote})`;
+    parts.push(`${formatCount(input.linesIn)} lines passed through${note}`);
+  } else {
+    if (input.mode === "fallback") parts.push(`fallback (no Jev: ${input.fallbackReason ?? "unknown"})`);
+    parts.push(`${formatCount(input.linesIn)} \u2192 ${formatCount(input.linesOut)} lines`);
+    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
+  }
+  if (input.storeFailureCode !== void 0) {
+    parts.push(`run store unavailable (${input.storeFailureCode})`);
+  } else if (input.logPath !== void 0) {
+    parts.push(`full output ${displayPath(input.logPath, input.home)}`);
+  }
+  return `jevprune: ${parts.join(", ")}`;
+}
+function footerAfter(lastByte, footer) {
+  if (footer.length === 0) return "";
+  const separator = lastByte === void 0 || lastByte === LF ? "" : "\n";
+  return `${separator}${footer}
+`;
+}
+function withFooter(kept, footer) {
+  if (footer.length === 0) return kept;
+  const separator = kept.length === 0 || kept.endsWith("\n") ? "" : "\n";
+  return `${kept}${separator}${footer}
+`;
+}
+function formatCount(value) {
+  const digits = Math.trunc(Math.abs(value)).toString();
+  const grouped = digits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return value < 0 ? `-${grouped}` : grouped;
+}
+function displayPath(path, home = homedir2()) {
+  if (path === home) return "~";
+  if (home.length > 0 && path.startsWith(home + sep)) return `~${path.slice(home.length)}`;
+  return path;
+}
+
+// src/store.ts
+import { randomBytes } from "crypto";
+import { createReadStream } from "fs";
+import { appendFile, mkdir, open, readFile as readFile2, readdir, stat, unlink, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+import { finished } from "stream/promises";
+
+// src/bytes.ts
+var LF2 = 10;
+var CR = 13;
+function isValidUtf8(bytes) {
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function byteLineStarts(bytes) {
+  const starts = [0];
+  for (let index = 0; index < bytes.length; index += 1) {
+    const byte = bytes[index];
+    if (byte === CR && bytes[index + 1] === LF2) index += 1;
+    else if (byte !== CR && byte !== LF2) continue;
+    starts.push(index + 1);
+  }
+  if (starts[starts.length - 1] !== bytes.length) starts.push(bytes.length);
+  return starts;
+}
+function countByteLines(bytes) {
+  return byteLineStarts(bytes).length - 1;
+}
+
+// src/store.ts
+var RUN_ID_PATTERN = /^[a-z0-9]+-[a-f0-9]{4}$/;
+var RUNS_DIR = "runs";
+var GAIN_FILE = "gain.jsonl";
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+function newRunId() {
+  return `${Date.now().toString(36)}-${randomBytes(2).toString("hex")}`;
+}
+var FileRunWriter = class {
+  path;
+  #handle;
+  #stream;
+  #waiting = [];
+  #failure;
+  #closed = false;
+  constructor(path, handle, stream) {
+    this.path = path;
+    this.#handle = handle;
+    this.#stream = stream;
+    this.#stream.on("error", (error) => {
+      this.#fail(error);
+      this.#release();
+    });
+    this.#stream.on("drain", () => {
+      this.#release();
+    });
+  }
+  get failure() {
+    return this.#failure;
+  }
+  write(chunk) {
+    if (this.#closed || this.#failure !== void 0) return true;
+    try {
+      return this.#stream.write(chunk);
+    } catch (error) {
+      this.#fail(error);
+      return true;
+    }
+  }
+  onDrain(listener) {
+    if (this.#closed || this.#failure !== void 0) {
+      queueMicrotask(listener);
+      return;
+    }
+    this.#waiting.push(listener);
+  }
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    try {
+      this.#stream.end();
+      await finished(this.#stream);
+    } catch (error) {
+      this.#fail(error);
+      await this.#handle.close().catch(() => void 0);
+    }
+    this.#release();
+  }
+  #fail(error) {
+    this.#failure ??= storeError(`run log ${this.path} could not be written`, error);
+  }
+  #release() {
+    const waiting = this.#waiting;
+    this.#waiting = [];
+    for (const listener of waiting) listener();
+  }
+};
+var RunStore = class {
+  home;
+  #retention;
+  constructor(options) {
+    this.home = options.home;
+    this.#retention = options.retention ?? DEFAULT_CONFIG.retention;
+  }
+  get runsDir() {
+    return join2(this.home, RUNS_DIR);
+  }
+  get gainPath() {
+    return join2(this.home, GAIN_FILE);
+  }
+  logPath(id) {
+    return join2(this.runsDir, `${requireRunId(id)}.log`);
+  }
+  metaPath(id) {
+    return join2(this.runsDir, `${requireRunId(id)}.json`);
+  }
+  async openRun(run) {
+    const path = this.logPath(run.id);
+    await this.#ensureDir(this.runsDir);
+    let handle;
+    try {
+      handle = await open(path, "wx", FILE_MODE);
+    } catch (error) {
+      throw storeError(`run log ${path} could not be created`, error);
+    }
+    return new FileRunWriter(path, handle, handle.createWriteStream());
+  }
+  async finalizeRun(id, meta) {
+    const path = this.metaPath(id);
+    await this.#ensureDir(this.runsDir);
+    try {
+      await writeFile(path, `${JSON.stringify(meta)}
+`, { mode: FILE_MODE });
+    } catch (error) {
+      throw storeError(`run meta ${path} could not be written`, error);
+    }
+  }
+  async readRunBytes(id) {
+    const path = this.logPath(id);
+    try {
+      return await readFile2(path);
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") throw new RunNotFoundError(id, { cause: error });
+      throw storeError(`run log ${path} could not be read`, error);
+    }
+  }
+  async *readRunChunks(id) {
+    const path = this.logPath(id);
+    try {
+      for await (const chunk of createReadStream(path)) {
+        yield typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+      }
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") throw new RunNotFoundError(id, { cause: error });
+      throw storeError(`run log ${path} could not be read`, error);
+    }
+  }
+  async readRun(id) {
+    const bytes = await this.readRunBytes(id);
+    return { id, path: this.logPath(id), text: bytes.toString("utf8"), meta: await this.#readMeta(id) };
+  }
+  async readRunLineBytes(id, from = 1, to) {
+    const bytes = await this.readRunBytes(id);
+    const starts = byteLineStarts(bytes);
+    const lines = starts.length - 1;
+    const last = to ?? lines;
+    if (!Number.isInteger(from) || !Number.isInteger(last) || from < 1 || last < from) {
+      throw new LineRangeError(`line range ${String(from)}-${String(last)} is not a range`);
+    }
+    if (last > lines) {
+      throw new LineRangeError(
+        `line range ${String(from)}-${String(last)} is outside run ${id} (${String(lines)} lines)`
+      );
+    }
+    return bytes.subarray(starts[from - 1] ?? 0, starts[last] ?? bytes.length);
+  }
+  async readRunLines(id, from = 1, to) {
+    return (await this.readRunLineBytes(id, from, to)).toString("utf8");
+  }
+  async appendGain(entry2) {
+    await this.#ensureDir(this.home);
+    try {
+      await appendFile(this.gainPath, `${JSON.stringify(entry2)}
+`, { mode: FILE_MODE });
+    } catch (error) {
+      throw storeError(`gain ledger ${this.gainPath} could not be written`, error);
+    }
+  }
+  async readGain() {
+    let raw;
+    try {
+      raw = await readFile2(this.gainPath, "utf8");
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return { runs: 0, linesIn: 0, linesOut: 0, bytesIn: 0, bytesOut: 0 };
+      throw storeError(`gain ledger ${this.gainPath} could not be read`, error);
+    }
+    let runs = 0;
+    let linesIn = 0;
+    let linesOut = 0;
+    let bytesIn = 0;
+    let bytesOut = 0;
+    for (const line of raw.split("\n")) {
+      if (line.trim().length === 0) continue;
+      const entry2 = parseGainEntry(line);
+      if (entry2 === null) continue;
+      runs += 1;
+      linesIn += entry2.linesIn;
+      linesOut += entry2.linesOut;
+      bytesIn += entry2.bytesIn;
+      bytesOut += entry2.bytesOut;
+    }
+    return { runs, linesIn, linesOut, bytesIn, bytesOut };
+  }
+  async enforceRetention() {
+    let names;
+    try {
+      names = await readdir(this.runsDir);
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return;
+      throw storeError(`run directory ${this.runsDir} could not be read`, error);
+    }
+    const ids = [...new Set(names.filter((name) => name.endsWith(".log")).map((name) => name.slice(0, -4)))].filter((id) => RUN_ID_PATTERN.test(id)).sort();
+    const sizes = /* @__PURE__ */ new Map();
+    let total = 0;
+    for (const id of ids) {
+      const bytes = await this.#sizeOf(this.logPath(id)) + await this.#sizeOf(this.metaPath(id));
+      sizes.set(id, bytes);
+      total += bytes;
+    }
+    let count = ids.length;
+    for (const id of ids) {
+      if (count <= this.#retention.maxRuns && total <= this.#retention.maxBytes) break;
+      await this.discardRun(id);
+      total -= sizes.get(id) ?? 0;
+      count -= 1;
+    }
+  }
+  async discardRun(id) {
+    for (const path of [this.logPath(id), this.metaPath(id)]) {
+      try {
+        await unlink(path);
+      } catch (error) {
+        if (errorCode(error) === "ENOENT") continue;
+        throw storeError(`run file ${path} could not be deleted`, error);
+      }
+    }
+  }
+  async #sizeOf(path) {
+    try {
+      return (await stat(path)).size;
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return 0;
+      throw storeError(`run file ${path} could not be inspected`, error);
+    }
+  }
+  async #readMeta(id) {
+    const path = this.metaPath(id);
+    let raw;
+    try {
+      raw = await readFile2(path, "utf8");
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return null;
+      throw storeError(`run meta ${path} could not be read`, error);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw storeError(`run meta ${path} is not valid JSON`, error);
+    }
+    return isRecord4(parsed) ? parsed : null;
+  }
+  async #ensureDir(path) {
+    try {
+      await mkdir(path, { recursive: true, mode: DIR_MODE });
+    } catch (error) {
+      throw storeError(`directory ${path} could not be created`, error);
+    }
+  }
+};
+function requireRunId(id) {
+  if (!RUN_ID_PATTERN.test(id)) throw new RunStoreError(`"${id}" is not a run id`);
+  return id;
+}
+function parseGainEntry(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord4(parsed)) return null;
+  const linesIn = parsed["linesIn"];
+  const linesOut = parsed["linesOut"];
+  const bytesIn = parsed["bytesIn"];
+  const bytesOut = parsed["bytesOut"];
+  if (typeof linesIn !== "number" || typeof linesOut !== "number" || typeof bytesIn !== "number" || typeof bytesOut !== "number") {
+    return null;
+  }
+  return parsed;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function storeError(message, error) {
+  const code = errorCode(error);
+  return new RunStoreError(`${message}: ${errorMessage(error)}`, {
+    ...code !== void 0 ? { code } : {},
+    cause: error
+  });
+}
+
+// src/commands/gain.ts
+async function runGain(io) {
+  const config = await loadConfig(io.env);
+  const store = new RunStore({ home: config.home, retention: config.retention });
+  const totals = await store.readGain();
+  const tokens = Math.max(0, Math.floor((totals.bytesIn - totals.bytesOut) / CHARS_PER_TOKEN));
+  await io.write(
+    `jevprune: ${formatCount(totals.runs)} runs, ${formatCount(totals.linesIn)} \u2192 ${formatCount(totals.linesOut)} lines, ~${formatCount(tokens)} tokens saved (estimated at ${String(CHARS_PER_TOKEN)} chars per token)
+`
+  );
+  return 0;
+}
+
+// src/hook.ts
+var STATE_CHANGING_TOKENS = [
+  "cd",
+  "export",
+  "source",
+  ".",
+  "unset",
+  "alias",
+  "set",
+  "eval",
+  "exec",
+  "pushd",
+  "popd"
+];
+var ALWAYS_INTERACTIVE_COMMANDS = [
+  "vim",
+  "vi",
+  "nvim",
+  "nano",
+  "emacs",
+  "less",
+  "more",
+  "man",
+  "top",
+  "htop",
+  "ssh",
+  "telnet",
+  "tmux",
+  "screen",
+  "sudo",
+  "su",
+  "passwd",
+  "claude",
+  "watch"
+];
+var INTERACTIVE_WHEN_BARE_COMMANDS = [
+  "python",
+  "python3",
+  "node",
+  "irb",
+  "psql",
+  "mysql",
+  "sqlite3",
+  "bash",
+  "sh",
+  "zsh",
+  "fish",
+  "gh"
+];
+var SHELL_COMMANDS = ["bash", "sh", "zsh", "fish"];
+var DOCKER_TTY_FLAG = /^-(?:i|t|it|ti)$|^--interactive$|^--tty$/;
+var STATE_CHANGE_PATTERN = new RegExp(
+  `(?:^|;|\\||\\(|&&|\\n)\\s*(?:${STATE_CHANGING_TOKENS.map(escapeRegExp).join("|")})(?=\\s|$|[;|)&])`
+);
+var ENV_ASSIGNMENT_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*=/;
+function quoteForShell(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function hasStateChange(command) {
+  return STATE_CHANGE_PATTERN.test(command);
+}
+function isInteractiveCommand(command) {
+  const words = command.split(/\s+/).filter((word2) => word2.length > 0);
+  let index = 0;
+  while (index < words.length && ENV_ASSIGNMENT_PATTERN.test(words[index] ?? "")) index += 1;
+  const word = words[index];
+  if (word === void 0) return true;
+  const rest = words.slice(index + 1);
+  if (ALWAYS_INTERACTIVE_COMMANDS.includes(word)) return true;
+  if (INTERACTIVE_WHEN_BARE_COMMANDS.includes(word)) {
+    if (rest.length === 0) return true;
+    if (SHELL_COMMANDS.includes(word) && rest.includes("-i")) return true;
+    return word === "gh" && rest[0] === "auth";
+  }
+  if (word === "tail") return rest[0] === "-f";
+  if (word === "docker" && (rest[0] === "exec" || rest[0] === "run")) {
+    return rest.some((flag) => DOCKER_TTY_FLAG.test(flag));
+  }
+  return false;
+}
+function isAllowlisted(command, allowlist) {
+  for (const prefix of allowlist) {
+    if (prefix.length === 0) continue;
+    if (command === prefix) return true;
+    const next = command.startsWith(prefix) ? command[prefix.length] : void 0;
+    if (next !== void 0 && /\s/.test(next)) return true;
+  }
+  return false;
+}
+function planRewrite(input, config) {
+  if (input.tool_name !== "Bash") return null;
+  if (!config.autoWrap) return null;
+  const toolInput = input.tool_input;
+  if (toolInput === void 0) return null;
+  if (toolInput.run_in_background === true) return null;
+  const command = typeof toolInput.command === "string" ? toolInput.command.trim() : "";
+  if (command.length === 0) return null;
+  if (/\bjevprune\b/.test(command)) return null;
+  if (hasStateChange(command)) return null;
+  if (isInteractiveCommand(command)) return null;
+  if (command.endsWith("&") && !command.endsWith("&&")) return null;
+  if (isAllowlisted(command, config.allowlist)) return null;
+  const transcript = typeof input.transcript_path === "string" && input.transcript_path.length > 0 ? ` --transcript ${quoteForShell(input.transcript_path)}` : "";
+  return { command: `jevprune run --hook${transcript} -- bash -c ${quoteForShell(command)}` };
+}
+function parsePreToolUse(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord5(parsed)) return null;
+  const toolName = parsed["tool_name"];
+  const transcriptPath = parsed["transcript_path"];
+  const toolInput = parsed["tool_input"];
+  return {
+    ...typeof toolName === "string" ? { tool_name: toolName } : {},
+    ...typeof transcriptPath === "string" ? { transcript_path: transcriptPath } : {},
+    ...isRecord5(toolInput) ? { tool_input: readToolInput(toolInput) } : {}
+  };
+}
+function formatHookOutput(plan) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      updatedInput: { command: plan.command }
+    }
+  });
+}
+function readToolInput(source) {
+  const command = source["command"];
+  const background = source["run_in_background"];
+  return {
+    ...typeof command === "string" ? { command } : {},
+    ...typeof background === "boolean" ? { run_in_background: background } : {}
+  };
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/io.ts
+var CLOSED_PIPE_CODES = /* @__PURE__ */ new Set([
+  "EPIPE",
+  "EOF",
+  "ERR_STREAM_DESTROYED",
+  "ERR_STREAM_WRITE_AFTER_END"
+]);
+function processIo() {
+  const write = openWriter(process.stdout);
+  return {
+    env: process.env,
+    cwd: process.cwd(),
+    stdin: process.stdin,
+    write: (text) => write(text),
+    writeBytes: (bytes) => write(bytes),
+    writeError: openWriter(process.stderr)
+  };
+}
+async function readStreamBytes(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
+  }
+  return Buffer.concat(chunks);
+}
+async function readStream(stream) {
+  return (await readStreamBytes(stream)).toString("utf8");
+}
+function isClosedPipe(error) {
+  const code = errorCode(error);
+  return code !== void 0 && CLOSED_PIPE_CODES.has(code);
+}
+function openWriter(stream) {
+  let closed = false;
+  stream.on("error", (error) => {
+    if (isClosedPipe(error)) closed = true;
+  });
+  return (chunk) => new Promise((resolve2, reject) => {
+    if (closed || chunk.length === 0) {
+      resolve2();
+      return;
+    }
+    try {
+      stream.write(chunk, (error) => {
+        if (error === void 0 || error === null) resolve2();
+        else if (isClosedPipe(error)) {
+          closed = true;
+          resolve2();
+        } else reject(error);
+      });
+    } catch (error) {
+      if (!isClosedPipe(error)) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      closed = true;
+      resolve2();
+    }
+  });
+}
+
+// src/commands/hook.ts
+async function runHook(io) {
+  try {
+    const input = parsePreToolUse(await readStream(io.stdin));
+    if (input === null) return 0;
+    const plan = planRewrite(input, await loadConfig(io.env));
+    if (plan === null) return 0;
+    await io.write(`${formatHookOutput(plan)}
+`);
+  } catch (error) {
+    await io.writeError(`jevprune: hook skipped: ${errorMessage(error)}
+`).catch(() => void 0);
+  }
+  return 0;
+}
+
+// src/notices.ts
+import { mkdir as mkdir2, open as open2 } from "fs/promises";
+import { join as join3 } from "path";
+var MISSING_KEY_MARKER = "missing-key-notice";
+async function shouldAnnounceMissingKey(home) {
+  const path = join3(home, MISSING_KEY_MARKER);
+  try {
+    await mkdir2(home, { recursive: true, mode: 448 });
+    const handle = await open2(path, "wx", 384);
+    await handle.close();
+    return true;
+  } catch (error) {
+    return errorCode(error) !== "EEXIST";
+  }
+}
+
+// src/keeps.ts
+var SIGNATURE_CASE_SENSITIVE = /(^|\s)(FAIL|FAILED|ERROR|PANIC|FATAL)(\s|:|$)|\b[A-Z][A-Za-z]*(Error|Exception|Panic)\b|^\s*E\s{2,}\S|^npm ERR!|^\s*(Test Files|Tests|Test Suites)\s/;
+var SIGNATURE_CASE_INSENSITIVE = /^\s*(✗|✘|×|⨯|❌|❯)|^\s*(error|fatal)(\[E\d+\])?:|^traceback \(most recent call last\)|^\s*File ".*", line \d+|^\s+at .*:\d+:\d+\)?$|^\s*-->\s.*:\d+:\d+|^thread '.*' panicked|\b(exit code|exit status|exited with|command not found|no such file or directory|ENOENT|EACCES|ECONNREFUSED|segmentation fault|core dumped|killed)\b|\blevel[=:"\s]+"?(error|fatal|panic)\b|\[(error|fatal|panic)\]|^=+ .*(passed|failed|error).* =+$/i;
+function isSignatureLine(text) {
+  return SIGNATURE_CASE_SENSITIVE.test(text) || SIGNATURE_CASE_INSENSITIVE.test(text);
+}
+function computeKeeps(lines, options) {
+  const keeps = /* @__PURE__ */ new Map();
+  const tailLines = Math.max(0, Math.trunc(options.tailLines));
+  const contextLines = Math.max(0, Math.trunc(options.contextLines));
+  const tailStart = lines.length - tailLines + 1;
+  for (const line of lines) {
+    if (line.n >= tailStart) keeps.set(line.n, "tail");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const signatures = [];
+  for (const line of lines) {
+    if (!isSignatureLine(line.text)) continue;
+    const key = line.text.trim();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    signatures.push(line.n);
+  }
+  for (const n of signatures) keeps.set(n, "signature");
+  for (const n of signatures) {
+    for (let offset = 1; offset <= contextLines; offset += 1) {
+      for (const candidate of [n - offset, n + offset]) {
+        if (candidate < 1 || candidate > lines.length) continue;
+        if (!keeps.has(candidate)) keeps.set(candidate, "context");
+      }
+    }
+  }
+  return keeps;
+}
+
+// src/lines.ts
+function splitLines(text) {
+  const lines = [];
+  const pattern = /\r\n|\n|\r/g;
+  let start = 0;
+  let match = pattern.exec(text);
+  while (match !== null) {
+    const raw = match[0];
+    const terminator = raw === "\r\n" ? "\r\n" : raw === "\r" ? "\r" : "\n";
+    lines.push({ n: lines.length + 1, text: text.slice(start, match.index), terminator });
+    start = match.index + raw.length;
+    match = pattern.exec(text);
+  }
+  if (start < text.length) {
+    lines.push({ n: lines.length + 1, text: text.slice(start), terminator: "" });
+  }
+  return lines;
+}
+
+// src/merge.ts
+function collapseMarker(range2, runId) {
+  return `[jevprune: ${String(range2.count)} lines dropped, run ${runId}, lines ${String(range2.from)}-${String(range2.to)}]
+`;
+}
+function mergeDecisions(lines, decisions, options) {
+  const minCollapseLines = Math.max(1, Math.trunc(options.minCollapseLines));
+  const dropped = [];
+  let kept = "";
+  let run = null;
+  let expected = 1;
+  const flush = () => {
+    if (run === null) return;
+    const count = run.to - run.from + 1;
+    if (!run.missing && count < minCollapseLines) {
+      for (const line of run.lines) {
+        decisions.set(line.n, { keep: true, reason: "collapse-min" });
+        kept += line.text + line.terminator;
+      }
+    } else {
+      const range2 = { from: run.from, to: run.to, count };
+      dropped.push(range2);
+      kept += collapseMarker(range2, options.runId);
+    }
+    run = null;
+  };
+  const dropLine = (line) => {
+    if (run === null) run = { from: line.n, to: line.n, lines: [line], missing: false };
+    else {
+      run.to = line.n;
+      run.lines.push(line);
+    }
+  };
+  const dropMissing = (from, to) => {
+    if (to < from) return;
+    if (run === null) run = { from, to, lines: [], missing: true };
+    else {
+      run.to = to;
+      run.missing = true;
+    }
+  };
+  for (const line of lines) {
+    dropMissing(expected, line.n - 1);
+    expected = line.n + 1;
+    if (decisions.get(line.n)?.keep === false) {
+      dropLine(line);
+      continue;
+    }
+    flush();
+    kept += line.text + line.terminator;
+  }
+  if (options.totalLines !== void 0) dropMissing(expected, options.totalLines);
+  flush();
+  return { kept, dropped };
+}
+
+// src/select.ts
+var UNAUTHORIZED_REASON = "unauthorized (401)";
+var NOT_UTF8_REASON = "not valid UTF-8";
+var NOT_UTF8_NOTE = "output is not valid UTF-8";
+var RUBRIC = "A line is needed when a developer acting on the task would want to read it: errors, failures, assertions, stack frames, diagnostics, timings or statuses that bear on the task, and the lines that give them meaning. Progress bars, download counters, repeated banners, unchanged status lines and routine success noise are not needed.";
+var ITEM_OVERHEAD_TOKENS = 12;
+function passthroughSelection(input) {
+  return {
+    mode: "passthrough",
+    kept: "",
+    dropped: [],
+    linesIn: input.lines,
+    linesOut: input.lines,
+    bytesIn: input.bytes,
+    bytesOut: input.bytes,
+    windows: 0,
+    jevRequests: 0,
+    jevInputTokens: 0,
+    ...input.reason !== void 0 ? { fallbackReason: input.reason } : {},
+    decisions: /* @__PURE__ */ new Map()
+  };
+}
+function questionFor(n) {
+  return `Is line ${String(n)} needed for the task?`;
+}
+async function selectLines(input) {
+  const lines = splitLines(input.text);
+  const bytesIn = Buffer.byteLength(input.text);
+  if (input.oversize !== void 0) {
+    return oversizeSelection(input, input.oversize, lines, bytesIn);
+  }
+  if (input.exitCode !== void 0 && input.exitCode !== null && input.exitCode !== 0 || input.interrupted === true) {
+    return everyLine(lines, "passthrough", input.text, bytesIn);
+  }
+  if (lines.length <= input.config.fastPathLines) {
+    return everyLine(lines, "fast-path", input.text, bytesIn);
+  }
+  const keeps = keepsOf(lines, input.config);
+  const decisions = /* @__PURE__ */ new Map();
+  const candidates = [];
+  for (const line of lines) {
+    const keep = keeps.get(line.n);
+    if (keep !== void 0) {
+      decisions.set(line.n, { keep: true, reason: keep });
+      continue;
+    }
+    if (line.text.trim().length === 0) {
+      decisions.set(line.n, { keep: false, reason: "blank" });
+      continue;
+    }
+    candidates.push({ id: `l${String(line.n)}`, n: line.n, text: line.text });
+  }
+  if (input.client === null) {
+    return fallbackSelection({ lines, keeps, input, reason: "no api key", bytesIn, linesIn: lines.length });
+  }
+  let verdicts;
+  try {
+    verdicts = await askJev(candidates, input, input.client);
+  } catch (error) {
+    return fallbackSelection({
+      lines,
+      keeps,
+      input,
+      reason: fallbackReason(error),
+      bytesIn,
+      linesIn: lines.length
+    });
+  }
+  for (const n of verdicts.oversize) decisions.set(n, { keep: true, reason: "oversize" });
+  for (const item of candidates) {
+    if (decisions.has(item.n)) continue;
+    const noul2 = verdicts.answers.get(item.n) ?? 0;
+    decisions.set(item.n, { keep: noul2 >= input.config.threshold, reason: "jev", noul: noul2 });
+  }
+  const { kept, dropped } = mergeDecisions(lines, decisions, {
+    minCollapseLines: input.config.minCollapseLines,
+    runId: input.runId
+  });
+  return {
+    mode: "jev",
+    kept,
+    dropped,
+    linesIn: lines.length,
+    linesOut: splitLines(kept).length,
+    bytesIn,
+    bytesOut: Buffer.byteLength(kept),
+    windows: verdicts.windows,
+    jevRequests: verdicts.jevRequests,
+    jevInputTokens: verdicts.jevInputTokens,
+    decisions
+  };
+}
+async function askJev(candidates, input, client) {
+  const answers = /* @__PURE__ */ new Map();
+  if (candidates.length === 0) {
+    return { windows: 0, jevRequests: 0, jevInputTokens: 0, answers, oversize: [] };
+  }
+  const lastLine = candidates[candidates.length - 1]?.n ?? 0;
+  const plan = planWindows(candidates, {
+    budgetTokens: input.config.windowTokens,
+    overheadTokens: estimateJsonTokens(stateOf(input, [])),
+    itemOverheadTokens: estimateTokens(questionFor(lastLine)) + ITEM_OVERHEAD_TOKENS,
+    costTokens: (item) => estimateJsonTokens({ n: item.n, text: item.text })
+  });
+  const results = await runWindows(
+    plan.windows,
+    async (window, _index, options) => {
+      const questions = {};
+      for (const item of window) questions[item.id] = questionFor(item.n);
+      return await client.noul({ state: stateOf(input, window), questions }, options);
+    },
+    {
+      concurrency: input.config.concurrency,
+      timeoutMs: input.config.windowTimeoutMs,
+      ...input.signal !== void 0 ? { signal: input.signal } : {}
+    }
+  );
+  let jevInputTokens = 0;
+  for (const [index, result] of results.entries()) {
+    jevInputTokens += result.usage.inputTokens;
+    for (const item of plan.windows[index] ?? []) {
+      const noul2 = result.answers[item.id];
+      if (noul2 !== void 0) answers.set(item.n, noul2);
+    }
+  }
+  return {
+    windows: plan.windows.length,
+    jevRequests: results.length,
+    jevInputTokens,
+    answers,
+    oversize: plan.oversize.map((item) => item.n)
+  };
+}
+function stateOf(input, window) {
+  return {
+    command: input.command,
+    task: input.task,
+    rubric: RUBRIC,
+    lines: window.map((item) => ({ n: item.n, text: item.text }))
+  };
+}
+function keepsOf(lines, config) {
+  return computeKeeps(lines, { tailLines: config.tailLines, contextLines: config.contextLines });
+}
+function fallbackSelection(fallback) {
+  const { lines, keeps, input } = fallback;
+  return fallbackResult({
+    lines,
+    decisions: fallbackDecisions(lines, keeps, input.config.headLines),
+    input,
+    reason: fallback.reason,
+    bytesIn: fallback.bytesIn,
+    linesIn: fallback.linesIn
+  });
+}
+function oversizeSelection(input, oversize, captured, bytesIn) {
+  const headCount = Math.min(Math.max(0, Math.trunc(oversize.headSegmentLines)), captured.length);
+  const totalLines = Math.max(Math.trunc(oversize.lines), captured.length);
+  const tailFirst = totalLines - captured.length + headCount + 1;
+  const head = captured.slice(0, headCount);
+  const tail = renumber(captured.slice(headCount), tailFirst);
+  const contextLines = input.config.contextLines;
+  const keeps = computeKeeps(head, { tailLines: 0, contextLines });
+  const tailKeeps = computeKeeps(renumber(tail, 1), { tailLines: input.config.tailLines, contextLines });
+  for (const [n, reason] of tailKeeps) keeps.set(n + tailFirst - 1, reason);
+  const lines = [...head, ...tail];
+  return fallbackResult({
+    lines,
+    decisions: fallbackDecisions(lines, keeps, input.config.headLines),
+    input,
+    reason: `output over ${String(input.config.maxPruneBytes)} bytes`,
+    bytesIn,
+    linesIn: totalLines,
+    totalLines
+  });
+}
+function fallbackDecisions(lines, keeps, headLines) {
+  const head = Math.max(0, Math.trunc(headLines));
+  const decisions = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const keep = keeps.get(line.n);
+    if (keep !== void 0) decisions.set(line.n, { keep: true, reason: keep });
+    else if (line.n <= head) decisions.set(line.n, { keep: true, reason: "head" });
+    else decisions.set(line.n, { keep: false, reason: "fallback" });
+  }
+  return decisions;
+}
+function renumber(lines, from) {
+  return lines.map((line, index) => ({ ...line, n: from + index }));
+}
+function fallbackResult(fallback) {
+  const { kept, dropped } = mergeDecisions(fallback.lines, fallback.decisions, {
+    minCollapseLines: fallback.input.config.minCollapseLines,
+    runId: fallback.input.runId,
+    ...fallback.totalLines !== void 0 ? { totalLines: fallback.totalLines } : {}
+  });
+  return {
+    mode: "fallback",
+    kept,
+    dropped,
+    linesIn: fallback.linesIn,
+    linesOut: splitLines(kept).length,
+    bytesIn: fallback.bytesIn,
+    bytesOut: Buffer.byteLength(kept),
+    windows: 0,
+    jevRequests: 0,
+    jevInputTokens: 0,
+    fallbackReason: fallback.reason,
+    decisions: fallback.decisions
+  };
+}
+function fallbackReason(error) {
+  if (error instanceof JevTimeoutError) return "timeout";
+  if (error instanceof JevResponseError) return "invalid response";
+  if (error instanceof JevRequestError) {
+    switch (error.status) {
+      case 429:
+        return "rate limited (429)";
+      case 529:
+        return "overloaded (529)";
+      case 401:
+        return UNAUTHORIZED_REASON;
+      case 400:
+        return "bad request (400)";
+      case void 0:
+        return "network";
+      default:
+        return error.name;
+    }
+  }
+  if (error instanceof Error) return error.name;
+  return "unknown";
+}
+function everyLine(lines, mode, text, bytesIn) {
+  const decisions = /* @__PURE__ */ new Map();
+  for (const line of lines) decisions.set(line.n, { keep: true, reason: mode });
+  return {
+    mode,
+    kept: text,
+    dropped: [],
+    linesIn: lines.length,
+    linesOut: lines.length,
+    bytesIn,
+    bytesOut: bytesIn,
+    windows: 0,
+    jevRequests: 0,
+    jevInputTokens: 0,
+    decisions
+  };
+}
+
+// src/prune.ts
+async function pruneOutput(input) {
+  const env = input.env ?? process.env;
+  const config = mergeConfig(await loadConfig(env), input.config);
+  const client = input.client !== void 0 ? input.client : clientFromEnv(env);
+  const runId = newRunId();
+  const command = input.command ?? "";
+  const store = input.save === false ? null : new RunStore({ home: config.home, retention: config.retention });
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const selection = await selectLines({
+    text: input.text,
+    task: input.task,
+    command,
+    exitCode: input.exitCode ?? null,
+    client,
+    config,
+    runId
+  });
+  const recorded = await recordRun({
+    store,
+    selection,
+    logText: input.text,
+    meta: {
+      id: runId,
+      command,
+      argv: [],
+      startedAt,
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exitCode: input.exitCode ?? null,
+      signal: null,
+      bytes: selection.bytesIn,
+      lines: selection.linesIn,
+      task: input.task
+    }
+  });
+  return {
+    kept: selection.kept,
+    dropped: selection.dropped,
+    runId,
+    mode: selection.mode,
+    linesIn: selection.linesIn,
+    linesOut: selection.linesOut,
+    ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {},
+    ...recorded.logPath !== void 0 ? { logPath: recorded.logPath } : {},
+    footer: recorded.footer
+  };
+}
+async function recordRun(input) {
+  const { store, selection, meta } = input;
+  const fastPath = selection.mode === "fast-path";
+  const log = input.logBytes ?? (input.logText !== void 0 ? Buffer.from(input.logText, "utf8") : void 0);
+  let failureCode = input.storeFailureCode;
+  if (store !== null && failureCode === void 0) {
+    try {
+      if (fastPath) {
+        if (log === void 0) await store.discardRun(meta.id);
+      } else {
+        if (log !== void 0) await writeLog(store, meta.id, log);
+        await store.finalizeRun(meta.id, {
+          ...meta,
+          mode: selection.mode,
+          linesOut: selection.linesOut,
+          ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {}
+        });
+      }
+      await store.appendGain({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        id: meta.id,
+        mode: selection.mode,
+        linesIn: selection.linesIn,
+        linesOut: selection.linesOut,
+        bytesIn: selection.bytesIn,
+        bytesOut: selection.bytesOut,
+        ...selection.fallbackReason !== void 0 ? { reason: selection.fallbackReason } : {}
+      });
+      await store.enforceRetention();
+    } catch (error) {
+      if (!(error instanceof RunStoreError)) throw error;
+      failureCode = error.code ?? "failed";
+    }
+  }
+  const logPath = store !== null && !fastPath && failureCode === void 0 ? store.logPath(meta.id) : void 0;
+  const footer = formatFooter({
+    mode: selection.mode,
+    linesIn: selection.linesIn,
+    linesOut: selection.linesOut,
+    exitCode: meta.exitCode,
+    ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {},
+    ...input.passthroughNote !== void 0 ? { passthroughNote: input.passthroughNote } : {},
+    ...failureCode !== void 0 ? { storeFailureCode: failureCode } : {},
+    ...logPath !== void 0 ? { logPath } : {}
+  });
+  return { footer, ...logPath !== void 0 ? { logPath } : {} };
+}
+function clientFromEnv(env) {
+  try {
+    return createJevClientFromEnv(env);
+  } catch (error) {
+    if (error instanceof JevConfigError) return null;
+    throw error;
+  }
+}
+function mergeConfig(base, overrides) {
+  if (overrides === void 0) return base;
+  const defined = {};
+  for (const key of Object.keys(overrides)) {
+    if (overrides[key] !== void 0) Object.assign(defined, { [key]: overrides[key] });
+  }
+  return { ...base, ...defined };
+}
+async function writeLog(store, id, bytes) {
+  const writer = await store.openRun({ id });
+  writer.write(bytes);
+  await writer.close();
+  if (writer.failure !== void 0) throw writer.failure;
+}
+
+// src/runner.ts
+import { spawn } from "child_process";
+import { constants } from "os";
+var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var TAIL_RING_BYTES = 256 * 1024;
+var LF3 = 10;
+var CR2 = 13;
+var LineCounter = class {
+  #terminators = 0;
+  #pendingCr = false;
+  #lastByte;
+  push(chunk) {
+    for (const byte of chunk) {
+      if (this.#pendingCr) {
+        this.#pendingCr = false;
+        this.#terminators += 1;
+        if (byte === LF3) {
+          this.#lastByte = byte;
+          continue;
+        }
+      }
+      if (byte === CR2) {
+        this.#pendingCr = true;
+        this.#lastByte = byte;
+        continue;
+      }
+      if (byte === LF3) this.#terminators += 1;
+      this.#lastByte = byte;
+    }
+  }
+  get terminators() {
+    return this.#terminators + (this.#pendingCr ? 1 : 0);
+  }
+  get lines() {
+    if (this.#lastByte === void 0) return 0;
+    const endsWithTerminator = this.#lastByte === LF3 || this.#lastByte === CR2;
+    return this.terminators + (endsWithTerminator ? 0 : 1);
+  }
+};
+var CaptureBuffer = class {
+  #maxBytes;
+  #head = [];
+  #ring = [];
+  #headCounter = new LineCounter();
+  #headBytes = 0;
+  #ringBytes = 0;
+  #oversize = false;
+  constructor(maxBytes) {
+    this.#maxBytes = maxBytes;
+  }
+  get oversize() {
+    return this.#oversize;
+  }
+  get headSegmentLines() {
+    return this.#oversize ? this.#headCounter.terminators : this.#headCounter.lines;
+  }
+  push(chunk) {
+    let rest = chunk;
+    if (!this.#oversize) {
+      const room = this.#maxBytes - this.#headBytes;
+      if (rest.length <= room) {
+        this.#head.push(rest);
+        this.#headCounter.push(rest);
+        this.#headBytes += rest.length;
+        return;
+      }
+      if (room > 0) {
+        const head = rest.subarray(0, room);
+        this.#head.push(head);
+        this.#headCounter.push(head);
+        this.#headBytes += room;
+        rest = rest.subarray(room);
+      }
+      this.#oversize = true;
+    }
+    this.#ring.push(rest);
+    this.#ringBytes += rest.length;
+    this.#trimRing();
+  }
+  bytes() {
+    if (!this.#oversize) return Buffer.concat(this.#head);
+    const head = trimToLastTerminator(Buffer.concat(this.#head));
+    const tail = trimToFirstLine(Buffer.concat(this.#ring));
+    return Buffer.concat([head, tail]);
+  }
+  #trimRing() {
+    while (this.#ringBytes > TAIL_RING_BYTES) {
+      const first = this.#ring[0];
+      if (first === void 0) return;
+      const excess = this.#ringBytes - TAIL_RING_BYTES;
+      if (first.length <= excess) {
+        this.#ring.shift();
+        this.#ringBytes -= first.length;
+      } else {
+        this.#ring[0] = first.subarray(excess);
+        this.#ringBytes -= excess;
+      }
+    }
+  }
+};
+async function runCommand(input) {
+  const executable = input.argv[0];
+  if (executable === void 0 || executable.length === 0) {
+    throw new UsageError("run needs a command to execute");
+  }
+  const writer = await openWriter2(input);
+  const buffer = new CaptureBuffer(input.maxPruneBytes);
+  const counter = new LineCounter();
+  let bytes = 0;
+  let storeFailure = writer.failure;
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const child = spawn(executable, input.argv.slice(1), {
+    stdio: ["inherit", "pipe", "pipe"],
+    shell: false,
+    ...input.cwd !== void 0 ? { cwd: input.cwd } : {},
+    ...input.env !== void 0 ? { env: input.env } : {}
+  });
+  let paused = false;
+  const onChunk = (chunk) => {
+    bytes += chunk.length;
+    counter.push(chunk);
+    buffer.push(chunk);
+    const ready = writer.write(chunk);
+    if (ready || paused) return;
+    paused = true;
+    child.stdout.pause();
+    child.stderr.pause();
+    writer.onDrain(() => {
+      paused = false;
+      child.stdout.resume();
+      child.stderr.resume();
+    });
+  };
+  child.stdout.on("data", onChunk);
+  child.stderr.on("data", onChunk);
+  let receivedSignal = false;
+  const handlers = installSignalHandlers(child, (signal) => {
+    receivedSignal = true;
+    input.onSignalForward?.(signal);
+  });
+  let exit;
+  try {
+    exit = await waitForExit(child, executable);
+  } finally {
+    removeSignalHandlers(handlers);
+    await writer.close();
+  }
+  storeFailure = writer.failure ?? storeFailure;
+  const captured = buffer.bytes();
+  return {
+    captured,
+    validUtf8: isValidUtf8(captured),
+    bytes,
+    lines: counter.lines,
+    headSegmentLines: buffer.headSegmentLines,
+    exitCode: exitCodeOf(exit),
+    signal: exit.signal,
+    interrupted: receivedSignal || exit.signal !== null,
+    oversize: buffer.oversize,
+    startedAt,
+    endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...storeFailure !== void 0 ? { storeFailure } : {}
+  };
+}
+var NO_WRITER = {
+  path: "",
+  failure: void 0,
+  write: () => true,
+  onDrain: (listener) => {
+    queueMicrotask(listener);
+  },
+  close: () => Promise.resolve()
+};
+async function openWriter2(input) {
+  if (input.store === null) return NO_WRITER;
+  try {
+    return await input.store.openRun({ id: input.runId });
+  } catch (error) {
+    const failure = error instanceof RunStoreError ? error : new RunStoreError(`run log could not be opened: ${errorMessage(error)}`, { cause: error });
+    return { ...NO_WRITER, failure };
+  }
+}
+function waitForExit(child, executable) {
+  return new Promise((resolve2, reject) => {
+    child.on("error", (error) => {
+      reject(spawnError(error, executable));
+    });
+    child.on("close", (code, signal) => {
+      resolve2({ code, signal });
+    });
+  });
+}
+function spawnError(error, executable) {
+  const code = errorCode(error);
+  const message = code === "ENOENT" ? `command not found: ${executable}` : code === "EACCES" ? `command not executable: ${executable}` : `command could not start: ${executable}: ${errorMessage(error)}`;
+  return new SpawnError(message, {
+    executable,
+    ...code !== void 0 ? { code } : {},
+    cause: error
+  });
+}
+function installSignalHandlers(child, onForward) {
+  const handlers = /* @__PURE__ */ new Map();
+  for (const signal of FORWARDED_SIGNALS) {
+    const handler = () => {
+      onForward(signal);
+      child.kill(signal);
+    };
+    process.on(signal, handler);
+    handlers.set(signal, handler);
+  }
+  return handlers;
+}
+function removeSignalHandlers(handlers) {
+  for (const [signal, handler] of handlers) process.off(signal, handler);
+}
+function exitCodeOf(exit) {
+  if (exit.code !== null) return exit.code;
+  if (exit.signal !== null) return 128 + (constants.signals[exit.signal] ?? 0);
+  return 0;
+}
+function trimToLastTerminator(buffer) {
+  for (let index = buffer.length - 1; index >= 0; index -= 1) {
+    const byte = buffer[index];
+    if (byte === LF3 || byte === CR2) return buffer.subarray(0, index + 1);
+  }
+  return buffer.subarray(0, 0);
+}
+function trimToFirstLine(buffer) {
+  for (let index = 0; index < buffer.length; index += 1) {
+    const byte = buffer[index];
+    if (byte === LF3) return buffer.subarray(index + 1);
+    if (byte === CR2) {
+      const next = buffer[index + 1];
+      return buffer.subarray(next === LF3 ? index + 2 : index + 1);
+    }
+  }
+  return Buffer.alloc(0);
+}
+
+// src/task.ts
+import { readFile as readFile3 } from "fs/promises";
+var MAX_TASK_LENGTH = 400;
+async function resolveTask(input) {
+  const flag = input.flag?.trim() ?? "";
+  if (flag.length > 0) return { task: flag, source: "flag" };
+  const fromEnv = input.env?.[TASK_ENV]?.trim() ?? "";
+  if (fromEnv.length > 0) return { task: fromEnv, source: "env" };
+  if (input.transcriptPath !== void 0 && input.transcriptPath.length > 0) {
+    const fromTranscript = await readTranscriptTask(input.transcriptPath).catch((error) => {
+      if (error instanceof TranscriptError) return null;
+      throw error;
+    });
+    if (fromTranscript !== null) return { task: fromTranscript, source: "transcript" };
+  }
+  return { task: input.command, source: "command" };
+}
+async function readTranscriptTask(path) {
+  let raw;
+  try {
+    raw = await readFile3(path, "utf8");
+  } catch (error) {
+    throw new TranscriptError(`transcript ${path} could not be read: ${errorMessage(error)}`, {
+      path,
+      cause: error
+    });
+  }
+  for (const line of raw.split("\n")) {
+    if (line.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const text = userText(parsed);
+    if (text !== null) return text;
+  }
+  return null;
+}
+function userText(entry2) {
+  if (!isRecord6(entry2) || entry2["type"] !== "user") return null;
+  const message = entry2["message"];
+  if (!isRecord6(message)) return null;
+  const content = message["content"];
+  if (typeof content === "string") return usableText(content);
+  if (!Array.isArray(content)) return null;
+  for (const item of content) {
+    if (!isRecord6(item) || item["type"] !== "text") continue;
+    const text = item["text"];
+    if (typeof text !== "string") continue;
+    const usable = usableText(text);
+    if (usable !== null) return usable;
+  }
+  return null;
+}
+function usableText(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("<")) return null;
+  return trimmed.slice(0, MAX_TASK_LENGTH);
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/commands/run.ts
+async function runRun(options, io) {
+  if (options.argv.length === 0) throw new UsageError("run needs a command after --");
+  const loaded = await loadConfig(io.env);
+  const config = options.threshold !== void 0 ? { ...loaded, threshold: options.threshold } : loaded;
+  const store = new RunStore({ home: config.home, retention: config.retention });
+  const runId = newRunId();
+  const command = options.argv.join(" ");
+  const transcriptPath = options.hook === true ? options.transcript : void 0;
+  const { task } = await resolveTask({
+    ...options.task !== void 0 ? { flag: options.task } : {},
+    env: io.env,
+    ...transcriptPath !== void 0 ? { transcriptPath } : {},
+    command
+  });
+  const client = clientFromEnv(io.env);
+  if (options.hook === true && client === null && await shouldAnnounceMissingKey(config.home)) {
+    await io.writeError(`jevprune: ${TYPESAFE_API_KEY_ENV} not set, using fallback
+`).catch(() => void 0);
+  }
+  const capture = await runCommand({
+    argv: options.argv,
+    runId,
+    store,
+    maxPruneBytes: config.maxPruneBytes,
+    cwd: io.cwd,
+    env: io.env
+  });
+  const meta = {
+    id: runId,
+    command,
+    argv: [...options.argv],
+    startedAt: capture.startedAt,
+    endedAt: capture.endedAt,
+    exitCode: capture.exitCode,
+    signal: capture.signal,
+    bytes: capture.bytes,
+    lines: capture.lines,
+    task
+  };
+  const failed = capture.exitCode !== 0 || capture.interrupted;
+  if (!capture.validUtf8 || capture.oversize && failed) {
+    return await passThrough({ capture, store, meta, maxPruneBytes: config.maxPruneBytes }, io);
+  }
+  try {
+    const selection = await selectLines({
+      text: capture.captured.toString("utf8"),
+      task,
+      command,
+      exitCode: capture.exitCode,
+      interrupted: capture.interrupted,
+      ...capture.oversize ? { oversize: { lines: capture.lines, headSegmentLines: capture.headSegmentLines } } : {},
+      client,
+      config,
+      runId
+    });
+    if (options.hook === true && selection.fallbackReason === UNAUTHORIZED_REASON) {
+      await io.writeError(`jevprune: ${TYPESAFE_API_KEY_ENV} rejected (401), using fallback
+`).catch(() => void 0);
+    }
+    const { footer } = await recordRun({
+      store,
+      selection,
+      meta,
+      ...capture.storeFailure !== void 0 ? { storeFailureCode: capture.storeFailure.code ?? "failed" } : {}
+    });
+    await io.write(withFooter(selection.kept, footer));
+  } catch (error) {
+    await io.writeBytes(capture.captured).catch(() => void 0);
+    await io.writeError(`jevprune: pruning failed (${errorName(error)}), output passed through
+`).catch(() => void 0);
+  }
+  return capture.exitCode;
+}
+async function passThrough(input, io) {
+  const { capture } = input;
+  let storeFailureCode = capture.storeFailure === void 0 ? void 0 : capture.storeFailure.code ?? "failed";
+  let written = 0;
+  let lastByte;
+  let complete = false;
+  if (capture.oversize && storeFailureCode === void 0) {
+    try {
+      for await (const chunk of input.store.readRunChunks(input.meta.id)) {
+        await io.writeBytes(chunk).catch(() => void 0);
+        if (chunk.length === 0) continue;
+        written += chunk.length;
+        lastByte = chunk[chunk.length - 1];
+      }
+      complete = true;
+    } catch (error) {
+      storeFailureCode = error instanceof RunStoreError ? error.code ?? "failed" : "failed";
+    }
+  }
+  if (!complete && written === 0) {
+    await io.writeBytes(capture.captured).catch(() => void 0);
+    lastByte = capture.captured.at(-1);
+    complete = !capture.oversize;
+  }
+  const oversizeReason = `output over ${String(input.maxPruneBytes)} bytes`;
+  const reason = capture.validUtf8 ? complete ? void 0 : oversizeReason : NOT_UTF8_REASON;
+  const note = capture.validUtf8 ? reason : NOT_UTF8_NOTE;
+  try {
+    const { footer } = await recordRun({
+      store: input.store,
+      selection: passthroughSelection({
+        bytes: capture.bytes,
+        lines: capture.lines,
+        ...reason !== void 0 ? { reason } : {}
+      }),
+      ...note !== void 0 ? { passthroughNote: note } : {},
+      meta: input.meta,
+      ...storeFailureCode !== void 0 ? { storeFailureCode } : {}
+    });
+    await io.write(footerAfter(lastByte, footer)).catch(() => void 0);
+  } catch (error) {
+    await io.writeError(`jevprune: pruning failed (${errorName(error)}), output passed through
+`).catch(() => void 0);
+  }
+  return capture.exitCode;
+}
+
+// src/commands/select.ts
+import { readFile as readFile4 } from "fs/promises";
+async function runSelect(options, io) {
+  let input;
+  try {
+    input = options.file !== void 0 ? await readFile4(options.file) : await readStreamBytes(io.stdin);
+  } catch (error) {
+    await io.writeError(`jevprune: input could not be read: ${errorMessage(error)}
+`);
+    return 1;
+  }
+  const command = options.command ?? "";
+  const { task } = await resolveTask({
+    ...options.task !== void 0 ? { flag: options.task } : {},
+    env: io.env,
+    command
+  });
+  if (!isValidUtf8(input)) {
+    return await passThrough2({ bytes: input, task, command, env: io.env }, io);
+  }
+  const result = await pruneOutput({
+    text: input.toString("utf8"),
+    task,
+    command,
+    exitCode: null,
+    env: io.env,
+    ...options.threshold !== void 0 ? { config: { threshold: options.threshold } } : {}
+  });
+  await io.write(withFooter(result.kept, result.footer));
+  return 0;
+}
+async function passThrough2(input, io) {
+  const config = await loadConfig(input.env);
+  const store = new RunStore({ home: config.home, retention: config.retention });
+  const lines = countByteLines(input.bytes);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const { footer } = await recordRun({
+    store,
+    selection: passthroughSelection({ bytes: input.bytes.length, lines, reason: NOT_UTF8_REASON }),
+    logBytes: input.bytes,
+    passthroughNote: NOT_UTF8_NOTE,
+    meta: {
+      id: newRunId(),
+      command: input.command,
+      argv: [],
+      startedAt,
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exitCode: null,
+      signal: null,
+      bytes: input.bytes.length,
+      lines,
+      task: input.task
+    }
+  });
+  await io.writeBytes(input.bytes);
+  await io.write(footerAfter(input.bytes.at(-1), footer));
+  return 0;
+}
+
+// src/commands/show.ts
+function parseLineRange(value) {
+  const match = /^(\d+)[-:](\d+)$/.exec(value.trim());
+  if (match === null) {
+    throw new LineRangeError(`--lines must be A-B or A:B, got ${JSON.stringify(value)}`);
+  }
+  const from = Number(match[1] ?? "");
+  const to = Number(match[2] ?? "");
+  if (from < 1 || to < from) {
+    throw new LineRangeError(`--lines must be a range with 1 <= A <= B, got ${JSON.stringify(value)}`);
+  }
+  return { from, to };
+}
+async function runShow(options, io) {
+  const config = await loadConfig(io.env);
+  const store = new RunStore({ home: config.home, retention: config.retention });
+  if (options.lines === void 0) {
+    await io.writeBytes(await store.readRunBytes(options.id));
+    return 0;
+  }
+  const range2 = parseLineRange(options.lines);
+  await io.writeBytes(await store.readRunLineBytes(options.id, range2.from, range2.to));
+  return 0;
+}
+
+// src/version.ts
+var VERSION2 = "0.1.0";
+
+// src/cli.ts
+var HELP = `usage: jevprune <command> [options]
+
+commands:
+  run [--task <text>] [--threshold <n>] [--hook] [--transcript <path>] -- <command> [args...]
+  select [--task <text>] [--threshold <n>] [--file <path>] [--command <text>]
+  show <id> [--lines A-B]
+  gain
+  hook
+
+options:
+  --help
+  --version
+`;
+async function runCli(argv, io) {
+  try {
+    return await dispatch(argv, io);
+  } catch (error) {
+    return await report(error, io);
+  }
+}
+async function dispatch(argv, io) {
+  const separator = argv.indexOf("--");
+  const own = separator === -1 ? [...argv] : argv.slice(0, separator);
+  const rest = separator === -1 ? [] : argv.slice(separator + 1);
+  const command = own[0];
+  if (command === void 0) {
+    await io.writeError(HELP);
+    return 2;
+  }
+  if (command === "--help" || command === "-h" || command === "help") {
+    await io.write(HELP);
+    return 0;
+  }
+  if (command === "--version" || command === "-v") {
+    await io.write(`${VERSION2}
+`);
+    return 0;
+  }
+  const args = own.slice(1);
+  switch (command) {
+    case "run": {
+      const values = parse(args, {
+        task: { type: "string" },
+        threshold: { type: "string" },
+        hook: { type: "boolean" },
+        transcript: { type: "string" }
+      });
+      return await runRun(
+        {
+          argv: rest,
+          task: values.task,
+          threshold: values.threshold === void 0 ? void 0 : parseThreshold(values.threshold),
+          hook: values.hook,
+          transcript: values.transcript
+        },
+        io
+      );
+    }
+    case "select": {
+      const values = parse(args, {
+        task: { type: "string" },
+        threshold: { type: "string" },
+        file: { type: "string" },
+        command: { type: "string" }
+      });
+      return await runSelect(
+        {
+          task: values.task,
+          threshold: values.threshold === void 0 ? void 0 : parseThreshold(values.threshold),
+          file: values.file,
+          command: values.command
+        },
+        io
+      );
+    }
+    case "show": {
+      const parsed = parseWithPositionals(args, { lines: { type: "string" } });
+      const id = parsed.positionals[0];
+      if (id === void 0) throw new UsageError("show needs a run id");
+      if (parsed.positionals.length > 1) {
+        throw new UsageError(`show takes one run id, got ${String(parsed.positionals.length)}`);
+      }
+      return await runShow(
+        { id, ...parsed.values.lines !== void 0 ? { lines: parsed.values.lines } : {} },
+        io
+      );
+    }
+    case "gain": {
+      parse(args, {});
+      return await runGain(io);
+    }
+    case "hook": {
+      parse(args, {});
+      return await runHook(io);
+    }
+    default:
+      throw new UsageError(`unknown command "${command}"`);
+  }
+}
+function parse(args, options) {
+  try {
+    return parseArgs({ args: [...args], options, strict: true, allowPositionals: false }).values;
+  } catch (error) {
+    throw new UsageError(errorMessage(error), { cause: error });
+  }
+}
+function parseWithPositionals(args, options) {
+  try {
+    return parseArgs({ args: [...args], options, strict: true, allowPositionals: true });
+  } catch (error) {
+    throw new UsageError(errorMessage(error), { cause: error });
+  }
+}
+async function report(error, io) {
+  if (error instanceof SpawnError) {
+    await io.writeError(`jevprune: ${error.message}
+`);
+    if (error.code === "ENOENT") return 127;
+    if (error.code === "EACCES") return 126;
+    return 1;
+  }
+  if (error instanceof UsageError || error instanceof ConfigError) {
+    await io.writeError(`jevprune: ${error.message}
+`);
+    return 2;
+  }
+  if (error instanceof JevpruneError) {
+    await io.writeError(`jevprune: ${error.message}
+`);
+    return 1;
+  }
+  await io.writeError(`jevprune: ${errorMessage(error)}
+`);
+  return 1;
+}
+function entryUrl(path) {
+  try {
+    return pathToFileURL(realpathSync(path)).href;
+  } catch {
+    return "";
+  }
+}
+var entry = process.argv[1];
+if (entry !== void 0 && import.meta.url === entryUrl(entry)) {
+  process.exitCode = await runCli(process.argv.slice(2), processIo());
+}
+export {
+  runCli
+};