@garygentry/system1 0.4.0 → 0.5.0

package/dist/bundle/chunks/chunk-45YUIPYC.mjs

@@ -0,0 +1,914 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  DEFAULT_ENDPOINT,
+  DEFAULT_MODEL_ID,
+  ENTRY_FIELDS,
+  PACK_NAMES,
+  activeTriggers,
+  allProfiles,
+  assertConsent,
+  assertExamples,
+  backlogPath,
+  checkBudget,
+  checkInput,
+  combineProjections,
+  createContext,
+  deciderFor,
+  describeExpectation,
+  detectHarness,
+  exampleFileProblem,
+  ledgerFor,
+  lintSpec,
+  listSpecs,
+  loadConfig,
+  loadSpec,
+  mapWithConcurrency,
+  meets,
+  mergeCandidates,
+  parseExpect,
+  parseFileRef,
+  parseRecordFilter,
+  parseRecordSort,
+  parseSplit,
+  prepare,
+  project,
+  readBacklog,
+  readField,
+  recordMatches,
+  resolveProfile,
+  resolveRequest,
+  route,
+  sumUsage,
+  unquoteKey,
+  userConfigDir,
+  verdictOf,
+  withBacklogLock,
+  writeBacklog
+} from "./chunk-TMAJXDTE.mjs";
+import {
+  CLI_PACKAGE,
+  VERSION
+} from "./chunk-7OZLIHEM.mjs";
+import {
+  DecisionsError,
+  isDecisionsError
+} from "./chunk-MH6THLCO.mjs";
+
+// ../core/dist/ping.js
+function probeUrl(config) {
+  const origin = new URL(config.endpoint).origin;
+  return `${origin}/api/v1/models/${config.model}/endpoints`;
+}
+async function ping(config, options = {}) {
+  const doFetch = options.fetch ?? fetch;
+  const probe = probeUrl(config);
+  const base = {
+    model: config.model,
+    endpoint: config.endpoint,
+    probe,
+    keyPresent: config.apiKey !== void 0
+  };
+  const started = performance.now();
+  try {
+    const response = await doFetch(probe, {
+      signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
+    });
+    const latencyMs = Math.round(performance.now() - started);
+    if (!response.ok) {
+      return {
+        ...base,
+        ok: false,
+        latencyMs,
+        httpStatus: response.status,
+        error: `HTTP ${response.status}`
+      };
+    }
+    const body = await response.json();
+    const contextLength = body.data?.endpoints?.[0]?.context_length;
+    return {
+      ...base,
+      ok: true,
+      latencyMs,
+      httpStatus: response.status,
+      ...typeof contextLength === "number" ? { contextLength } : {}
+    };
+  } catch (error) {
+    return { ...base, ok: false, error: describe(error) };
+  }
+}
+function describe(error) {
+  if (error instanceof Error) {
+    const cause = error.cause;
+    return cause instanceof Error ? `${error.message}: ${cause.message}` : error.message;
+  }
+  return String(error);
+}
+
+// ../core/dist/tools/many.js
+var EXCERPT = 120;
+var SAMPLE = 5;
+async function runMany(ctx, rawInput) {
+  const input = checkInput("many", rawInput);
+  const started = performance.now();
+  const req = resolveRequest(ctx, input);
+  const prepared = await prepare({
+    sources: req.sources,
+    split: req.split,
+    questions: req.questions,
+    profile: req.profile,
+    cwd: ctx.config.repoRoot,
+    exclude: ctx.config.egress.exclude,
+    filter: req.exclude,
+    oversize: "skip",
+    ...input.allowOutside ? { allowOutside: true } : {}
+  });
+  const base = {
+    ...req.spec ? { spec: req.spec.name } : {},
+    model: req.profile.id,
+    skipped: summariseSkipped(prepared.skipped),
+    redactions: { total: prepared.redactions.total, items: prepared.redactions.items },
+    projection: prepared.projection
+  };
+  if (input.dryRun) {
+    return {
+      ...base,
+      dryRun: true,
+      counts: counts(prepared.items.length, 0, 0, 0, 0, 0, prepared.skipped.length),
+      kept: [],
+      undecided: [],
+      failed: [],
+      usage: sumUsage([]),
+      wallClockMs: Math.round(performance.now() - started),
+      sampleIds: prepared.items.slice(0, SAMPLE).map((i) => i.id)
+    };
+  }
+  const decider = deciderFor(ctx, req.profile, input.mode ?? "auto");
+  if (decider.mode !== "replay") {
+    assertConsent(ctx.config.egress.consent, ctx.config.repoRoot);
+    checkBudget(prepared.projection, ctx.config.budget, input.confirm ?? false);
+  }
+  const concurrency = Math.min(input.concurrency ?? ctx.config.concurrency, ctx.config.concurrency);
+  const settled = await mapWithConcurrency(prepared.items, concurrency, (item) => decider.decide({ state: item.state, questions: req.questions, namespace: req.namespace }));
+  const done = [];
+  const failed = [];
+  settled.forEach((outcome, i) => {
+    const item = prepared.items[i];
+    if ("value" in outcome)
+      done.push({ item, result: outcome.value });
+    else
+      failed.push({ id: item.id, ...describe2(outcome.error) });
+  });
+  const [first] = failed;
+  if (done.length === 0 && first && failed.every((f) => f.code === first.code)) {
+    const { error } = settled.find((s) => "error" in s);
+    const details = isDecisionsError(error) ? error.details : {};
+    throw new DecisionsError(first.code === "error" ? "invalid-request" : first.code, failed.length === 1 ? error.message : `All ${failed.length} items failed: ${error.message}`, { ...details, failed: failed.length });
+  }
+  const rows = done.map(({ item, result }) => ({
+    ...row(item, result.answers),
+    flat: result.undecided
+  }));
+  const projected = project({
+    rows,
+    keep: req.keep,
+    keepAny: req.keepAny,
+    ...req.sort ? { sort: req.sort } : {},
+    ...input.limit !== void 0 ? { limit: input.limit } : {},
+    ...input.fields ? { fields: input.fields } : {},
+    undecidedOf: (r) => r.flat
+  });
+  const strip = ({ flat, ...rest }) => ({
+    ...rest,
+    ...flat.length ? { undecided: [...flat] } : {}
+  });
+  return {
+    ...base,
+    dryRun: false,
+    source: decider.mode === "replay" ? "replay" : "live",
+    counts: counts(prepared.items.length, projected.kept.length, projected.keptTotal, projected.undecided.length, projected.dropped, failed.length, prepared.skipped.length),
+    kept: projected.kept.map(strip),
+    undecided: projected.undecided.map(({ row: row2, questions }) => ({ ...strip(row2), questions })),
+    failed,
+    usage: sumUsage(done.map((d) => d.result.usage)),
+    wallClockMs: Math.round(performance.now() - started)
+  };
+}
+function row(item, answers) {
+  return {
+    id: item.id,
+    ...item.path ? { path: item.path } : {},
+    ...item.lines ? { lines: item.lines } : {},
+    ...traceable(item) ? {} : { excerpt: excerpt(item.state) },
+    answers
+  };
+}
+function traceable(item) {
+  if (item.path === void 0)
+    return false;
+  const oneLine = item.lines !== void 0 && item.lines.start === item.lines.end;
+  return item.id === item.path || !oneLine;
+}
+function excerpt(state) {
+  const text = (typeof state === "string" ? state : JSON.stringify(state)).replace(/\s+/g, " ").trim();
+  return text.length > EXCERPT ? `${text.slice(0, EXCERPT - 1)}\u2026` : text;
+}
+function counts(items, kept, keptTotal, undecided, dropped, failed, skipped) {
+  return { items, kept, keptTotal, undecided, dropped, failed, skipped };
+}
+function summariseSkipped(skipped) {
+  const byReason = {};
+  for (const s of skipped)
+    byReason[s.reason] = (byReason[s.reason] ?? 0) + 1;
+  const ordered = [...skipped].sort((a, b) => Number(b.reason === "excluded") - Number(a.reason === "excluded"));
+  return { total: skipped.length, byReason, sample: ordered.slice(0, SAMPLE) };
+}
+function describe2(error) {
+  return isDecisionsError(error) ? { code: error.code, message: error.message } : { code: "error", message: error.message };
+}
+
+// ../core/dist/tools/ask.js
+async function runAsk(ctx, rawInput) {
+  const input = checkInput("ask", rawInput);
+  const req = resolveRequest(ctx, input);
+  const prepared = await prepare({
+    sources: req.sources,
+    split: req.split,
+    questions: req.questions,
+    profile: req.profile,
+    cwd: ctx.config.repoRoot,
+    exclude: ctx.config.egress.exclude,
+    filter: req.exclude,
+    ...input.allowOutside ? { allowOutside: true } : {}
+  });
+  const [item, ...rest] = prepared.items;
+  if (!item || rest.length > 0) {
+    const held = prepared.skipped.filter((s) => s.reason !== "filtered");
+    const left = prepared.skipped.length - held.length;
+    const withheld = (held.length ? ` (${held.length} withheld: ${held.map((s) => `${s.path} ${s.reason}`).join(", ")})` : "") + (left ? ` (${left} left out by --exclude)` : "");
+    throw new DecisionsError("invalid-request", item ? `ask needs exactly one state, but the source gave ${prepared.items.length}. Use \`decide many\` to fan out.` : `The source gave nothing to ask about${withheld}.`, { items: prepared.items.length });
+  }
+  const result = await deciderFor(ctx, req.profile, input.mode ?? "auto").decide({
+    state: item.state,
+    questions: req.questions,
+    namespace: req.namespace
+  });
+  const verdict = req.keep.length > 0 || req.keepAny.length > 0 ? verdictOf(result.answers, result.undecided, req.keep, req.keepAny).verdict : void 0;
+  return {
+    ...req.spec ? { spec: req.spec.name } : {},
+    id: item.id,
+    ...item.path ? { path: item.path } : {},
+    ...item.lines ? { lines: item.lines } : {},
+    source: result.source,
+    model: result.model,
+    servedBy: result.servedBy,
+    answers: result.answers,
+    undecided: result.undecided,
+    ...verdict ? { verdict } : {},
+    usage: result.usage,
+    latencyMs: result.latencyMs,
+    skipped: summariseSkipped(prepared.skipped),
+    redactions: { total: prepared.redactions.total, items: prepared.redactions.items }
+  };
+}
+
+// ../core/dist/tools/doctor.js
+import { accessSync, constants, existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+function guardCheck(config, env, home, cliPath) {
+  const enabled = PACK_NAMES.filter((name) => config.guard.packs[name].enabled);
+  if (enabled.length === 0)
+    return { name: "guard", status: "ok", detail: "no guard pack enabled (all dormant)" };
+  if (!config.egress.consent.granted) {
+    return {
+      name: "guard",
+      status: "warn",
+      detail: `${enabled.join(", ")} enabled, but this repo has no egress consent: dormant`,
+      fix: "grant consent (see the consent check), or turn it off with `decide guard disable <pack>`",
+      // The consent check already stands between this shell and a live decision.
+      advisory: true
+    };
+  }
+  const codex = codexHookTrust(env, home);
+  if (codex === "untrusted") {
+    return {
+      name: "guard",
+      status: "warn",
+      detail: `active: ${enabled.join(", ")}; but Codex hasn't trusted the system1 hooks, so it skips them without a word`,
+      fix: "open Codex interactively in this repo once and trust the system1 hooks when it asks (after a plugin update it may ask again)",
+      advisory: true
+    };
+  }
+  if (cliPath && /[\\/]_npx[\\/]/.test(cliPath)) {
+    return {
+      name: "guard",
+      status: "warn",
+      detail: `active: ${enabled.join(", ")}; but decide runs from npx's cache, which the hooks never download into: after a plugin update or an npm cache clean, the check is skipped silently until decide runs once`,
+      fix: "npm i -g @garygentry/system1",
+      advisory: true
+    };
+  }
+  return { name: "guard", status: "ok", detail: `active: ${enabled.join(", ")}` };
+}
+function codexHookTrust(env, home = homedir()) {
+  const file = join(env.CODEX_HOME?.trim() || join(home, ".codex"), "config.toml");
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return "absent";
+  }
+  const section = (header) => {
+    const out = [];
+    const lines = text.split(/\r?\n/);
+    lines.forEach((line, n) => {
+      if (!header.test(line))
+        return;
+      const body = [];
+      for (const next of lines.slice(n + 1)) {
+        if (/^\s*\[/.test(next))
+          break;
+        body.push(next);
+      }
+      out.push(body.join("\n"));
+    });
+    return out;
+  };
+  const plugin = section(/^\s*\[plugins\."system1@[^"]+"\]\s*$/);
+  if (plugin.length === 0 || plugin.every((b) => /^\s*enabled\s*=\s*false\b/m.test(b))) {
+    return "absent";
+  }
+  const trust = section(/^\s*\[hooks\.state\."system1@[^"]+:[^"]*codex-hooks\.json:stop:[^"]*"\]\s*$/);
+  return trust.some((b) => /^\s*trusted_hash\s*=/m.test(b)) ? "trusted" : "untrusted";
+}
+function routeCheck(config) {
+  try {
+    route("", config);
+    if (!config.enabled) {
+      return {
+        name: "route",
+        status: "ok",
+        detail: "routing hints are off (route.enabled or SYSTEM1_ROUTE)"
+      };
+    }
+    const names = activeTriggers(config).map((t) => t.name);
+    return {
+      name: "route",
+      status: "ok",
+      detail: `routing hints on: ${names.length ? names.join(", ") : "no triggers"}`
+    };
+  } catch (error) {
+    return {
+      name: "route",
+      status: "warn",
+      detail: `routing hints are silent: ${error instanceof Error ? error.message : String(error)}`,
+      fix: 'correct route: in the config file (test it with `decide route --text "\u2026"`)'
+    };
+  }
+}
+function backlogProblem(error) {
+  const problems = isDecisionsError(error) ? error.details?.problems : void 0;
+  const first = Array.isArray(problems) ? problems[0] : void 0;
+  const count = Array.isArray(problems) && problems.length > 1 ? ` (+${problems.length - 1} more)` : "";
+  return `the backlog doesn't validate: ${first ?? (error instanceof Error ? error.message : String(error))}${count}`;
+}
+function backlogCheck(repoRoot) {
+  const file = backlogPath(repoRoot);
+  if (!existsSync(file))
+    return { name: "backlog", status: "ok", detail: "no scout backlog yet" };
+  try {
+    const { opportunities } = readBacklog(file);
+    return {
+      name: "backlog",
+      status: "ok",
+      detail: `${opportunities.length} opportunit${opportunities.length === 1 ? "y" : "ies"} in ${file}`
+    };
+  } catch (error) {
+    return {
+      name: "backlog",
+      status: "warn",
+      detail: backlogProblem(error),
+      fix: "`decide opportunities check` lists every problem; correct the file by hand or move it aside (decide never repairs it)"
+    };
+  }
+}
+var CODEX_RULE = 'prefix_rule(pattern = ["decide"], decision = "allow")';
+async function runDoctor(options) {
+  const { env } = options;
+  const harness = detectHarness(env) ?? null;
+  const checks = [
+    {
+      name: "cli",
+      status: "ok",
+      detail: `decide ${VERSION} on node ${process.version}${options.cliPath ? ` (${options.cliPath})` : ""}`
+    },
+    pathCheck(harness, env)
+  ];
+  const onPath = which("decide", env.PATH ?? "");
+  if (onPath && options.probeVersion) {
+    checks.push(await versionCheck(onPath, options.probeVersion, env));
+  }
+  const report = (ctx2, live2) => ({
+    healthy: !checks.some((c) => c.status === "fail"),
+    live: live2,
+    harness,
+    session: ctx2?.config.session ?? null,
+    version: VERSION,
+    node: process.version,
+    checks
+  });
+  let ctx;
+  try {
+    ctx = createContext(options);
+  } catch (error) {
+    checks.push({
+      name: "config",
+      status: "fail",
+      detail: error instanceof Error ? error.message : String(error),
+      fix: "correct the config file or environment variable named above"
+    });
+    return report(void 0, false);
+  }
+  const { config } = ctx;
+  if (config.warnings.length > 0) {
+    checks.push({
+      name: "config-keys",
+      status: "warn",
+      detail: `ignored: ${config.warnings.join("; ")}`,
+      fix: "correct or remove these keys (docs/configuration.md lists every key)"
+    });
+  }
+  const credentials = join(userConfigDir(env, options.home), "credentials");
+  checks.push(config.apiKey && config.apiKeyQuoted ? {
+    name: "key",
+    status: "warn",
+    detail: `OPENROUTER_API_KEY present (${config.apiKeySource}), but wrapped in quotes; they were removed`,
+    fix: config.apiKeySource === "env" ? "set OPENROUTER_API_KEY without the surrounding quotes" : `remove the extra quotes around openrouter_api_key in ${credentials}`,
+    advisory: true
+  } : config.apiKey ? {
+    name: "key",
+    status: "ok",
+    detail: `OPENROUTER_API_KEY present (${config.apiKeySource})`
+  } : {
+    name: "key",
+    status: "warn",
+    detail: "no API key: only replay works",
+    // The file this shell would read: XDG_CONFIG_HOME moves it.
+    fix: `set OPENROUTER_API_KEY, or write \`openrouter_api_key: <key>\` to ${credentials} (create its directory first; chmod 600)`
+  });
+  checks.push(config.egress.consent.granted ? { name: "consent", status: "ok", detail: `egress consent granted for ${config.repoRoot}` } : {
+    name: "consent",
+    status: "warn",
+    detail: `no egress consent for ${config.repoRoot}: live calls are refused`,
+    fix: "if the user agrees, they grant it themselves (an agent must not): `decide config egress allow` in a terminal in this repo, or through their agent prompt's shell escape (not as a chat message) with --confirm added"
+  });
+  checks.push(routeCheck(config.route));
+  checks.push(guardCheck(config, env, options.home, options.cliPath));
+  checks.push(backlogCheck(config.repoRoot));
+  let reach;
+  try {
+    reach = await ping({
+      endpoint: config.endpoint,
+      model: config.model,
+      apiKey: config.apiKey,
+      replay: config.replay
+    }, ctx.fetch ? { fetch: ctx.fetch } : {});
+  } catch (error) {
+    checks.push({
+      name: "config",
+      status: "fail",
+      detail: `endpoint ${config.endpoint}: ${error instanceof Error ? error.message : String(error)}`,
+      fix: "correct SYSTEM1_ENDPOINT or `endpoint` in the config file"
+    });
+    return report(ctx, false);
+  }
+  if (reach.ok) {
+    checks.push({
+      name: "network",
+      status: "ok",
+      detail: `${config.model} reachable in ${reach.latencyMs} ms`
+    });
+  } else {
+    const sandboxed = env.CODEX_SANDBOX_NETWORK_DISABLED === "1";
+    checks.push({
+      name: "network",
+      // Replay needs no network, so an unreachable endpoint only warns there.
+      status: config.replay ? "warn" : "fail",
+      detail: `${reach.probe}: ${reach.error ?? "unreachable"}${sandboxed ? " (Codex sandbox has network disabled)" : ""}`,
+      fix: networkFix(reach.httpStatus, harness, sandboxed, env)
+    });
+  }
+  const live = !config.replay && config.apiKey !== void 0 && config.egress.consent.granted && reach.ok === true;
+  return report(ctx, live);
+}
+function pathCheck(harness, env) {
+  const onPath = which("decide", env.PATH ?? "");
+  if (onPath)
+    return { name: "path", status: "ok", detail: `decide on PATH: ${onPath}` };
+  if (harness === "claude") {
+    return {
+      name: "path",
+      status: "warn",
+      detail: "decide is not on PATH, so the System 1 plugin's bin/ is not loaded",
+      fix: `npm i -g ${CLI_PACKAGE}@${VERSION} (also puts decide in your own terminal), or install the System 1 plugin from its marketplace`
+    };
+  }
+  return {
+    name: "path",
+    status: "warn",
+    detail: "decide is not on PATH. Codex and Pi do not add plugin bin/ to PATH",
+    fix: `npm i -g ${CLI_PACKAGE}@${VERSION}`
+  };
+}
+async function versionCheck(path, probe, env) {
+  let raw;
+  try {
+    raw = await probe(path);
+  } catch {
+  }
+  const found = raw?.trim() || void 0;
+  if (raw !== void 0 && found === void 0 && env.CODEX_SANDBOX_NETWORK_DISABLED === "1") {
+    return {
+      name: "path-version",
+      status: "ok",
+      detail: "not checked: the Codex sandbox hides a child process's output"
+    };
+  }
+  if (found === void 0) {
+    return {
+      name: "path-version",
+      status: "warn",
+      detail: `could not read the version of ${path}`,
+      fix: `run \`${path} version\` to see why; reinstall it if it fails`
+    };
+  }
+  if (found === VERSION) {
+    return {
+      name: "path-version",
+      status: "ok",
+      detail: `decide on PATH is ${found}, same as this one`
+    };
+  }
+  return {
+    name: "path-version",
+    status: "warn",
+    detail: `decide on PATH is ${found}, but this one is ${VERSION}: agents will run the one on PATH`,
+    fix: `npm i -g ${CLI_PACKAGE}@${VERSION}, or remove the other decide (${path})`
+  };
+}
+function networkFix(httpStatus, harness, sandboxed, env) {
+  if (httpStatus === 404)
+    return "the endpoint does not know this model: check SYSTEM1_MODEL / `model` and SYSTEM1_ENDPOINT / `endpoint`";
+  if (httpStatus !== void 0 && httpStatus >= 500)
+    return `the provider answered HTTP ${httpStatus}: retry later`;
+  if (httpStatus !== void 0)
+    return `the endpoint answered HTTP ${httpStatus}: check SYSTEM1_ENDPOINT / \`endpoint\``;
+  if (sandboxed) {
+    return `add \`${CODEX_RULE}\` to ${env.CODEX_HOME?.trim() || "~/.codex"}/rules/system1.rules, then restart Codex (it covers commands that start with decide; a pipe into decide stays offline)`;
+  }
+  if (harness === "claude")
+    return "allow outbound access to openrouter.ai in Claude Code's sandbox settings";
+  return "check that this machine can reach openrouter.ai (proxy, firewall, DNS)";
+}
+function which(name, path) {
+  for (const dir of path.split(delimiter)) {
+    if (!dir)
+      continue;
+    const candidate = join(dir, name);
+    try {
+      accessSync(candidate, constants.X_OK);
+      if (statSync(candidate).isFile())
+        return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// ../core/dist/tools/opportunities.js
+import { existsSync as existsSync2 } from "node:fs";
+function runOpportunitiesAdd(ctx, rawInput, now = () => /* @__PURE__ */ new Date()) {
+  const input = checkInput("opportunities-add", rawInput);
+  const file = backlogPath(ctx.config.repoRoot);
+  const merged = withBacklogLock(file, () => {
+    const result = mergeCandidates(readBacklog(file), input.candidates, now().toISOString());
+    writeBacklog(file, result.backlog);
+    return result;
+  });
+  return {
+    file,
+    added: merged.added,
+    updated: merged.updated,
+    staled: merged.staled,
+    total: merged.backlog.opportunities.length
+  };
+}
+function runOpportunitiesList(ctx, rawInput = {}) {
+  const input = checkInput("opportunities-list", rawInput);
+  const filters = (input.keep ?? []).map(parseRecordFilter);
+  const sort = parseRecordSort(input.sort ?? "projected:desc");
+  assertFields(input.fields);
+  const file = backlogPath(ctx.config.repoRoot);
+  const { opportunities } = readBacklog(file);
+  const matched = opportunities.filter((o) => filters.every((f) => recordMatches(o, f))).sort((a, b) => compare(readField(a, sort.field), readField(b, sort.field), sort.direction));
+  const shown = input.limit === void 0 ? matched : matched.slice(0, input.limit);
+  return {
+    file,
+    total: opportunities.length,
+    matched: matched.length,
+    basis: "projected",
+    opportunities: shown.map((o) => pick(o, input.fields))
+  };
+}
+function runOpportunitiesCheck(ctx, rawInput = {}) {
+  checkInput("opportunities-check", rawInput);
+  const file = backlogPath(ctx.config.repoRoot);
+  const backlog = readBacklog(file);
+  const byStatus = {};
+  for (const o of backlog.opportunities)
+    byStatus[o.status] = (byStatus[o.status] ?? 0) + 1;
+  return { file, exists: existsSync2(file), entries: backlog.opportunities.length, byStatus };
+}
+function compare(a, b, direction) {
+  if (a === void 0 || b === void 0)
+    return a === b ? 0 : a === void 0 ? 1 : -1;
+  const order = typeof a === "number" && typeof b === "number" ? a - b : String(a).localeCompare(String(b));
+  return direction === "asc" ? order : -order;
+}
+function pick(o, fields) {
+  if (!fields)
+    return o;
+  const out = { id: o.id };
+  for (const f of fields)
+    if (Object.hasOwn(o, f))
+      out[f] = o[f];
+  return out;
+}
+function assertFields(fields = []) {
+  const unknown = fields.filter((f) => !ENTRY_FIELDS.includes(f));
+  if (unknown.length) {
+    throw new DecisionsError("invalid-request", `--fields: no field ${unknown.join(", ")}. Fields: ${ENTRY_FIELDS.join(", ")}`);
+  }
+}
+
+// ../core/dist/tools/route.js
+function runRoute(options, rawInput) {
+  const problems = checkRouteInput(rawInput);
+  if (problems.length > 0) {
+    throw new DecisionsError("invalid-request", `Invalid route input:
+  ${problems.join("\n  ")}`, {
+      problems
+    });
+  }
+  const input = rawInput;
+  const config = loadConfig(options);
+  const { user, repo } = config.layers;
+  return {
+    ...route(input.prompt, config.route),
+    files: { ...user ? { user } : {}, ...repo ? { repo } : {} }
+  };
+}
+function checkRouteInput(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input))
+    return ["/ must be an object"];
+  const extra = Object.keys(input).filter((k) => k !== "prompt");
+  return [
+    ...typeof input.prompt === "string" ? [] : ["/prompt must be a string"],
+    ...extra.map((k) => `/${k} is not allowed`)
+  ];
+}
+
+// ../core/dist/tools/spec-check.js
+async function runSpecCheck(ctx, rawInput) {
+  const input = checkInput("spec-check", rawInput);
+  const spec = loadSpec(input.spec, ctx.specDirs, ctx.cwd);
+  const lint = lintSpec(spec);
+  const examples = spec.examples ?? [];
+  if (examples.length === 0) {
+    throw new DecisionsError("invalid-request", `Spec "${spec.name}" has no examples to check. Add some under examples: (id, state or file, expect).`);
+  }
+  assertExamples(spec);
+  const profile = resolveProfile(input.model ?? ctx.config.model, allProfiles(ctx.config));
+  const root = ctx.config.repoRoot;
+  const prepared = [];
+  for (const example of examples) {
+    const expect = example.expect ? parseExpect(example.expect, spec.questions, example.id) : {};
+    const refused = example.file !== void 0 ? exampleFileProblem(example.file, root) : void 0;
+    if (refused) {
+      prepared.push({ id: example.id, expect, reason: `${example.file} ${refused}` });
+      continue;
+    }
+    const source = example.file !== void 0 ? { kind: "file", ...parseFileRef(example.file) } : {
+      kind: "text",
+      // A structured state is sent as its JSON text.
+      text: typeof example.state === "string" ? example.state : JSON.stringify(example.state),
+      id: example.id
+    };
+    try {
+      const prep = await prepare({
+        sources: [source],
+        split: parseSplit("file"),
+        questions: spec.questions,
+        profile,
+        cwd: root,
+        exclude: ctx.config.egress.exclude
+      });
+      const [item, ...rest] = prep.items;
+      const why = prep.skipped[0];
+      prepared.push(item && rest.length === 0 ? { id: example.id, expect, prep } : {
+        id: example.id,
+        expect,
+        reason: why ? `${why.path} ${why.reason}` : `gave ${prep.items.length} states, not 1`
+      });
+    } catch (error) {
+      if (!isDecisionsError(error) || !["state-too-large", "source-error"].includes(error.code)) {
+        throw error;
+      }
+      prepared.push({ id: example.id, expect, reason: error.message.split("\n")[0] });
+    }
+  }
+  const decider = deciderFor(ctx, profile, input.mode ?? "replay");
+  if (decider.mode !== "replay") {
+    assertConsent(ctx.config.egress.consent, root);
+    const parts = prepared.flatMap((p) => p.prep ? [p.prep.projection] : []);
+    checkBudget(combineProjections(profile, parts), ctx.config.budget, input.confirm ?? false);
+  }
+  const results = [];
+  const usages = [];
+  let misses = 0;
+  for (const { id, expect, prep, reason } of prepared) {
+    const item = prep?.items[0];
+    if (!prep || !item) {
+      results.push({ id, status: "withheld", reason: reason ?? "not sent" });
+      continue;
+    }
+    try {
+      const r = await decider.decide({
+        state: item.state,
+        questions: spec.questions,
+        namespace: spec.name
+      });
+      usages.push(r.usage);
+      results.push(judge(id, r.answers, r.undecided, expect));
+    } catch (error) {
+      if (isDecisionsError(error) && error.code === "replay-miss") {
+        misses += 1;
+        continue;
+      }
+      throw error;
+    }
+  }
+  if (misses > 0) {
+    throw new DecisionsError("replay-miss", `${misses} of ${examples.length} examples of "${spec.name}" have no recorded answer. Record them with \`decide spec check ${spec.name} --live\` (needs a key and repo consent).`, { misses });
+  }
+  const counts2 = {
+    examples: results.length,
+    pass: 0,
+    fail: 0,
+    undecided: 0,
+    captured: 0,
+    withheld: 0
+  };
+  for (const r of results)
+    counts2[r.status] += 1;
+  return {
+    spec: spec.name,
+    file: spec.file,
+    model: profile.id,
+    source: decider.mode === "replay" ? "replay" : "live",
+    passed: counts2.fail === 0 && counts2.undecided === 0 && counts2.withheld === 0,
+    counts: counts2,
+    examples: results,
+    usage: sumUsage(usages),
+    skipped: summariseSkipped(prepared.flatMap((p) => p.prep?.skipped ?? [])),
+    lint
+  };
+}
+function judge(id, answers, flat, expect) {
+  const entries = Object.entries(expect);
+  if (entries.length === 0) {
+    return { id, status: "captured", answers, ...flat.length ? { undecided: flat } : {} };
+  }
+  const failures = [];
+  const undecided = [];
+  for (const [question, expectation] of entries) {
+    const answer = answers[question];
+    const isFlat = flat.includes(question);
+    if (expectation.kind === "undecided") {
+      if (!isFlat)
+        failures.push({ question, expected: "undecided" });
+    } else if (isFlat) {
+      undecided.push(question);
+    } else if (!answer || !meets(question, answer, expectation)) {
+      failures.push({ question, expected: describeExpectation(expectation) });
+    }
+  }
+  const status = failures.length ? "fail" : undecided.length ? "undecided" : "pass";
+  return {
+    id,
+    status,
+    answers,
+    ...failures.length ? { failures } : {},
+    ...undecided.length ? { undecided } : {}
+  };
+}
+
+// ../core/dist/tools/spec-lint.js
+import { basename, extname } from "node:path";
+function runSpecLint(ctx, rawInput = {}) {
+  const input = checkInput("spec-lint", rawInput);
+  const specs = input.spec ? [named(ctx, input.spec)] : listSpecs(ctx.specDirs).filter((s) => !s.shadowed).map((s) => s.error ? { name: s.name, file: s.file, origin: s.origin, findings: [], invalid: s.error } : (
+    // Loaded by path, so keep the layer it was listed from.
+    { ...entry(loadSpec(s.file, ctx.specDirs, ctx.cwd)), origin: s.origin }
+  ));
+  const all = specs.flatMap((s) => s.findings);
+  const counts2 = {
+    specs: specs.length,
+    errors: all.filter((f) => f.severity === "error").length,
+    warnings: all.filter((f) => f.severity === "warning").length,
+    invalid: specs.filter((s) => s.invalid).length
+  };
+  return { specs, counts: counts2, passed: counts2.errors === 0 && counts2.invalid === 0 };
+}
+function named(ctx, ref) {
+  try {
+    return entry(loadSpec(ref, ctx.specDirs, ctx.cwd));
+  } catch (error) {
+    const file = isDecisionsError(error) ? error.details?.file : void 0;
+    if (typeof file !== "string")
+      throw error;
+    return {
+      name: basename(file, extname(file)),
+      file,
+      origin: "path",
+      findings: [],
+      invalid: error.message
+    };
+  }
+}
+function entry(spec) {
+  return { name: spec.name, file: spec.file, origin: spec.origin, findings: lintSpec(spec) };
+}
+
+// ../core/dist/tools/usage.js
+function runUsage(ctx, rawInput = {}) {
+  const input = checkInput("usage", rawInput);
+  const since = input.since ? new Date(input.since) : void 0;
+  if (since && Number.isNaN(since.getTime())) {
+    throw new DecisionsError("invalid-request", `--since "${input.since}" is not a date`);
+  }
+  const session = input.session === "current" ? currentSession(ctx) : input.session;
+  const ledger = ledgerFor(ctx);
+  return {
+    basis: "measured",
+    ...ledger.summary({
+      ...session ? { session } : {},
+      ...since ? { since } : {}
+    }),
+    ledger: ledger.file,
+    ...session ? { session } : {},
+    ...input.since ? { since: input.since } : {}
+  };
+}
+function currentSession(ctx) {
+  if (ctx.config.session)
+    return ctx.config.session;
+  throw new DecisionsError("invalid-request", "no current session: not running under Claude Code, Codex or Pi, and SYSTEM1_SESSION is not set");
+}
+
+// ../core/dist/wiring.js
+var DEFAULT_MODEL = DEFAULT_MODEL_ID;
+function resolveConnection(env = process.env) {
+  return {
+    endpoint: nonEmpty(env.SYSTEM1_ENDPOINT) ?? DEFAULT_ENDPOINT,
+    model: nonEmpty(env.SYSTEM1_MODEL) ?? DEFAULT_MODEL,
+    apiKey: envKey(env),
+    replay: /^(1|true|yes)$/i.test(env.SYSTEM1_REPLAY ?? "")
+  };
+}
+function envKey(env) {
+  try {
+    return unquoteKey(env.OPENROUTER_API_KEY)?.value;
+  } catch {
+    return void 0;
+  }
+}
+function nonEmpty(value) {
+  return value === void 0 || value.trim() === "" ? void 0 : value.trim();
+}
+
+export {
+  probeUrl,
+  ping,
+  runMany,
+  runAsk,
+  runDoctor,
+  runOpportunitiesAdd,
+  runOpportunitiesList,
+  runOpportunitiesCheck,
+  runRoute,
+  runSpecCheck,
+  runSpecLint,
+  runUsage,
+  resolveConnection
+};