eminiar 0.11.0 → 0.13.0

package/dist/hook-hooks-U6GDOQSY.js

@@ -0,0 +1,1827 @@
+import { createRequire as __emCreateRequire } from "node:module"; const require = __emCreateRequire(import.meta.url);
+import {
+  FALLBACK_MODEL,
+  agentFileRange,
+  coordinationRoot,
+  costOfCall,
+  hookLog,
+  manifestPath,
+  readManifestAt,
+  resolvePrice
+} from "./hook-chunk-MVOBVFQL.js";
+import {
+  adjudicateOne,
+  briefUnitsOf,
+  cacheKeyFor,
+  complexityBucket,
+  extractFeatures,
+  resolveAdjudicator,
+  spawnAsyncJob,
+  topIntent
+} from "./hook-chunk-77I6QQ43.js";
+import {
+  AGENT_EFFORT_SINCE,
+  KEPT_MODEL_FLAG,
+  TIERS,
+  getContext,
+  getStorage,
+  init_esm_shims,
+  keptModel,
+  tierOf
+} from "./hook-chunk-IYHVLMJ4.js";
+
+// src/adjudicator/hooks.ts
+init_esm_shims();
+import { readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { basename as basename2, dirname as dirname2, join as join2 } from "path";
+
+// src/adjudicator/agent-pin.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+
+// src/adjudicator/savings.ts
+init_esm_shims();
+
+// src/adjudicator/env.ts
+init_esm_shims();
+var ON = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function envFlagOn(value) {
+  return value !== void 0 && ON.has(value.trim().toLowerCase());
+}
+function subagentModelForced(env = process.env) {
+  return envFlagOn(env.CLAUDE_CODE_SUBAGENT_MODEL_FORCE);
+}
+
+// src/adjudicator/savings.ts
+var SAVINGS_ASSUMPTIONS = Object.freeze([
+  "Token counts would have been the same on the baseline model. Smaller models can need more turns, so compare tokens per successful task by tier.",
+  "List prices, with cache pricing unchanged.",
+  "Credit only for dispatches that were followed or applied; a failed attempt that was redone is charged its full cost.",
+  "No credit for a dispatch to an agent whose model pin the advice kept (pinned, or a pin that could not be read): the adjudicator chose nothing there.",
+  "For a role with a model range the baseline is its fallback pin (the model the agent file pins), and a ranged dispatch earns credit like any followed advice.",
+  "For an agent with no `model` line, the baseline is CLAUDE_CODE_SUBAGENT_MODEL when it is set (and FORCE is off), else the main session's model.",
+  "No credit while CLAUDE_CODE_SUBAGENT_MODEL_FORCE is on, nor for a fork (it runs on the main session's model): Claude Code, not the advice, sets the model.",
+  "The adjudicator's own provider spend is subtracted.",
+  "No credit for tool advice: em_stats already counts context kept out by em_* tools. Only the tool-advice follow rate is reported.",
+  "Main-session advice yields potential savings only and is never added to net: the counterfactual cannot be observed."
+]);
+var SESSION_LOOKBACK_MS = 12 * 60 * 60 * 1e3;
+function tierRank(tier) {
+  return TIERS.indexOf(tier);
+}
+function isPinned(model) {
+  const m = String(model ?? "").trim();
+  return m !== "" && m.toLowerCase() !== "inherit";
+}
+function withKeptModel(raw, kept, extra = {}) {
+  try {
+    const parsed = raw ? JSON.parse(raw) : {};
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    const o = { ...parsed, ...extra };
+    for (const k of Object.values(KEPT_MODEL_FLAG)) delete o[k];
+    if (kept) o[KEPT_MODEL_FLAG[kept]] = true;
+    return JSON.stringify(o);
+  } catch {
+    return void 0;
+  }
+}
+var RANGED_FLAG = "ranged";
+var FALLBACK_PIN_FIELD = "fallbackPin";
+var ADVISED_PICK_FIELD = "advisedPick";
+function scoresRecord(row) {
+  const raw = row.scores;
+  let o = raw;
+  if (typeof raw === "string") {
+    try {
+      o = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!o || typeof o !== "object" || Array.isArray(o)) return void 0;
+  return o;
+}
+function advisedPick(row) {
+  const pick = scoresRecord(row)?.[ADVISED_PICK_FIELD];
+  return typeof pick === "string" && tierRank(pick) >= 0 ? pick : void 0;
+}
+function envSubagentModel(env) {
+  if (envFlagOn(env.CLAUDE_CODE_SUBAGENT_MODEL_FORCE)) return void 0;
+  const m = env.CLAUDE_CODE_SUBAGENT_MODEL;
+  return isPinned(m) ? m.trim() : void 0;
+}
+function resolveBaseline(db, q) {
+  if (isPinned(q.fallbackPin)) return { model: q.fallbackPin.trim(), source: "ranged" };
+  if (isPinned(q.pinned)) return { model: q.pinned.trim(), source: "pinned" };
+  const envModel = q.env ? envSubagentModel(q.env) : void 0;
+  if (envModel) return { model: envModel, source: "env" };
+  if (q.sessionId) {
+    const calls = q.calls ?? (db ? db.apiCalls({
+      sessionId: q.sessionId,
+      since: q.ts - SESSION_LOOKBACK_MS,
+      until: q.ts,
+      sidechain: false
+    }) : []);
+    let best;
+    for (const c of calls) {
+      if (c.sidechain || c.session_id !== q.sessionId || c.ts >= q.ts || !c.model) continue;
+      if (c.model.startsWith("<")) continue;
+      if (!best || c.ts >= best.ts) best = c;
+    }
+    if (best) return { model: best.model, source: "session" };
+  }
+  return { model: FALLBACK_MODEL, source: "fallback" };
+}
+function totalTokens(calls) {
+  let n = 0;
+  for (const c of calls)
+    n += (c.input_tokens || 0) + (c.output_tokens || 0) + (c.cache_create_5m || 0) + (c.cache_create_1h || 0) + (c.cache_read || 0);
+  return n;
+}
+function dominantModel(calls) {
+  const counts = /* @__PURE__ */ new Map();
+  let best;
+  let bestN = 0;
+  for (const c of calls) {
+    if (!c.model || c.model.startsWith("<")) continue;
+    const n = (counts.get(c.model) ?? 0) + 1;
+    counts.set(c.model, n);
+    if (n >= bestN) {
+      best = c.model;
+      bestN = n;
+    }
+  }
+  return best;
+}
+function actualCost(calls, overrides) {
+  let total = 0;
+  for (const c of calls) {
+    const p = resolvePrice(c.model, overrides);
+    if (p) total += costOfCall(c, p).total;
+    else if (typeof c.cost_usd === "number" && c.priced) total += c.cost_usd;
+    else return null;
+  }
+  return total;
+}
+function repriceAt(calls, model, overrides) {
+  const p = resolvePrice(model, overrides);
+  if (!p) return null;
+  let total = 0;
+  for (const c of calls) total += costOfCall(c, p).total;
+  return total;
+}
+function allRows(db, filter = {}, max = 2e4) {
+  const out = [];
+  for (let offset = 0; offset < max; offset += 500) {
+    const { rows, total } = db.adjudicator.list({ ...filter, limit: 500, offset });
+    out.push(...rows);
+    if (!rows.length || offset + rows.length >= total) break;
+  }
+  return out.sort((a, b) => a.ts - b.ts || a.id - b.id);
+}
+
+// src/adjudicator/agent-pin.ts
+var FORK_AGENT = "fork";
+function isFork(agentType) {
+  return agentType === FORK_AGENT;
+}
+var BUILTIN = {
+  "general-purpose": void 0,
+  Explore: void 0,
+  Plan: void 0,
+  "statusline-setup": "sonnet",
+  "claude-code-guide": "haiku"
+};
+var MAX_FILES = 2e3;
+var MAX_DEPTH = 8;
+var MAX_BYTES = 256 * 1024;
+var MAX_UP = 8;
+var SEGMENT = /^[A-Za-z0-9_.-]+$/;
+function homeOf(env) {
+  return env.HOME?.trim() || env.USERPROFILE?.trim() || homedir();
+}
+function defaultManagedDir() {
+  switch (process.platform) {
+    case "darwin":
+      return "/Library/Application Support/ClaudeCode";
+    case "linux":
+      return "/etc/claude-code";
+    case "win32":
+      return "C:\\Program Files\\ClaudeCode";
+    default:
+      return null;
+  }
+}
+function scalar(fm, key) {
+  const raw = new RegExp(`^${key}:[ \\t]*(.*)$`, "m").exec(fm)?.[1]?.trim();
+  if (!raw) return void 0;
+  const q = raw[0];
+  if (q === '"' || q === "'") {
+    const end = raw.indexOf(q, 1);
+    return end > 1 ? raw.slice(1, end).trim() || void 0 : void 0;
+  }
+  return raw.replace(/\s+#.*$/, "").trim() || void 0;
+}
+function readDef(file) {
+  try {
+    if (statSync(file).size > MAX_BYTES) return { file };
+    const text = readFileSync(file, "utf8");
+    const fm = /^\uFEFF?---\r?\n([\s\S]*?)\r?\n---/.exec(text)?.[1];
+    if (!fm) return { file };
+    const def = { file, name: scalar(fm, "name"), model: scalar(fm, "model") };
+    if (text.includes(" range=")) def.range = agentFileRange(text);
+    return def;
+  } catch {
+    return void 0;
+  }
+}
+function rangeOf(defs, model) {
+  const r = defs[0]?.range;
+  if (!r || defs.some((d) => d.range?.floor !== r.floor || d.range?.ceiling !== r.ceiling))
+    return void 0;
+  const tier = model.toLowerCase() === "opusplan" ? void 0 : tierOf(model);
+  const [lo, hi, at] = [tierRank(r.floor), tierRank(r.ceiling), tierRank(tier)];
+  return lo >= 0 && lo < hi && at >= lo && at <= hi ? { floor: r.floor, ceiling: r.ceiling } : void 0;
+}
+function scan(dir) {
+  const files = [];
+  let truncated = false;
+  const walk = (d, depth) => {
+    if (truncated) return;
+    let entries;
+    try {
+      entries = readdirSync(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = join(d, e.name);
+      if (e.isDirectory()) {
+        if (depth >= MAX_DEPTH) truncated = true;
+        else walk(p, depth + 1);
+      } else if (e.name.endsWith(".md")) {
+        if (files.length >= MAX_FILES) {
+          truncated = true;
+          return;
+        }
+        files.push(p);
+      }
+    }
+  };
+  walk(dir, 0);
+  return { files, truncated };
+}
+function byName(dir, type) {
+  const { files, truncated } = scan(dir);
+  const defs = [];
+  for (const f of files) {
+    const d = readDef(f);
+    if (d?.name === type) defs.push(d);
+  }
+  return { defs, truncated };
+}
+function shown(file, home) {
+  const rel = relative(home, file);
+  return rel && !rel.startsWith("..") && !isAbsolute(rel) ? join("~", rel) : file;
+}
+function decide(defs, source, home) {
+  const pins = new Set(defs.map((d) => isPinned(d.model) ? d.model.trim() : ""));
+  const first = defs[0];
+  const file = shown(first.file, home);
+  if (pins.size > 1)
+    return {
+      status: "unknown",
+      source,
+      file,
+      reason: `${defs.length} ${source} definitions disagree on the model`
+    };
+  const model = [...pins][0];
+  if (!model) {
+    const out = {
+      status: "unpinned",
+      source,
+      file,
+      reason: `${source} agent has no model pin`
+    };
+    if (defs.every((d) => d.model?.trim().toLowerCase() === "inherit")) out.inherit = true;
+    return out;
+  }
+  const range = rangeOf(defs, model);
+  return range ? {
+    status: "ranged",
+    model,
+    range,
+    source,
+    file,
+    reason: `${source} agent ranges ${range.floor}..${range.ceiling} (fallback ${model})`
+  } : { status: "pinned", model, source, file, reason: `${source} agent pins model ${model}` };
+}
+function projectDirs(root, cwd) {
+  const top = resolve(root);
+  const inside = (d2) => {
+    const rel = relative(top, d2);
+    return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  };
+  let d = cwd && inside(resolve(cwd)) ? resolve(cwd) : top;
+  const dirs = [];
+  for (; ; ) {
+    dirs.push(d);
+    if (d === top) break;
+    d = dirname(d);
+  }
+  if (!existsSync(join(top, ".git"))) {
+    const above = [];
+    let u = top;
+    for (let i = 0; i < MAX_UP; i++) {
+      const parent = dirname(u);
+      if (parent === u) break;
+      u = parent;
+      above.push(u);
+      if (existsSync(join(u, ".git"))) {
+        dirs.push(...above);
+        break;
+      }
+    }
+  }
+  return dirs.map((x) => join(x, ".claude", "agents"));
+}
+function pluginDirs(plugin, env, home) {
+  const out = /* @__PURE__ */ new Set();
+  const pluginsRoot = env.CLAUDE_CODE_PLUGIN_CACHE_DIR?.trim() || join(home, ".claude", "plugins");
+  try {
+    const j = JSON.parse(readFileSync(join(pluginsRoot, "installed_plugins.json"), "utf8"));
+    for (const [key, val] of Object.entries(j?.plugins ?? {})) {
+      const at = key.lastIndexOf("@");
+      if ((at > 0 ? key.slice(0, at) : key) !== plugin) continue;
+      for (const e of Array.isArray(val) ? val : [val]) {
+        const p = e?.installPath;
+        if (typeof p === "string" && p) out.add(p);
+      }
+    }
+  } catch {
+  }
+  const sep = process.platform === "win32" ? ";" : ":";
+  for (const raw of (env.CLAUDE_CODE_PLUGIN_DIRS ?? "").split(sep)) {
+    const p = raw.trim().replace(/^~(?=$|[/\\])/, home);
+    if (!p || !isAbsolute(p)) continue;
+    const name = manifest(p)?.name;
+    if ((typeof name === "string" ? name : basename(p)) === plugin) out.add(p);
+  }
+  return [...out];
+}
+function manifest(dir) {
+  try {
+    const m = JSON.parse(readFileSync(join(dir, ".claude-plugin", "plugin.json"), "utf8"));
+    return m && typeof m === "object" ? m : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function agentPaths(dir) {
+  const a = manifest(dir)?.agents;
+  const list = typeof a === "string" ? [a] : Array.isArray(a) ? a.filter((x) => typeof x === "string") : [];
+  return (list.length ? list : ["./agents"]).map((p) => resolve(dir, p));
+}
+function pluginDefs(segments, env, home) {
+  const [plugin, ...rest] = segments;
+  const agent = rest.at(-1);
+  const sub = rest.slice(0, -1);
+  const installs = pluginDirs(plugin, env, home);
+  if (!installs.length) return `plugin ${plugin} is not installed where eminiar can see it`;
+  const defs = [];
+  const matches = (d, file) => !!d && (d.name === agent || basename(file, ".md") === agent);
+  for (const install of installs) {
+    for (const p of agentPaths(install)) {
+      let isDir = false;
+      try {
+        isDir = statSync(p).isDirectory();
+      } catch {
+        continue;
+      }
+      if (!isDir) {
+        if (!sub.length && p.endsWith(".md")) {
+          const d = readDef(p);
+          if (matches(d, p)) defs.push(d);
+        }
+        continue;
+      }
+      let entries;
+      try {
+        entries = readdirSync(join(p, ...sub)).filter((n) => n.endsWith(".md"));
+      } catch {
+        continue;
+      }
+      for (const n of entries) {
+        const f = join(p, ...sub, n);
+        const d = readDef(f);
+        if (matches(d, f)) defs.push(d);
+      }
+    }
+  }
+  return { defs, truncated: false };
+}
+function resolveAgentPin(agentType, q) {
+  try {
+    if (isFork(agentType))
+      return {
+        status: "unpinned",
+        source: "builtin",
+        reason: "a fork runs on the main session's model"
+      };
+    const env = q.env ?? process.env;
+    const home = homeOf(env);
+    if (agentType.includes(":")) {
+      const segments = agentType.split(":");
+      if (segments.length < 2 || !segments.every((s) => SEGMENT.test(s) && s !== "." && s !== ".."))
+        return { status: "unknown", source: "plugin", reason: "malformed plugin agent name" };
+      const found = pluginDefs(segments, env, home);
+      if (typeof found === "string") return { status: "unknown", source: "plugin", reason: found };
+      if (!found.defs.length)
+        return {
+          status: "unknown",
+          source: "plugin",
+          reason: `plugin agent ${agentType} has no definition file eminiar can read`
+        };
+      return decide(found.defs, "plugin", home);
+    }
+    const managed = q.managedDir === void 0 ? defaultManagedDir() : q.managedDir;
+    const scopes = [];
+    if (managed) scopes.push(["managed", join(managed, ".claude", "agents")]);
+    for (const d of projectDirs(q.root, q.cwd)) scopes.push(["project", d]);
+    scopes.push(["user", join(home, ".claude", "agents")]);
+    let truncated = false;
+    for (const [source, dir] of scopes) {
+      const found = byName(dir, agentType);
+      if (found.defs.length) return decide(found.defs, source, home);
+      truncated ||= found.truncated;
+    }
+    if (truncated)
+      return { status: "unknown", reason: "an agents directory is too large to scan fully" };
+    if (Object.hasOwn(BUILTIN, agentType)) {
+      const model = BUILTIN[agentType];
+      return model ? { status: "pinned", model, source: "builtin", reason: `built-in agent runs on ${model}` } : { status: "unpinned", source: "builtin", reason: "built-in agent has no model pin" };
+    }
+    return {
+      status: "unknown",
+      reason: `no definition of ${agentType} found (a --agents or plugin agent?)`
+    };
+  } catch (err) {
+    return { status: "unknown", reason: `agent lookup failed: ${err?.message ?? err}` };
+  }
+}
+
+// src/adjudicator/learn.ts
+init_esm_shims();
+var SETTLE_MS = 2 * 6e4;
+var FINAL_AFTER_MS = 24 * 60 * 6e4;
+var LINK_WINDOW_MS = 6e4;
+var AGENT_IDLE_MS = 30 * 6e4;
+var BASELINE_LOOKBACK_MS = 12 * 60 * 6e4;
+var DEFAULT_LEARNING = Object.freeze({
+  enabled: true,
+  maxBias: 0.3,
+  minSamples: 5,
+  halfLife: 50,
+  costWeight: 0.05
+});
+function learningOf(explicit, config) {
+  return { ...DEFAULT_LEARNING, ...config?.adjudicator?.learning ?? {}, ...explicit ?? {} };
+}
+var clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+function decayFactor(halfLife) {
+  return halfLife > 0 && Number.isFinite(halfLife) ? 2 ** (-1 / halfLife) : 1;
+}
+function posterior(s, n) {
+  return (s + 2) / (n + 4);
+}
+function median(xs) {
+  if (!xs.length) return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const mid = s.length >> 1;
+  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+function computeBias(row, bucketMedian, l) {
+  if (!(row.n >= l.minSamples) || row.n <= 0) return 0;
+  let b = posterior(row.s, row.n) - 0.8;
+  if (row.costMedian && row.costMedian > 0 && bucketMedian && bucketMedian > 0)
+    b -= l.costWeight * Math.log2(row.costMedian / bucketMedian);
+  return clamp(b, -l.maxBias, l.maxBias);
+}
+function bucketMedianOf(rows) {
+  return median(
+    rows.map((r) => r.costMedian).filter((c) => typeof c === "number" && c > 0)
+  );
+}
+function stepMedian(current, sample) {
+  if (current === null || !(current > 0)) return sample;
+  if (sample > current) return Math.min(sample, current * 1.2);
+  if (sample < current) return Math.max(sample, current / 1.2);
+  return current;
+}
+function recordSignal(db, sig, learning, now = Date.now()) {
+  if (!learning.enabled || !sig.option || !sig.bucket) return;
+  const inBucket = db.adjudicator.biasAll().filter((r) => r.dimension === sig.dimension && r.bucket === sig.bucket);
+  let target = inBucket.find((r) => r.option === sig.option);
+  if (!target) {
+    target = {
+      dimension: sig.dimension,
+      bucket: sig.bucket,
+      option: sig.option,
+      n: 0,
+      s: 0,
+      f: 0,
+      costMedian: null,
+      bias: 0,
+      updatedAt: null
+    };
+    inBucket.push(target);
+  }
+  const d = decayFactor(learning.halfLife);
+  target.n = target.n * d + 1;
+  target.s = target.s * d + (sig.success ? 1 : 0);
+  target.f = target.f * d + (sig.success ? 0 : 1);
+  if (sig.success && typeof sig.costUsd === "number" && sig.costUsd > 0)
+    target.costMedian = stepMedian(target.costMedian, sig.costUsd);
+  target.updatedAt = now;
+  const med = bucketMedianOf(inBucket);
+  for (const r of inBucket) {
+    const bias = computeBias(r, med, learning);
+    if (r !== target && bias === r.bias) continue;
+    r.bias = bias;
+    db.adjudicator.biasUpsert({ ...r, updatedAt: r === target ? now : r.updatedAt });
+  }
+}
+function biasFromRows(rows, learning, key) {
+  const out = {};
+  if (!learning.enabled) return out;
+  const tierBucket = typeof key.complexity === "number" && Number.isFinite(key.complexity) ? String(complexityBucket(key.complexity)) : void 0;
+  const roleBucket = key.intent || "none";
+  for (const [dimension, bucket] of [
+    ["tier", tierBucket],
+    ["role", roleBucket]
+  ]) {
+    if (bucket === void 0) continue;
+    const inBucket = rows.filter((r) => r.dimension === dimension && r.bucket === bucket);
+    const med = bucketMedianOf(inBucket);
+    for (const r of inBucket) {
+      const b = computeBias(r, med, learning);
+      if (b !== 0) out[`${dimension}:${r.option}`] = b;
+    }
+  }
+  return out;
+}
+function biasFor(db, learning, key) {
+  const l = learningOf(learning, void 0);
+  if (!l.enabled) return {};
+  return biasFromRows(db.adjudicator.biasAll(), l, key);
+}
+function parsedFeatures(row) {
+  if (!row.scores) return void 0;
+  try {
+    const s = JSON.parse(row.scores);
+    return s && typeof s === "object" && s.features && typeof s.features === "object" ? s.features : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function heuristicComplexityOf(row) {
+  if (!row.scores) return void 0;
+  try {
+    const s = JSON.parse(row.scores);
+    const c = s && typeof s === "object" ? s.heuristicComplexity : void 0;
+    return typeof c === "number" && Number.isFinite(c) ? c : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function bucketsOf(row) {
+  const heuristic = heuristicComplexityOf(row);
+  const complexity = heuristic ?? (typeof row.complexity === "number" && Number.isFinite(row.complexity) ? row.complexity : void 0);
+  const tier = complexity === void 0 ? void 0 : String(complexityBucket(complexity));
+  const f = parsedFeatures(row);
+  const intent = f?.intents && typeof f.intents === "object" ? topIntent(f) : void 0;
+  return { tier, role: intent ?? "none" };
+}
+function diff(row, patch) {
+  const out = {};
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === void 0) continue;
+    const cur = row[k] ?? null;
+    if (cur === (v ?? null)) continue;
+    out[k] = v;
+  }
+  return out;
+}
+var CREDITED = /* @__PURE__ */ new Set(["applied", "followed"]);
+function matchDispatches(rows, agents, windowMs = LINK_WINDOW_MS) {
+  const out = /* @__PURE__ */ new Map();
+  let R = [...rows];
+  let A = [...agents];
+  const inWindow = (r, a) => a.first >= r.ts && a.first <= r.ts + windowMs;
+  for (; ; ) {
+    const cand = new Map(R.map((r) => [r.id, A.filter((a) => inWindow(r, a))]));
+    const owners = new Map(A.map((a) => [a.id, R.filter((r) => inWindow(r, a))]));
+    const pairs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const start of R) {
+      if (seen.has(start.id)) continue;
+      const rowsC = [];
+      const agentsC = /* @__PURE__ */ new Set();
+      const queue = [start];
+      seen.add(start.id);
+      while (queue.length) {
+        const r = queue.pop();
+        rowsC.push(r);
+        for (const a of cand.get(r.id) ?? []) {
+          if (agentsC.has(a)) continue;
+          agentsC.add(a);
+          for (const o of owners.get(a.id) ?? [])
+            if (!seen.has(o.id)) {
+              seen.add(o.id);
+              queue.push(o);
+            }
+        }
+      }
+      if (!agentsC.size || rowsC.some((r) => !r.settled)) continue;
+      if (rowsC.length === 1 && agentsC.size === 1) {
+        pairs.push([rowsC[0], [...agentsC][0]]);
+        continue;
+      }
+      for (const r of rowsC) {
+        if (!r.want) continue;
+        const match = (cand.get(r.id) ?? []).filter((a2) => a2.tier === r.want);
+        if (match.length !== 1) continue;
+        const a = match[0];
+        const rivals = (owners.get(a.id) ?? []).filter((o) => o !== r);
+        if (rivals.every((o) => o.want !== void 0 && o.want !== a.tier)) pairs.push([r, a]);
+      }
+    }
+    if (!pairs.length) return out;
+    for (const [r, a] of pairs) out.set(r.id, a.id);
+    const pr = new Set(pairs.map(([r]) => r.id));
+    const pa = new Set(pairs.map(([, a]) => a.id));
+    R = R.filter((r) => !pr.has(r.id));
+    A = A.filter((a) => !pa.has(a.id));
+  }
+}
+var Reconciler = class {
+  constructor(db, now, learning, pricing, sessionsSince) {
+    this.db = db;
+    this.now = now;
+    this.learning = learning;
+    this.pricing = pricing;
+    this.sessionsSince = sessionsSince;
+    this.latestCallTs = db.apiCallsLatestTs();
+  }
+  db;
+  now;
+  learning;
+  pricing;
+  sessionsSince;
+  result = {
+    scanned: 0,
+    updated: 0,
+    finalized: 0,
+    linked: 0,
+    learned: 0
+  };
+  sessionCalls = /* @__PURE__ */ new Map();
+  taskRows = /* @__PURE__ */ new Map();
+  runWorkers = /* @__PURE__ */ new Map();
+  promptsBySession;
+  /** Agent ids already tied to an adjudication row. */
+  taken = /* @__PURE__ */ new Set();
+  /** Row id → the agent linkAgents matched it to in this run. */
+  links = /* @__PURE__ */ new Map();
+  latestCallTs;
+  /** Calls of a session from (its oldest pending row − lookback), loaded once per run. */
+  calls(sessionId) {
+    let c = this.sessionCalls.get(sessionId);
+    if (!c) {
+      const since = (this.sessionsSince.get(sessionId) ?? this.now) - BASELINE_LOOKBACK_MS;
+      c = this.db.apiCalls({ sessionId, since });
+      this.sessionCalls.set(sessionId, c);
+    }
+    return c;
+  }
+  siblings(runId, taskId) {
+    const k = `${runId}#${taskId}`;
+    let r = this.taskRows.get(k);
+    if (!r) {
+      r = this.db.adjudicator.forTask(runId, taskId);
+      this.taskRows.set(k, r);
+    }
+    return r;
+  }
+  workers(runId) {
+    let w = this.runWorkers.get(runId);
+    if (!w) {
+      w = this.db.swarm.workers(runId);
+      this.runWorkers.set(runId, w);
+    }
+    return w;
+  }
+  prompts(sessionId, since) {
+    if (!this.promptsBySession) {
+      const m = /* @__PURE__ */ new Map();
+      for (const p of allRows(this.db, { surface: "prompt", since })) {
+        if (!p.sessionId) continue;
+        const list = m.get(p.sessionId);
+        if (list) list.push(p);
+        else m.set(p.sessionId, [p]);
+      }
+      this.promptsBySession = m;
+    }
+    return this.promptsBySession.get(sessionId) ?? [];
+  }
+  /**
+   * Can every agent this row might own be visible? Yes once ingestion holds a call past the
+   * row's link window, or once the row is AGENT_IDLE_MS old (a session whose last agents
+   * finished inside the window has no later call; by then its transcripts are ingested).
+   */
+  windowSeen(row) {
+    return this.latestCallTs === void 0 || this.latestCallTs >= row.ts + LINK_WINDOW_MS || this.now - row.ts >= AGENT_IDLE_MS;
+  }
+  /**
+   * Decide, once per run and jointly per session, which sidechain agent each unlinked
+   * non-swarm agent row dispatched (agentRow reads the result). Parallel Agent calls in one
+   * message are the common case, so rows are not linked greedily in order: every dispatch
+   * row of the session without an agent id competes (final, unsettled and swarm rows too),
+   * and matchDispatches links only what the evidence settles. Ambiguous rows stay unlinked.
+   */
+  linkAgents(targets) {
+    const bySession = /* @__PURE__ */ new Map();
+    for (const r of targets) {
+      if (r.agentId || !r.sessionId) continue;
+      const list = bySession.get(r.sessionId);
+      if (list) list.push(r);
+      else bySession.set(r.sessionId, [r]);
+    }
+    if (!bySession.size) return;
+    const minTs = Math.min(...targets.map((r) => r.ts));
+    const near = allRows(this.db, { surface: "agent", since: minTs - LINK_WINDOW_MS });
+    for (const [sessionId, mine] of bySession) {
+      const maxTs = Math.max(...mine.map((r) => r.ts));
+      const linkable = new Set(mine.map((r) => r.id));
+      const rows = near.filter((r) => r.sessionId === sessionId && !r.agentId && r.ts <= maxTs + LINK_WINDOW_MS).map((r) => ({
+        id: r.id,
+        ts: r.ts,
+        want: tierOf(r.modelFinal ?? r.modelRequested),
+        settled: this.windowSeen(r)
+      }));
+      const callsBy = /* @__PURE__ */ new Map();
+      for (const c of this.calls(sessionId)) {
+        if (!c.sidechain || !c.agent_id || this.taken.has(c.agent_id)) continue;
+        const list = callsBy.get(c.agent_id);
+        if (list) list.push(c);
+        else callsBy.set(c.agent_id, [c]);
+      }
+      const agents = [...callsBy].map(([id, cs]) => ({
+        id,
+        first: Math.min(...cs.map((c) => c.ts)),
+        tier: tierOf(dominantModel(cs))
+      }));
+      for (const [rowId, agentId] of matchDispatches(rows, agents)) {
+        this.taken.add(agentId);
+        if (linkable.has(rowId)) this.links.set(rowId, agentId);
+      }
+    }
+  }
+  /** Seed `taken` with the agent ids already on agent / plan rows near these rows. */
+  seedTaken(since) {
+    for (const surface of ["agent", "plan"])
+      for (const r of allRows(this.db, { surface, since: since - FINAL_AFTER_MS }))
+        if (r.agentId) this.taken.add(r.agentId);
+  }
+  /**
+   * Commit a patch; on the transition to final, record the row's learning signals and keep
+   * exactly what was taught on the row (scores.taught, empty when nothing was) so a later
+   * relabel or feedback retracts that, not a lesson recomputed from the row's current state.
+   */
+  commit(row, patch, teach) {
+    if (patch.outcome && patch.outcome !== "pending" && row.outcomeTs == null && patch.outcomeTs === void 0)
+      patch.outcomeTs = this.now;
+    const d = diff(row, patch);
+    if (!Object.keys(d).length) return;
+    let lesson;
+    if (d.final === true && !row.final) {
+      this.result.finalized++;
+      if (teach) {
+        const outcome = d.outcome ?? row.outcome;
+        lesson = this.learning.enabled && (outcome === "success" || outcome === "failure") ? this.lessonOf(row, outcome === "success", teach, d.actualCostUsd ?? row.actualCostUsd) : [];
+        const scores = withTaught(row.scores, lesson);
+        if (scores !== void 0) d.scores = scores;
+      }
+    }
+    this.db.adjudicator.update(row.id, d);
+    this.result.updated++;
+    for (const sig of lesson ?? []) {
+      recordSignal(this.db, sig, this.learning, this.now);
+      this.result.learned++;
+    }
+  }
+  /** The signals a finalising swarm row teaches: the tier that ran and the role, if known. */
+  lessonOf(row, success, what, cost) {
+    const b = bucketsOf(row);
+    const out = [];
+    if (what.tier && b.tier !== void 0)
+      out.push({ dimension: "tier", bucket: b.tier, option: what.tier, success, costUsd: cost });
+    if (what.role)
+      out.push({ dimension: "role", bucket: b.role, option: what.role, success, costUsd: cost });
+    return out;
+  }
+  /**
+   * Actual model, tokens and cost of `calls`, the baseline and its cost, follow detection
+   * and the credited savings. `calls` empty leaves the token fields alone.
+   */
+  pricePatch(row, calls, sessionId, redone, outcome) {
+    const patch = {};
+    const baseline = row.baselineModel ?? resolveBaseline(void 0, {
+      sessionId,
+      ts: row.ts,
+      calls: sessionId ? this.calls(sessionId) : []
+    }).model;
+    if (!row.baselineModel) patch.baselineModel = baseline;
+    const deferred = keptModel(row) !== void 0;
+    let action = row.action ?? null;
+    if (action === "advised" && row.modelRequested && !deferred) {
+      const parent = row.parentId ? this.db.adjudicator.get(row.parentId) : void 0;
+      const advice = advisedPick(row) ?? (parent ? advisedPick(parent) : void 0) ?? parent?.tier ?? row.tier ?? void 0;
+      const requested = tierOf(row.modelRequested) ?? row.modelRequested;
+      if (advice && requested === advice) {
+        if (advice !== (tierOf(baseline) ?? baseline)) action = "followed";
+      } else if (advice) action = "ignored";
+      if (action !== row.action) patch.action = action;
+    }
+    if (!calls.length) return patch;
+    const actual = actualCost(calls, this.pricing);
+    const base = repriceAt(calls, baseline, this.pricing);
+    patch.actualModel = dominantModel(calls) ?? null;
+    patch.actualTokens = totalTokens(calls);
+    patch.actualCostUsd = actual;
+    patch.baselineCostUsd = base;
+    let savings = null;
+    if (CREDITED.has(action ?? "") && !deferred) {
+      if (redone && outcome === "failure") savings = actual === null ? null : -actual;
+      else if (actual !== null && base !== null) savings = base - actual;
+    }
+    patch.savingsUsd = savings;
+    return patch;
+  }
+  /** Apply the redo penalty to earlier credited attempts of a task that already went final. */
+  penaliseEarlier(row, sibs) {
+    for (const e of sibs) {
+      if (e.surface !== "agent" || e.id >= row.id || !e.final) continue;
+      if (!CREDITED.has(e.action ?? "") || typeof e.actualCostUsd !== "number") continue;
+      const patch = { savingsUsd: -e.actualCostUsd };
+      const relabel = e.outcome !== "failure" && feedbackOf(e) === void 0;
+      let before = [];
+      let after = [];
+      if (relabel) {
+        patch.outcome = "failure";
+        patch.outcomeSource = "redo";
+        before = taughtLesson(this.db, e);
+        after = reconcileLesson(this.db, { ...e, outcome: "failure", outcomeSource: "redo" });
+        const scores = withTaught(e.scores, this.learning.enabled ? after : before);
+        if (scores !== void 0) patch.scores = scores;
+      }
+      const d = diff(e, patch);
+      if (Object.keys(d).length) {
+        this.db.adjudicator.update(e.id, d);
+        Object.assign(e, d);
+        this.result.updated++;
+      }
+      if (relabel)
+        this.result.learned += replaceLesson(this.db, before, after, this.learning, this.now);
+    }
+  }
+  swarmRow(row) {
+    const runId = row.runId;
+    const taskId = row.taskId;
+    const run = this.db.swarm.runGet(runId);
+    const rawTask = this.db.swarm.taskGet(taskId);
+    const task = rawTask && rawTask.run_id === runId ? rawTask : void 0;
+    const sibs = this.siblings(runId, taskId);
+    const later = sibs.find((s) => s.surface === "agent" && s.id > row.id);
+    const redone = row.surface === "agent" && later !== void 0;
+    const age = this.now - row.ts;
+    let outcome = "pending";
+    let source = "swarm";
+    if (redone) {
+      outcome = "failure";
+      source = "redo";
+    } else if (task?.status === "done") outcome = "success";
+    else if (task?.status === "failed" || task?.status === "blocked") outcome = "failure";
+    else if (!task || run && run.status !== "active") outcome = "abandoned";
+    if (outcome === "pending" && age >= FINAL_AFTER_MS) {
+      outcome = "abandoned";
+      source = "timeout";
+    }
+    const workers = this.workers(runId).filter((w) => w.task_id === taskId);
+    const otherAttempts = new Set(
+      sibs.filter((s) => s.surface === "agent" && s.id !== row.id && s.agentId).map((s) => s.agentId)
+    );
+    let worker;
+    if (row.surface === "agent") {
+      worker = workers.filter(
+        (w) => !otherAttempts.has(w.agent_id) && w.spawned_at >= row.ts - 5e3 && (!later || w.spawned_at < later.ts)
+      ).sort((a, b) => a.spawned_at - b.spawned_at)[0];
+    }
+    const agentId = row.agentId ?? worker?.agent_id ?? (redone ? void 0 : task?.agent_id ?? void 0);
+    if (!worker && agentId) worker = workers.find((w) => w.agent_id === agentId);
+    if (agentId) this.taken.add(agentId);
+    const sessionId = row.sessionId ?? run?.session_id ?? worker?.session_id ?? void 0;
+    const calls = agentId && sessionId ? this.calls(sessionId).filter((c) => c.agent_id === agentId && c.ts >= row.ts - 5e3) : [];
+    const patch = {
+      ...this.pricePatch(row, calls, sessionId, redone, outcome),
+      outcome,
+      outcomeSource: outcome === "pending" ? row.outcomeSource : source
+    };
+    if (agentId && !row.agentId) patch.agentId = agentId;
+    const settledAt = later?.ts ?? task?.updated_at ?? row.ts;
+    const caughtUp = this.latestCallTs === void 0 || this.latestCallTs >= settledAt || calls.length > 0;
+    if (age >= FINAL_AFTER_MS || outcome !== "pending" && caughtUp) patch.final = true;
+    const teaches = row.surface === "agent" || !sibs.some((s) => s.surface === "agent");
+    const teach = teaches ? {
+      tier: tierOf(patch.actualModel ?? row.actualModel),
+      role: task?.role ?? worker?.role ?? void 0
+    } : void 0;
+    this.commit(row, patch, teach);
+    if (row.surface === "agent") this.penaliseEarlier(row, sibs);
+  }
+  agentRow(row) {
+    const sessionId = row.sessionId ?? void 0;
+    const age = this.now - row.ts;
+    const all = sessionId ? this.calls(sessionId) : [];
+    let agentId = row.agentId ?? void 0;
+    let linkedNow = false;
+    if (!agentId) {
+      agentId = this.links.get(row.id);
+      if (agentId) {
+        linkedNow = true;
+        this.result.linked++;
+      }
+    }
+    const calls = agentId ? all.filter((c) => c.agent_id === agentId) : [];
+    const patch = this.pricePatch(row, calls, sessionId, false, row.outcome);
+    if (linkedNow) {
+      patch.agentId = agentId;
+      patch.outcomeSource = "link";
+    }
+    const last = calls.length ? calls[calls.length - 1].ts : void 0;
+    const idle = last !== void 0 && this.now - last >= AGENT_IDLE_MS;
+    if (age >= FINAL_AFTER_MS || idle) {
+      patch.final = true;
+      if (row.outcome === "pending") patch.outcome = "n/a";
+    }
+    this.commit(row, patch);
+  }
+  promptRow(row, promptsSince) {
+    const sessionId = row.sessionId ?? void 0;
+    const age = this.now - row.ts;
+    const patch = { outcome: "n/a", outcomeSource: "window" };
+    let closed = false;
+    if (sessionId) {
+      const next = this.prompts(sessionId, promptsSince).find(
+        (p) => p.ts > row.ts || p.ts === row.ts && p.id > row.id
+      );
+      const end = next?.ts ?? Number.POSITIVE_INFINITY;
+      const calls = this.calls(sessionId).filter(
+        (c) => !c.sidechain && c.ts >= row.ts && c.ts < end
+      );
+      if (calls.length) {
+        patch.actualModel = dominantModel(calls) ?? null;
+        patch.actualTokens = totalTokens(calls);
+        patch.actualCostUsd = actualCost(calls, this.pricing);
+      }
+      if (!row.baselineModel)
+        patch.baselineModel = resolveBaseline(void 0, {
+          sessionId,
+          ts: row.ts,
+          calls: this.calls(sessionId)
+        }).model;
+      closed = next !== void 0 && (this.latestCallTs === void 0 || this.latestCallTs >= next.ts);
+    }
+    if (closed || age >= FINAL_AFTER_MS || !sessionId) patch.final = true;
+    this.commit(row, patch);
+  }
+  otherRow(row) {
+    this.commit(row, {
+      outcome: row.outcome === "pending" ? "n/a" : row.outcome,
+      final: true
+    });
+  }
+};
+function reconcile(db, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const limit = Math.max(1, Math.min(opts.limit ?? 200, 1e4));
+  const learning = learningOf(opts.learning, opts.config);
+  const pricing = opts.pricing ?? opts.config?.usage?.pricing;
+  const rows = db.adjudicator.nonFinal(limit, now - SETTLE_MS);
+  if (!rows.length) return { scanned: 0, updated: 0, finalized: 0, linked: 0, learned: 0 };
+  const isSwarm = (r) => (r.surface === "agent" || r.surface === "plan") && !!r.runId && typeof r.taskId === "number";
+  const sessionsSince = /* @__PURE__ */ new Map();
+  const note = (sid, ts) => {
+    if (!sid) return;
+    const cur = sessionsSince.get(sid);
+    if (cur === void 0 || ts < cur) sessionsSince.set(sid, ts);
+  };
+  for (const r of rows) {
+    note(r.sessionId, r.ts);
+    if (isSwarm(r) && !r.sessionId) note(db.swarm.runGet(r.runId)?.session_id, r.ts);
+  }
+  for (const w of rows.filter(isSwarm)) {
+    for (const wk of db.swarm.workers(w.runId))
+      if (wk.task_id === w.taskId) note(wk.session_id, w.ts);
+  }
+  const minTs = Math.min(...rows.map((r) => r.ts));
+  const rec = new Reconciler(db, now, learning, pricing, sessionsSince);
+  rec.seedTaken(minTs);
+  rec.result.scanned = rows.length;
+  const swarm = rows.filter(isSwarm);
+  const rest = rows.filter((r) => !isSwarm(r));
+  for (const row of swarm) {
+    try {
+      rec.swarmRow(row);
+    } catch {
+    }
+  }
+  try {
+    rec.linkAgents(rest.filter((r) => r.surface === "agent"));
+  } catch {
+  }
+  for (const row of rest) {
+    try {
+      if (row.surface === "agent") rec.agentRow(row);
+      else if (row.surface === "prompt") rec.promptRow(row, minTs);
+      else rec.otherRow(row);
+    } catch {
+    }
+  }
+  return rec.result;
+}
+function feedbackOf(row) {
+  const src = row.outcomeSource ?? "";
+  if (src.startsWith("feedback:")) {
+    const k = src.slice("feedback:".length);
+    return Object.hasOwn(FEEDBACK_OUTCOME, k) ? k : void 0;
+  }
+  if (src === "feedback")
+    return row.outcome === "failure" ? "too_small" : row.outcome === "success" ? "good" : void 0;
+  return void 0;
+}
+function ranAsRole(db, row) {
+  if (!row.runId || typeof row.taskId !== "number") return void 0;
+  const task = db.swarm.taskGet(row.taskId);
+  if (task && task.run_id === row.runId && task.role) return task.role;
+  if (!row.agentId) return void 0;
+  return db.swarm.workers(row.runId).find((w) => w.agent_id === row.agentId)?.role ?? void 0;
+}
+var signalKey = (s) => `${s.dimension}\0${s.bucket}\0${s.option}`;
+function parseScoresObject(scores) {
+  if (!scores) return {};
+  try {
+    const s = JSON.parse(scores);
+    return s && typeof s === "object" && !Array.isArray(s) ? s : null;
+  } catch {
+    return null;
+  }
+}
+function taughtOf(row) {
+  const s = parseScoresObject(row.scores);
+  const raw = s?.taught;
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const t of raw) {
+    if (!t || typeof t !== "object") continue;
+    const e = t;
+    if ((e.dimension === "tier" || e.dimension === "role") && typeof e.bucket === "string" && typeof e.option === "string" && typeof e.success === "boolean")
+      out.push({ dimension: e.dimension, bucket: e.bucket, option: e.option, success: e.success });
+  }
+  return out;
+}
+function withTaught(scores, lesson) {
+  const s = parseScoresObject(scores);
+  if (!s) return void 0;
+  const taught = lesson.map((l) => ({
+    dimension: l.dimension,
+    bucket: l.bucket,
+    option: l.option,
+    success: l.success
+  }));
+  return JSON.stringify({ ...s, taught });
+}
+function taughtLesson(db, row, ladder = TIERS) {
+  const taught = taughtOf(row);
+  if (taught) return taught;
+  const prior = feedbackOf(row);
+  return prior ? feedbackLesson(db, row, prior, ladder) : reconcileLesson(db, row);
+}
+function reconcileLesson(db, row) {
+  if (!row.final || row.outcomeSource !== "swarm" && row.outcomeSource !== "redo") return [];
+  if (row.outcome !== "success" && row.outcome !== "failure") return [];
+  if (!row.runId || typeof row.taskId !== "number") return [];
+  if (row.surface === "plan") {
+    const cutoff = row.outcomeTs ?? Number.POSITIVE_INFINITY;
+    const tracked = db.adjudicator.forTask(row.runId, row.taskId).some((s) => s.surface === "agent" && s.ts <= cutoff);
+    if (tracked) return [];
+  } else if (row.surface !== "agent") return [];
+  const success = row.outcome === "success";
+  const b = bucketsOf(row);
+  const out = [];
+  const tier = tierOf(row.actualModel);
+  if (tier && b.tier !== void 0)
+    out.push({
+      dimension: "tier",
+      bucket: b.tier,
+      option: tier,
+      success,
+      costUsd: row.actualCostUsd
+    });
+  const role = ranAsRole(db, row);
+  if (role)
+    out.push({
+      dimension: "role",
+      bucket: b.role,
+      option: role,
+      success,
+      costUsd: row.actualCostUsd
+    });
+  return out;
+}
+function feedbackLesson(db, row, feedback, ladder = TIERS) {
+  const b = bucketsOf(row);
+  const success = FEEDBACK_OUTCOME[feedback] === "success";
+  const cost = row.actualCostUsd;
+  const out = [];
+  const tier = tierOf(row.actualModel) ?? tierOf(row.modelFinal) ?? tierOf(row.modelRequested) ?? tierOf(row.tier) ?? void 0;
+  if (tier && b.tier !== void 0) {
+    out.push({ dimension: "tier", bucket: b.tier, option: tier, success, costUsd: cost });
+    if (feedback === "too_big") {
+      const at = ladder.indexOf(tier);
+      const lower = at > 0 ? ladder[at - 1] : void 0;
+      if (lower) out.push({ dimension: "tier", bucket: b.tier, option: lower, success: true });
+    }
+  }
+  if (feedback === "good") {
+    const role = ranAsRole(db, row) ?? row.role ?? void 0;
+    if (role)
+      out.push({ dimension: "role", bucket: b.role, option: role, success: true, costUsd: cost });
+  }
+  return out;
+}
+function adjustSignal(db, sig, dn, ds, df, learning, now) {
+  if (!learning.enabled) return false;
+  const inBucket = db.adjudicator.biasAll().filter((r) => r.dimension === sig.dimension && r.bucket === sig.bucket);
+  const target = inBucket.find((r) => r.option === sig.option);
+  if (!target) return false;
+  target.n = Math.max(0, target.n + dn);
+  target.s = clamp(target.s + ds, 0, target.n);
+  target.f = clamp(target.f + df, 0, target.n);
+  target.updatedAt = now;
+  const med = bucketMedianOf(inBucket);
+  for (const r of inBucket) {
+    const bias = computeBias(r, med, learning);
+    if (r !== target && bias === r.bias) continue;
+    r.bias = bias;
+    db.adjudicator.biasUpsert({ ...r, updatedAt: r === target ? now : r.updatedAt });
+  }
+  return true;
+}
+function replaceLesson(db, before, after, learning, now = Date.now()) {
+  if (!learning.enabled) return 0;
+  const prev = new Map(before.map((s) => [signalKey(s), s]));
+  let changed = 0;
+  for (const s of after) {
+    const k = signalKey(s);
+    const p = prev.get(k);
+    prev.delete(k);
+    if (p === void 0) {
+      recordSignal(db, s, learning, now);
+      changed++;
+    } else if (p.success !== s.success) {
+      if (!adjustSignal(db, s, 0, s.success ? 1 : -1, s.success ? -1 : 1, learning, now))
+        recordSignal(db, s, learning, now);
+      changed++;
+    }
+  }
+  for (const p of prev.values())
+    if (adjustSignal(db, p, -1, p.success ? -1 : 0, p.success ? 0 : -1, learning, now)) changed++;
+  return changed;
+}
+var FEEDBACK_OUTCOME = Object.freeze({
+  good: "success",
+  too_small: "failure",
+  too_big: "success"
+});
+
+// src/adjudicator/swarm.ts
+init_esm_shims();
+function dispatchRule(f) {
+  if (f.fork) return { model: "fork", effort: "fork" };
+  return {
+    model: f.forced ? "forced" : f.ranged ? "ranged" : f.pin ? "pin" : "pass",
+    effort: f.effortSet || f.saturated ? "informational" : "pass"
+  };
+}
+var ROLE_NOTE_MIN = 0.7;
+function rangedTier(tier, range, floor, ceiling) {
+  const r = tierRank(tier);
+  const applyLo = tierRank(floor);
+  const lo = Math.max(tierRank(range.floor), applyLo);
+  const hi = Math.min(tierRank(range.ceiling), Math.max(applyLo, tierRank(ceiling)));
+  if (r < 0 || lo < 0 || lo > hi) return void 0;
+  return TIERS[Math.min(hi, Math.max(lo, r))];
+}
+var LADDER = { floor: TIERS[0], ceiling: TIERS[TIERS.length - 1] };
+function appliedTier(tier, floor, ceiling) {
+  return rangedTier(tier, LADDER, floor, ceiling);
+}
+function rangedPasses(pick, fallback) {
+  return !!pick && pick !== tierOf(fallback);
+}
+function rangedPart(range, pick) {
+  const span = `range ${range.floor}\u2013${range.ceiling}`;
+  if (rangedPasses(pick, range.fallback))
+    return `model ${pick} (${span}, fallback ${range.fallback})`;
+  return pick ? `fallback ${range.fallback} (${span}; matches the adjudicator's pick)` : `fallback ${range.fallback} (${span}; no pick inside apply.floor..ceiling)`;
+}
+function keptModelOf(rule) {
+  return rule.model === "pin" ? "pin" : rule.model === "forced" ? "force" : rule.model === "fork" ? "fork" : void 0;
+}
+function pinHome(pin) {
+  return pin.source === "project" || pin.source === void 0 ? "remove the pin in swarm.yaml" : `remove the ${pin.source} agent's model pin`;
+}
+function pinnedPart(pin, model, fix = pinHome(pin)) {
+  if (pin.status === "unknown")
+    return `model pin is unknown (${model ? `adjudicator would pick ${model}; ` : ""}not overridden while the agent's definition cannot be read)`;
+  const pinned = pin.model ?? "?";
+  if (!model || (tierOf(pinned) ?? pinned) === model)
+    return `pinned ${pinned} (matches the adjudicator's pick)`;
+  return `pinned ${pinned} (adjudicator would pick ${model}; ${fix} to let it choose)`;
+}
+function effortForced(env = process.env) {
+  const v = env.CLAUDE_CODE_EFFORT_LEVEL?.trim();
+  return !!v;
+}
+
+// src/adjudicator/hooks.ts
+var ADVICE_MAX = 220;
+var DEGRADED_MAX = 200;
+var HINT_WINDOW_MS = 30 * 6e4;
+var WARMUP_BUDGET_MS = 1e4;
+var RAW_TOOLS = /* @__PURE__ */ new Set(["Bash", "Read", "Grep", "Glob", "WebFetch", "WebSearch"]);
+var AGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var str = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+function clip(s, n) {
+  const one = s.replace(/\s+/g, " ").trim();
+  return one.length > n ? `${one.slice(0, n - 1)}\u2026` : one;
+}
+function log(line) {
+  hookLog("info", line);
+}
+function active(cfg, input) {
+  return cfg.enabled && input.client !== "cursor";
+}
+function docsLibraries(ctx) {
+  const names = /* @__PURE__ */ new Set();
+  for (const src of readManifestAt(manifestPath(ctx), ctx.root).sources) {
+    names.add(src.name.toLowerCase());
+    const pkg = /^(?:npm|pypi|go|crates?):(.+)$/.exec(String(src.provider ?? ""))?.[1];
+    if (pkg) names.add(pkg.toLowerCase());
+  }
+  return names.size ? [...names] : void 0;
+}
+function engineOptions(db, cfg, deps) {
+  const o = {
+    config: cfg,
+    store: db.adjudicator,
+    context: "hook",
+    log,
+    bias: (_req, f, h) => biasFor(db, cfg.learning, { complexity: h.complexity, intent: topIntent(f) ?? "none" })
+  };
+  if (deps.env) o.env = deps.env;
+  if (deps.now) o.now = deps.now;
+  if (deps.provider !== void 0) o.provider = deps.provider;
+  if (deps.fetch) o.deps = { fetch: deps.fetch };
+  return o;
+}
+function adviceLine(v, f) {
+  const c = Math.round(v.complexity);
+  const intent = topIntent(f);
+  const parts = [`eminiar adjudicator: complexity ${c}/4${intent ? ` (${intent})` : ""}`];
+  if (v.tool.choice !== "none") {
+    const tools = v.tool.entries.filter((e, i) => e.option !== "none" && (i === 0 || e.score >= 0.1)).slice(0, 2).map((e) => e.option);
+    if (tools.length) parts.push(`start with ${tools.join(" \u2192 ")}`);
+  }
+  const role = v.role.choice && v.role.choice !== "none" ? `, role ${v.role.choice}` : "";
+  parts.push(`if you delegate: ${v.tier.choice}${role}`);
+  return clip(parts.join(" \xB7 "), ADVICE_MAX);
+}
+var HARNESS_ENVELOPE = /^\s*<(?:agent-message|task-notification|ci-monitor-event|system-reminder)[\s>]/;
+var LEADING_REMINDER = /^\s*<system-reminder(?:\s[^>]*)?>[\s\S]*?<\/system-reminder>/;
+function stripLeadingReminders(text) {
+  let rest = text;
+  for (let m = LEADING_REMINDER.exec(rest); m; m = LEADING_REMINDER.exec(rest)) {
+    rest = rest.slice(m[0].length);
+  }
+  return rest.trim();
+}
+function isHarnessEnvelope(text) {
+  if (typeof text !== "string" || !HARNESS_ENVELOPE.test(text)) return false;
+  const rest = stripLeadingReminders(text);
+  return rest === "" || HARNESS_ENVELOPE.test(rest);
+}
+async function onPrompt(ctx, db, input, sessionId, deps = {}) {
+  try {
+    const cfg = ctx.config.adjudicator;
+    if (!active(cfg, input) || !cfg.surfaces.prompt) return void 0;
+    const raw = (input.prompt ?? "").trim();
+    if (isHarnessEnvelope(raw)) return void 0;
+    const text = stripLeadingReminders(raw);
+    if (text.length < cfg.minPromptChars || text.startsWith("/") || extractFeatures(text).chat) {
+      if (cfg.surfaces.tools) closeToolHint(db, sessionId);
+      return void 0;
+    }
+    const opts = engineOptions(db, cfg, deps);
+    opts.call = cfg.promptMode === "heuristic" ? "never" : cfg.promptMode === "async" ? "async" : "inline";
+    if (opts.call === "async") {
+      opts.spawn = deps.spawn ?? ((job) => spawnAsyncJob(job));
+      opts.projectRoot = ctx.root;
+    }
+    if (sessionId && sessionId !== "unknown") opts.row = { sessionId };
+    const req = { key: "prompt", surface: "prompt", text };
+    const libraries = docsLibraries(ctx);
+    if (libraries) {
+      const hints = { libraries };
+      req.hints = hints;
+    }
+    const a = await adjudicateOne(req, opts);
+    const out = { context: adviceLine(a.verdict, a.features) };
+    const main = mainSessionAdvice(db, cfg, sessionId, a.verdict, (deps.now ?? Date.now)());
+    if (main) {
+      if (cfg.advice.mainSession === "user") out.systemMessage = main;
+      else out.context = `${out.context}
+${main}`;
+    }
+    return out;
+  } catch (err) {
+    log(`adjudicator: onPrompt ${err?.message ?? String(err)}`);
+    return void 0;
+  }
+}
+function mainSessionAdvice(db, cfg, sessionId, v, now) {
+  if (cfg.advice.mainSession === "off" || !sessionId || sessionId === "unknown") return void 0;
+  const key = `adjudicator:main:${sessionId}`;
+  let st = { n: 0 };
+  try {
+    const raw = db.metaGet(key);
+    if (raw) st = JSON.parse(raw);
+  } catch {
+  }
+  st.n = (Number(st.n) || 0) + 1;
+  let line;
+  if (st.last === void 0 || st.n - st.last >= cfg.advice.cooldownPrompts) {
+    const base = resolveBaseline(db, { sessionId, ts: now, env: {} });
+    const current = base.source === "session" ? tierOf(base.model) : void 0;
+    const advice = v.tier.choice;
+    if (current && tierRank(advice) >= 0 && tierRank(current) - tierRank(advice) >= 2) {
+      const c = Math.round(v.complexity);
+      line = `eminiar adjudicator: this prompt looks ${c <= 1 ? "small" : "moderate"} (complexity ${c}/4); /model ${advice} would be cheaper than ${current}`;
+      st.last = st.n;
+    }
+  }
+  db.metaSet(key, JSON.stringify(st));
+  return line;
+}
+function withModel(out, input, model) {
+  const h = out?.hookSpecificOutput;
+  if (h?.permissionDecision === "deny" || h?.permissionDecision === "ask") return out;
+  return {
+    ...out,
+    hookSpecificOutput: {
+      ...h,
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow",
+      updatedInput: { ...h?.updatedInput ?? input, model }
+    }
+  };
+}
+function withNote(out, note) {
+  if (!note) return out;
+  const h = out?.hookSpecificOutput;
+  const cur = h?.additionalContext;
+  return {
+    ...out,
+    hookSpecificOutput: {
+      ...h,
+      hookEventName: "PreToolUse",
+      additionalContext: cur ? `${cur}
+${note}` : note
+    }
+  };
+}
+async function afterRouting(ctx, input, spawn, out, deps = {}) {
+  try {
+    if (!active(ctx.config.adjudicator, input) || !input.tool_input) return out;
+    if (AGENT_TOOLS.has(input.tool_name ?? "")) {
+      const a = await onPreAgent(ctx, input, spawn, deps);
+      if (!a) return out;
+      const next = a.model ? withModel(out, input.tool_input, a.model) : out;
+      return withNote(next, a.note);
+    }
+    return withNote(out, onPreTool(ctx, input, out, deps));
+  } catch (err) {
+    log(`adjudicator: afterRouting ${err?.message ?? String(err)}`);
+    return out;
+  }
+}
+function clampTier(tier, floor, ceiling) {
+  return appliedTier(tier, floor, ceiling);
+}
+function withPin(db, rowId, pin, kept, extra = {}) {
+  try {
+    const scores = withKeptModel(db.adjudicator.get(rowId)?.scores, kept, { pin, ...extra });
+    return scores === void 0 ? {} : { scores };
+  } catch {
+    return {};
+  }
+}
+function storedRoleConfidence(scores) {
+  if (!scores) return void 0;
+  try {
+    const c = JSON.parse(scores)?.role?.confidence;
+    if (typeof c === "number" && Number.isFinite(c)) return c;
+  } catch {
+    return void 0;
+  }
+  return briefUnitsOf(scores)?.roleConfidence;
+}
+function findTask(ctx, db, runId, taskId) {
+  const t = db.swarm.taskGet(taskId);
+  if (t && t.run_id === runId) return { db, task: t };
+  const main = coordinationRoot(ctx.root);
+  if (main === ctx.root) return void 0;
+  const mdb = getStorage(getContext(main), { vectors: false });
+  const m = mdb.swarm.taskGet(taskId);
+  return m && m.run_id === runId ? { db: mdb, task: m } : void 0;
+}
+async function onPreAgent(ctx, input, spawn, deps = {}) {
+  const cfg = ctx.config.adjudicator;
+  if (!active(cfg, input) || !cfg.surfaces.agent) return void 0;
+  if (!AGENT_TOOLS.has(input.tool_name ?? "")) return void 0;
+  const ti = input.tool_input ?? {};
+  const env = deps.env ?? process.env;
+  const now = (deps.now ?? Date.now)();
+  const worker = spawn?.kind === "worker" ? spawn : void 0;
+  const agentType = str(ti.subagent_type) ?? "general-purpose";
+  let db = getStorage(ctx, { vectors: false });
+  let task;
+  if (worker?.runId && typeof worker.taskId === "number") {
+    try {
+      const found = findTask(ctx, db, worker.runId, worker.taskId);
+      if (found) ({ db, task } = found);
+    } catch {
+    }
+  }
+  const text = task ? `${task.title}
+${task.detail ?? ""}` : `${str(ti.description) ?? ""}
+${str(ti.prompt) ?? ""}`;
+  if (!text.trim()) return void 0;
+  let plan;
+  if (task && worker?.runId) {
+    try {
+      plan = db.adjudicator.forTask(worker.runId, task.id).filter((r) => r.surface === "plan").pop();
+    } catch {
+    }
+  }
+  const explicit = str(ti.model);
+  const pin = resolveAgentPin(agentType, { root: ctx.root, cwd: input.cwd, env });
+  const pinned = pin.status === "pinned" ? pin.model : void 0;
+  const pinnedRespected = cfg.apply.respectFrontmatter && isPinned(pinned);
+  const pinUnknown = cfg.apply.respectFrontmatter && pin.status === "unknown";
+  const isForced = subagentModelForced(env);
+  const fork = isFork(agentType);
+  const effortSet = !!str(ti.effort) || effortForced(env);
+  const ranged = cfg.apply.respectFrontmatter && !fork && !isForced && pin.status === "ranged" && pin.range && isPinned(pin.model) ? { floor: pin.range.floor, ceiling: pin.range.ceiling, fallback: pin.model } : void 0;
+  const facts = { fork, forced: isForced, pin: pinnedRespected || pinUnknown, effortSet };
+  const before = dispatchRule({ ...facts, ranged: !!ranged });
+  const applyMode = cfg.mode === "apply";
+  const inScope = cfg.apply.scope === "all" || !!worker;
+  const mayApply = applyMode && inScope && (before.model === "pass" || before.model === "ranged") && !explicit;
+  const sessionId = input.session_id && input.session_id !== "unknown" ? input.session_id : void 0;
+  const subagentEnv = before.model === "fork" || before.model === "forced" || pin.inherit ? {} : { CLAUDE_CODE_SUBAGENT_MODEL: env.CLAUDE_CODE_SUBAGENT_MODEL };
+  const baselinePin = pin.status === "ranged" ? pin.model : pinned;
+  const baseline = resolveBaseline(db, {
+    pinned: before.model === "fork" ? void 0 : before.model === "forced" ? str(env.CLAUDE_CODE_SUBAGENT_MODEL) : baselinePin,
+    fallbackPin: ranged?.fallback,
+    env: subagentEnv,
+    sessionId,
+    ts: now
+  });
+  const row = {
+    modelRequested: explicit ?? null,
+    baselineModel: baseline.model
+  };
+  if (sessionId) row.sessionId = sessionId;
+  if (input.tool_use_id) row.toolUseId = input.tool_use_id;
+  if (worker?.runId && task) {
+    row.runId = worker.runId;
+    row.taskId = task.id;
+  }
+  if (plan) {
+    row.parentId = plan.id;
+    for (const k of ["complexity", "tier", "effort", "tool", "role", "confidence"])
+      if (plan[k] !== void 0 && plan[k] !== null) row[k] = plan[k];
+  }
+  const opts = engineOptions(db, cfg, deps);
+  opts.call = mayApply && !plan ? "inline" : "never";
+  opts.row = row;
+  const req = { key: "agent", surface: "agent", text };
+  const hints = {};
+  if (task) {
+    hints.files = task.files.length;
+    hints.deps = task.deps.length;
+    if (task.role) hints.role = task.role;
+  }
+  const libraries = docsLibraries(ctx);
+  if (libraries) hints.libraries = libraries;
+  if (Object.keys(hints).length) req.hints = hints;
+  const a = await adjudicateOne(req, opts);
+  const v = a.verdict;
+  const tier = plan?.tier ?? v.tier.choice;
+  const conf = plan?.confidence ?? v.tier.confidence;
+  const c = Math.round(plan?.complexity ?? v.complexity);
+  const effort = plan?.effort ?? v.effort;
+  const role = plan?.role ?? v.role.choice;
+  const clamped = clampTier(tier, cfg.apply.floor, cfg.apply.ceiling);
+  const units = plan ? briefUnitsOf(plan.scores) : a.units;
+  const saturated = !!units?.saturated;
+  const roleConf = (plan ? storedRoleConfidence(plan.scores) : void 0) ?? v.role.confidence;
+  const pick = ranged ? rangedTier(tier, ranged, cfg.apply.floor, cfg.apply.ceiling) : void 0;
+  const moves = !!ranged && rangedPasses(pick, ranged.fallback);
+  const rule = dispatchRule({
+    ...facts,
+    ranged: moves,
+    pin: facts.pin || !!ranged && !moves,
+    saturated
+  });
+  let action;
+  let model;
+  let modelFinal;
+  if (!applyMode || !inScope) {
+    action = "advised";
+    modelFinal = explicit ?? null;
+  } else if (fork) {
+    action = "respected";
+    modelFinal = null;
+  } else if (isForced || explicit || pinnedRespected) {
+    action = "respected";
+    modelFinal = isForced ? str(env.CLAUDE_CODE_SUBAGENT_MODEL) ?? null : explicit ?? (isPinned(pinned) ? pinned : null);
+  } else if (ranged) {
+    if (moves && pick && conf >= cfg.apply.minConfidence) {
+      action = "applied";
+      model = pick;
+      modelFinal = pick;
+    } else {
+      action = moves ? "advised" : "respected";
+      modelFinal = ranged.fallback;
+    }
+  } else if (clamped && conf >= cfg.apply.minConfidence && !pinUnknown) {
+    action = "applied";
+    model = clamped;
+    modelFinal = clamped;
+  } else {
+    action = "advised";
+    modelFinal = null;
+  }
+  const kept = model ? void 0 : keptModelOf(rule);
+  const pinDeferred = kept === "pin";
+  const advised = ranged ? pick : clamped;
+  if (a.rowId !== void 0) {
+    try {
+      db.adjudicator.update(a.rowId, {
+        action,
+        modelFinal,
+        // A ranged dispatch is flagged with its fallback, the savings baseline. Every dispatch
+        // stores the tier its note names (the ranged pick, else the verdict clamped to the apply
+        // bounds), the model follow detection compares the call with (savings.ts advisedPick).
+        ...withPin(db, a.rowId, pin, kept, {
+          ...ranged ? { [RANGED_FLAG]: true, [FALLBACK_PIN_FIELD]: ranged.fallback } : {},
+          ...advised ? { [ADVISED_PICK_FIELD]: advised } : {}
+        })
+      });
+    } catch {
+    }
+  }
+  const why = `complexity ${c}, conf ${conf.toFixed(2)}`;
+  if (rule.model === "fork") {
+    const note2 = `adjudicator: fork runs on the main session's model; no \`model\` or \`effort\` to pass (${why})`;
+    const out2 = { action, note: clip(note2, ADVICE_MAX) };
+    if (a.rowId !== void 0) out2.rowId = a.rowId;
+    return out2;
+  }
+  const effortHint = rule.effort === "pass" ? `pass effort:'${effort}' (Claude Code ${AGENT_EFFORT_SINCE}+)` : saturated && !effortSet ? `effort ${effort}: informational (brief saturated)` : `suggested effort ${effort}`;
+  const extras = [effortHint];
+  if (role && role !== "none" && roleConf >= ROLE_NOTE_MIN) extras.push(`role ${role}`);
+  if (applyMode && inScope && pinUnknown && !isForced && !explicit)
+    extras.push("not applied: the agent's model pin is unknown");
+  const span = ranged ? `range ${ranged.floor}\u2013${ranged.ceiling}, fallback ${ranged.fallback}; ` : "";
+  let note;
+  if (action === "applied") {
+    note = `adjudicator: model ${model} applied (${span}${why}); ${extras.join(", ")}`;
+  } else if (rule.model === "forced") {
+    note = `adjudicator: CLAUDE_CODE_SUBAGENT_MODEL_FORCE sets the model${clamped ? ` (adjudicator would pick ${clamped}; ${why})` : ` (${why})`}; ${extras.join(", ")}`;
+  } else if (rule.model === "ranged" && !explicit) {
+    note = `adjudicator: model ${pick} would do (${span}${why}): pass model:'${pick}'; ${extras.join(", ")}`;
+  } else if (ranged && pinDeferred && !explicit) {
+    note = `adjudicator: ${rangedPart(ranged, pick)}; ${extras.join(", ")}`;
+  } else if (pinDeferred && !explicit) {
+    const part = pinnedPart(
+      { status: pinUnknown ? "unknown" : "pinned", model: pinned, source: pin.source },
+      clamped,
+      worker && pin.source === "project" ? void 0 : `remove the model pin in ${pin.file ?? "the agent's definition"}`
+    );
+    note = `adjudicator: ${part}; ${extras.filter((e) => !e.startsWith("not applied")).join(", ")}`;
+  } else if (action === "advised" && !explicit && clamped && clamped !== (tierOf(baseline.model) ?? baseline.model)) {
+    note = `adjudicator: model ${clamped} would do (${why}): pass model:'${clamped}'; ${extras.join(", ")}`;
+  } else {
+    note = `adjudicator: ${extras.join(", ")}`;
+  }
+  const out = { action, note: clip(note, ADVICE_MAX) };
+  if (model) out.model = model;
+  if (a.rowId !== void 0) out.rowId = a.rowId;
+  return out;
+}
+var POST_AGENT_LOOKBACK_MS = 24 * 36e5;
+function agentLinkOf(input) {
+  const r = input.tool_response;
+  const o = r && typeof r === "object" && !Array.isArray(r) ? r : {};
+  const resolvedModel = str(o.resolvedModel);
+  const agentId = str(o.agentId) ?? agentFromMeta(input.transcript_path, input.tool_use_id);
+  if (!agentId) return void 0;
+  return resolvedModel ? { agentId, resolvedModel } : { agentId };
+}
+function agentFromMeta(transcriptPath, toolUseId) {
+  if (!transcriptPath || !toolUseId) return void 0;
+  const dir = join2(dirname2(transcriptPath), basename2(transcriptPath, ".jsonl"), "subagents");
+  let names;
+  try {
+    names = readdirSync2(dir).filter((n) => /^agent-[A-Za-z0-9_-]+\.meta\.json$/.test(n));
+  } catch {
+    return void 0;
+  }
+  for (const n of names) {
+    try {
+      const m = JSON.parse(readFileSync2(join2(dir, n), "utf8"));
+      if (m?.toolUseId === toolUseId) return n.slice("agent-".length, -".meta.json".length);
+    } catch {
+    }
+  }
+  return void 0;
+}
+function onPostAgent(ctx, db, input, deps = {}) {
+  try {
+    const cfg = ctx.config.adjudicator;
+    if (!active(cfg, input) || !cfg.surfaces.agent) return void 0;
+    if (!AGENT_TOOLS.has(input.tool_name ?? "") || !input.tool_use_id) return void 0;
+    const link = agentLinkOf(input);
+    if (!link) return void 0;
+    const since = (deps.now ?? Date.now)() - POST_AGENT_LOOKBACK_MS;
+    const dbs = [db];
+    const main = coordinationRoot(ctx.root);
+    if (main !== ctx.root) dbs.push(getStorage(getContext(main), { vectors: false }));
+    for (const d of dbs) {
+      const row = d.adjudicator.byToolUseId(input.tool_use_id, { surface: "agent", since });
+      if (!row) continue;
+      if (row.agentId) {
+        if (row.agentId !== link.agentId)
+          log(
+            `adjudicator: row ${row.id} keeps agent ${row.agentId}, dispatch says ${link.agentId}`
+          );
+        return void 0;
+      }
+      const patch = { agentId: link.agentId };
+      if (link.resolvedModel && !row.actualModel) patch.actualModel = link.resolvedModel;
+      d.adjudicator.update(row.id, patch);
+      return row.id;
+    }
+    return void 0;
+  } catch (err) {
+    log(`adjudicator: onPostAgent ${err?.message ?? String(err)}`);
+    return void 0;
+  }
+}
+function onPreTool(ctx, input, out, deps = {}) {
+  const cfg = ctx.config.adjudicator;
+  if (!active(cfg, input) || !cfg.surfaces.tools) return void 0;
+  if (!RAW_TOOLS.has(input.tool_name ?? "") || !input.session_id) return void 0;
+  const h = out?.hookSpecificOutput;
+  if (h?.additionalContext || h?.permissionDecision) return void 0;
+  try {
+    const db = getStorage(ctx, { vectors: false });
+    const row = db.adjudicator.latestForSession(input.session_id, "prompt");
+    if (!row || row.toolUseId || !row.tool?.startsWith("em_")) return void 0;
+    if ((deps.now ?? Date.now)() - row.ts > HINT_WINDOW_MS) return void 0;
+    db.adjudicator.update(row.id, { toolUseId: input.tool_use_id || "hinted" });
+    const c = Math.round(row.complexity ?? 0);
+    return clip(
+      `eminiar adjudicator: this prompt was scored for ${row.tool} (complexity ${c}/4); ${input.tool_name} works, but ${row.tool} usually answers it with less context.`,
+      ADVICE_MAX
+    );
+  } catch {
+    return void 0;
+  }
+}
+function closeToolHint(db, sessionId) {
+  try {
+    const row = db.adjudicator.latestForSession(sessionId, "prompt");
+    if (row && !row.toolUseId) db.adjudicator.update(row.id, { toolUseId: "superseded" });
+  } catch {
+  }
+}
+function onSessionStart(ctx, db, input, deps = {}) {
+  try {
+    const cfg = ctx.config.adjudicator;
+    if (!active(cfg, input)) return void 0;
+    const env = deps.env ?? process.env;
+    const now = (deps.now ?? Date.now)();
+    const r = resolveAdjudicator(cfg, { context: "hook", env });
+    const issues = [];
+    if (r.degraded === "no_key") issues.push(`no key for ${r.configured}`);
+    else if (r.degraded === "no_consent")
+      issues.push(`${r.configured} is remote and has no consent`);
+    else if (r.degraded && r.degraded !== "hook_context")
+      issues.push(
+        `${r.configured}: ${String(r.degraded).replace(/_/g, " ")}${r.detail ? ` (${r.detail})` : ""}`
+      );
+    if (r.provider !== "heuristic") {
+      const s = db.adjudicator.providerState(r.provider);
+      if (s && s.state !== "closed" && s.retryAt !== null && s.retryAt > now)
+        issues.push(`${r.provider} ${s.state === "slow" ? "is slow" : "breaker open"}`);
+    }
+    if (cfg.mode === "apply") {
+      const sum = db.adjudicator.summary(now - 7 * 864e5);
+      if (sum.applyIneffective > 0)
+        issues.push(
+          `apply did not take effect on ${sum.applyIneffective} of ${sum.applyChecked} dispatches: use advise`
+        );
+    }
+    if (r.provider === "openai-compatible" && r.preset === "ollama" && cfg.promptMode !== "heuristic")
+      warmUp(ctx, cfg, r, deps);
+    if (!issues.length) return void 0;
+    return clip(
+      `eminiar adjudicator: ${issues.join("; ")}; \`eminiar adjudicator status\` explains.`,
+      DEGRADED_MAX
+    );
+  } catch {
+    return void 0;
+  }
+}
+function warmUp(ctx, cfg, r, deps) {
+  const request = { key: "warmup", surface: "test", text: "warm up" };
+  const job = {
+    v: 1,
+    projectRoot: ctx.root,
+    request,
+    // The same key the child computes (no hints or catalogues: just the config's ladder and weights).
+    cacheKey: cacheKeyFor(request, r, { config: cfg }),
+    config: cfg,
+    context: "hook",
+    budgetMs: WARMUP_BUDGET_MS
+  };
+  (deps.spawn ?? ((j) => spawnAsyncJob(j)))(job);
+}
+function onSessionEnd(ctx, db, input) {
+  try {
+    if (!active(ctx.config.adjudicator, input)) return;
+    if (input.session_id) db.metaDelete(`adjudicator:main:${input.session_id}`);
+    reconcile(db, { limit: 200, config: ctx.config });
+  } catch (err) {
+    log(`adjudicator: reconcile ${err?.message ?? String(err)}`);
+  }
+}
+export {
+  ADVICE_MAX,
+  DEGRADED_MAX,
+  HINT_WINDOW_MS,
+  POST_AGENT_LOOKBACK_MS,
+  WARMUP_BUDGET_MS,
+  adviceLine,
+  afterRouting,
+  agentLinkOf,
+  clampTier,
+  isHarnessEnvelope,
+  onPostAgent,
+  onPreAgent,
+  onPreTool,
+  onPrompt,
+  onSessionEnd,
+  onSessionStart,
+  stripLeadingReminders,
+  withModel,
+  withNote
+};
+//# sourceMappingURL=hook-hooks-U6GDOQSY.js.map