eminiar 0.12.0 → 0.13.1

package/dist/hook-chunk-RYZAFUTT.js

@@ -0,0 +1,3780 @@
+import { createRequire as __emCreateRequire } from "node:module"; const require = __emCreateRequire(import.meta.url);
+import {
+  AdjudicatorConfigSchema,
+  DEFAULT_ROLES,
+  SCORER_VERSION,
+  SURFACES,
+  TIERS,
+  TOOL_IDS,
+  classifyPrompt,
+  external_exports,
+  getContext,
+  getStorage,
+  init_esm_shims,
+  loadConfig,
+  paths
+} from "./hook-chunk-BECSRJFD.js";
+
+// src/adjudicator/async.ts
+init_esm_shims();
+import { spawn as nodeSpawn } from "child_process";
+
+// src/adjudicator/engine.ts
+init_esm_shims();
+import { createHash as createHash3 } from "crypto";
+
+// src/adjudicator/blend.ts
+init_esm_shims();
+
+// src/adjudicator/heuristic.ts
+init_esm_shims();
+
+// src/adjudicator/features.ts
+init_esm_shims();
+var p = (intent, re, w = 1) => ({ intent, re, w });
+var KEBAB_NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/;
+function isPackageName(name, libraries) {
+  return !libraries || !KEBAB_NAME.test(name) || libraries.includes(name);
+}
+var PKG = String.raw`(?![\w.-]*\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|rb|php|java|md|json|ya?ml|toml|sql|sh|css|html)\b)(?:@[a-z0-9][\w.-]*\/[a-z0-9][\w.-]*|node:[a-z_]+|[a-z][a-z0-9]*(?:[-.][a-z0-9]+)+|[a-z]{2,}\d+[a-z]*)(?![\w./-])`;
+var DET = "(?:the|a|an|its|their|our|this|that|these|those|my)";
+var CLOSED = "(?:when|if|after|before|while|until|unless|once|on|at|in|into|onto|from|to|with|without|for|by|of|about|and|or|but|so|then|is|are|was|were|be|been|does|do|did|doesn't|don't|isn't|aren't|should|would|will|can|could|must|may|might|has|have|had|not|never)";
+var NP_WORD = String.raw`(?!${CLOSED}\b)[\w@./:+-]+`;
+var DOC_HEAD = String.raw`(?:docs?|documentation|readme|release notes|changelog|api reference|reference|manual|wiki|site|website|(?<!\b(?:next|previous|prev|first|last|each|every|another) )pages?(?! of\b))(?=\s*(?:$|[,.;:!?)])|\s+${CLOSED}\b)`;
+var FETCH_OBJECT = String.raw`(?:${DET} )?(?:${NP_WORD} ){0,3}(?:https?:\/\/|${DOC_HEAD})|(?:${DET} )?${PKG}(?=\s*(?:$|[,.;:!?]|v?\d))|the latest\b`;
+var FETCH_VERB = "(?:fetch|download|crawl|scrape)";
+var WRITTEN_DOC = String.raw`(?:${DET} )?(?:docs|readme|documentation|changelog|release notes|help text|(?:[\w@./:+-]+ ){0,2}(?:docs?|documentation|reference|manual|man|help|wiki|api|readme|changelog) (?:page|site|section|entry|article)s?)\b`;
+var EDIT_DOC_VERB = "(?:update|edit|fix|tweak|reword|touch up|expand|remove|correct|clean up)";
+var WRITE_DOC_VERB = "(?:add|write|draft|create)";
+var REWRITE_DOC_VERB = "(?:rewrite|restructure|reorgani[sz]e)";
+var DOC_WRITE = new RegExp(
+  String.raw`\b(?:${EDIT_DOC_VERB}|${WRITE_DOC_VERB}|${REWRITE_DOC_VERB}) ${WRITTEN_DOC}`,
+  "g"
+);
+var FORMATTER = "(?:biome|prettier|dprint|ruff|black|gofmt|rustfmt|clang-format)";
+var UI_NOUN = "(?:view|page|dashboard|panel|tab|sidebar|chart|ui|screen|modal|dialog|card|header|footer|toolbar|menu|tooltip|legend|badge|widget|form|layout|status ?bar|status ?line)";
+var UI_PLACE = `${UI_NOUN}s?`;
+var PHRASES = [
+  // impact: judging the effect of a change is reasoning; listing dependents is a graph lookup
+  p("impact", /\bwhat (?:would|will|could|might) (?:break|change|fail)\b/),
+  p("impact", /\bwhat breaks\b/),
+  p("impact", /\b(?:blast radius|impact of|affected by)\b/),
+  p("impact", /\b(?:what|who|which \w+) (?:else )?(?:depends? on|imports?|calls?|uses?)\b/, 0.5),
+  p(
+    "impact",
+    /\b(?:files?|modules?|code|callers?|places?) (?:that|which) (?:imports?|uses?|calls?|references?)\b/,
+    0.5
+  ),
+  p("impact", /\b(?:callers|usages?|references|dependents|consumers) of\b/, 0.5),
+  // refactor: migrations and platform moves touch every module that uses the old thing
+  p("refactor", /\b(?:esm|cjs|commonjs|typescript|ts|async|python ?3)[- ]only\b/),
+  p(
+    "refactor",
+    /\bdrop (?:the |our )?(?:[\w.-]+ ){0,2}(?:build|support|dependency|runtime|fallback)\b/
+  ),
+  p(
+    "refactor",
+    /\bupgrade (?:[\w.-]+ ){0,3}to (?:the )?(?:next |latest )?(?:major|v?\d+(?:\.x)?)\b/
+  ),
+  p(
+    "refactor",
+    /\b(?:major (?:version )?(?:upgrade|bump)|bump (?:\w+ ){0,3}to (?:the )?next major)\b/
+  ),
+  // "from X to Y" between named things, not numbers ("change the port from 3000 to 8080")
+  p("refactor", /\b(?:port|move|switch|migrate) (?:[\w./-]+ ){0,5}from [a-z][\w./:-]* to\b/),
+  p("refactor", /^\s*port (?:[\w./-]+ ){0,5}to (?=[a-z])/),
+  p("refactor", /\breplace (?:[\w./-]+ ){0,5}with\b/),
+  // An extraction into a function or module is bounded (like "extract"), not a sweeping refactor.
+  p(
+    "implement",
+    /\brefactor (?:[\w./'-]+ ){1,8}into (?:a |an |one |its own |their own |separate |shared )?(?:[\w-]+ ){0,2}(?:function|helper|method|hook|module|class|component|utility|util)s?\b/
+  ),
+  // history
+  p("history", /\bwhy (?:was|were|did)\b(?! we\b)/),
+  p("history", /\bwhen (?:was|were|did)\b/),
+  p("history", /\b(?:git (?:blame|log|show|history)|commit history|check (?:the )?history)\b/),
+  p("history", /\bwho (?:wrote|changed|added|removed)\b/),
+  // A git verb with commits as its object is doing git; commits as the subject of a question are history.
+  p(
+    "git",
+    /\b(?:amend|squash|revert|reword|undo|reset|drop|cherry-pick|rebase|push) (?:the |my |our |these |those )?(?:last |previous |latest |recent )?(?:\w+ )?commits?\b/
+  ),
+  p("history", /\b(?:which|what|whose|last|recent|latest|previous|past) (?:\w+ ){0,2}commits?\b/),
+  p("history", /\bcommits? (?:that|which|touching)\b|\bcommits (?:on|in|since|from|by|between)\b/),
+  p(
+    "history",
+    /\b(?:later|subsequently|eventually) (?:needed|required|got|had|took) (?:a |an |to be )?(?:fix|revert|patch|hotfix)\w*|\b(?:riskiest|most (?:risky|fragile|churned)|(?:bug|fix)-prone)\b/
+  ),
+  // recall (judgement against past decisions); before "why did" style history
+  p(
+    "recall",
+    /\b(?:should we|is it safe|is it ok(?:ay)?|safe to|did we (?:decide|agree|choose|pick)|what did we decide|why did we)\b/
+  ),
+  // run
+  p("run", /\b(?:the )?test suite\b/),
+  p("run", /\brun (?:the |all (?:the )?)?tests?\b/),
+  p("run", /\bnpm (?:audit|run \w+|test|ci)\b/),
+  p("run", /\btype ?check(?:s|ing)?\b/),
+  // bigfile
+  p("bigfile", /\b\d[\d,.]*k?[- ]?(?:lines?|loc)\b/),
+  p("bigfile", /\b(?:whole|entire|full) file\b/),
+  // writing docs is an edit, not a docs lookup; it runs before the docs phrases so a doc that is
+  // the object of a write verb ("update the api page", "write release notes for v2") is masked
+  p(
+    "edit_small",
+    new RegExp(String.raw`\b${EDIT_DOC_VERB} (?:(?:the |our |a )?comments?\b|${WRITTEN_DOC})`)
+  ),
+  p("implement", new RegExp(String.raw`\b${WRITE_DOC_VERB} ${WRITTEN_DOC}`), 0.8),
+  p("refactor", new RegExp(String.raw`\b${REWRITE_DOC_VERB} ${WRITTEN_DOC}`)),
+  // docs: a fetch verb leads only with documentation to fetch as its object
+  p("docs", new RegExp(String.raw`^\s*${FETCH_VERB} (?=${FETCH_OBJECT})`), 0.7),
+  // docs: reading documentation of something else
+  p("docs", /\b(?:docs?|documentation|readme) (?:for|on|about|of)\b/),
+  p("docs", /\b(?:latest|current|newest) version\b/),
+  p("docs", /\b(?:api reference|release notes|changelog for)\b/),
+  p("edit_small", /\bfix (?:the |a )?typos?\b/),
+  // adding a comment or annotation is mechanical, not new behaviour
+  p(
+    "edit_small",
+    /\badd (?:a |an |some )?(?:short |brief |one-line |small )?(?:comments?|docstrings?|jsdoc|log lines?|type annotations?|todo)\b/
+  ),
+  // docs: documentation named as the source (after writing docs, which is an edit)
+  p(
+    "docs",
+    /\b(?:docs?|documentation|reference|manual|man|help|wiki|api) (?:page|pages|site|section|entry|article)\b/
+  ),
+  p(
+    "docs",
+    /\b(?:read|check|see|consult|search|open|browse|skim|look (?:at|in|through)|go through) (?:the |its |their |our )?(?:[\w@./:+-]+ ){0,3}(?:docs|documentation|api reference|reference docs|manual)\b/
+  ),
+  p(
+    "docs",
+    /\b(?:what|how) (?:do|does) (?:the |its |their )?(?:[\w@./:+-]+ ){0,2}(?:docs|documentation|readme|spec|reference) (?:say|recommend|suggest|describe|mention|cover|list)\b|\baccording to (?:the |its |their )?(?:[\w@./:+-]+ ){0,2}(?:docs|documentation|spec|readme)\b/
+  ),
+  // docs: how a third-party package (named like one, never a file) behaves; a kebab-case name
+  // that is not a known library is the project's own ("how does agent-pin pick the model")
+  {
+    ...p(
+      "docs",
+      new RegExp(
+        String.raw`\bhow (?:does|do|can|should|would|will) (${PKG})(?= (?![a-z]+ing\b)[a-z])`
+      )
+    ),
+    pkg: true
+  },
+  {
+    ...p(
+      "docs",
+      new RegExp(
+        String.raw`\b(?:does|do|can|will) (${PKG}) (?:support|handle|allow|provide|offer|expose|have|ship|include|accept|work with)\b`
+      )
+    ),
+    pkg: true
+  },
+  // formatting as an action (a format, or the formatting of something, is a noun): the lead
+  // takes code to format as its object (a determiner, a file or dir, code, src, changed or staged
+  // files) or names the formatter ("format X with biome"); "format code blocks" is a noun phrase
+  p(
+    "edit_small",
+    new RegExp(
+      String.raw`^\s*format (?=(?:the|this|these|those|all|our|my|it|them|everything|code(?! ?(?:blocks?|snippets?|spans?|fences?)\b)|src|files?|changed|staged|modified)\b|[\w./-]+\.[a-z]{1,4}\b|[\w.-]+\/|(?:[\w./-]+ ){0,3}with ${FORMATTER}\b)`
+    )
+  ),
+  p(
+    "edit_small",
+    new RegExp(
+      String.raw`\b(?:apply|run|fix|check|redo|enforce|use) (?:the |our |a |all )?(?:[\w-]+ )?(?:formatting|formatter)\b|\b${FORMATTER} (?:format|fmt|--write)\b`
+    )
+  ),
+  // ui: showing something in a UI surface builds it ("show me X" is a lookup); so does leaving
+  // something out of what a view, chart or report counts
+  p(
+    "implement",
+    new RegExp(
+      String.raw`\b(?:show|display|render|surface|highlight)(?= (?!me\b|us\b|you\b|how\b|what\b|where\b|which\b|why\b)(?:[\w'.-]+ ){1,8}(?:in|on|inside|within|under|next to|beside) (?:the |a |an |each |every |our |its |their )?(?:[\w-]+ ){0,3}${UI_PLACE}\b)`
+    )
+  ),
+  p(
+    "implement",
+    new RegExp(
+      String.raw`\b(?:exclude|hide|filter out|omit|leave out)(?= (?:[\w'.-]+ ){0,4}(?:from|in|on) (?:the |a |an |each |every |our |its |their )?(?:[\w-]+ ){0,3}(?:${UI_PLACE}|(?:lists?|tables?|totals?|counts?|rates?|metrics?|stats|summary|summaries|results|reports?|exports?))\b)`
+    )
+  ),
+  // plan: the verb, or a plan to produce; never a modifier ("plan lines") or part of a name ("plan-advice")
+  p("plan", /^\s*plan(?=\s)/, 0.9),
+  p(
+    "plan",
+    /\bplan (?:the|a|an|out|how|for|our|this|these|its|it|them|which|what|ahead|and)\b/,
+    0.63
+  ),
+  p(
+    "plan",
+    /\b(?:a|an|(?:make|write|draft|create|prepare|produce|need|propose|outline) (?:the|me a|us a)) (?:[\w-]+ ){0,2}plan\b(?![-./]\w)/,
+    0.63
+  ),
+  p("plan", /\b(?:split|break|divide) (?:\w+ ){0,3}(?:into|down)\b/),
+  p(
+    "plan",
+    /\b(?:into (?:sub)?tasks|assign (?:\w+ )?(?:workers|tasks|agents|owners)|roll ?out|work breakdown)\b/
+  ),
+  // review
+  p("review", /\b(?:security|code|design) (?:review|audit)\b/),
+  p("review", /\breview (?:this|the|my|our) (?:pr|diff|change|patch|branch)\b/),
+  // test
+  p("test", /\b(?:unit|regression|integration|e2e|end-to-end|snapshot) tests?\b/),
+  p("test", /\b(?:test coverage|write (?:a |some )?tests?)\b/),
+  // git: doing git (commit, push, rebase, branch off), not a branch or commits as a subject; a
+  // git subcommand, not git as a noun ("the git root", "git hooks"); a named branch ("switch to
+  // the main branch"), not a control-flow one ("make the error branch return null", "the branch
+  // variable", "a branch of the decision tree", "a branch in the switch")
+  p(
+    "git",
+    /\b(?:commit|push|stash|rebase) (?:these|the|this|my|all|our|it|them|everything|those|your|changes)\b/
+  ),
+  p(
+    "git",
+    /\b(?:git (?:add|am|apply|bisect|branch|checkout|cherry-pick|clean|clone|commit|config|describe|diff|fetch|gc|grep|init|merge|mv|pull|push|rebase|reflog|remote|reset|restore|revert|rm|shortlog|stash|status|submodule|switch|tag)|open a (?:pr|pull request)|cherry-pick\w*|force[- ]push)\b/
+  ),
+  p(
+    "git",
+    /\b(?:create|cut|make|open|start|switch to|check ?out|delete|rename|new) (?:a |the |new |this |that |my )*(?:(?!(?:if|else|error|catch|default|fallback|true|false|happy|dead|case)\b)[\w./-]+ )?branch(?:es)?\b(?! (?:variable|var|logic|condition|statement|coverage|details)\b| (?:of|in|inside|within) (?!(?:the |this |our |my )?(?:git|repo|repository|remote|origin|github|main|master|develop|trunk)\b))|\bbranch (?:off|from|out)\b/
+  ),
+  p(
+    "git",
+    /\b(?:merge|rebase) (?:\S+ )?(?:into|onto)\b|\b(?:merge|rebase) (?:main|master|develop|the branch)\b|\bresolve (?:the |these |all )?(?:merge )?conflicts?\b/
+  ),
+  // debug: symptoms
+  p(
+    "debug",
+    /\b(?:does ?n[o']?t work|not working|is (?:too )?slow|returns? (?:duplicate|wrong|empty|stale)|stack ?trace)\b/
+  ),
+  p("debug", /\bwhy (?:is|are|does|do|doesn't|isn't|would)\b/),
+  // design
+  p("design", /\b(?:design (?:a|an|the)|architecture (?:for|of))\b/),
+  // research
+  p("research", /\b(?:trade-?offs?|alternatives to|pros and cons)\b/),
+  // lookup
+  p("lookup", /\b(?:how does|how do|tell me|what is|what are|where is|where are)\b/, 0.7)
+];
+var STEMS = [
+  p(
+    "lookup",
+    /\b(?:what|where|which|show|list|explain|find|search|summari[sz]e|describe|locate)\b/,
+    0.6
+  ),
+  p("impact", /\b(?:depend\w*|affect\w*|impact\w*)\b/, 0.8),
+  p("history", /\b(?:blame|history|histor\w+)\b/),
+  p("run", /\b(?:run|lint|linter|typecheck)\b/, 0.9),
+  p("docs", /\b(?:docs|documentation)\b/, 0.7),
+  p("recall", /\b(?:decided|decision|convention|agreed)\b/, 0.7),
+  p("plan", /\b(?:split|assign|rollout|roadmap|milestones?|coordinat\w*|orchestrat\w*)\b/, 0.9),
+  p("edit_small", /\b(?:rename\w*|typos?|tidy|reformat\w*|bump\w*|reword|indent\w*)\b/),
+  // Imperative and progressive forms only: "added" or "implementation" describe, not request.
+  p("implement", /\b(?:add|adding|write|writing|create|creating|introduce|build out)\b/, 0.8),
+  // Specific implement verbs name real work on their own (never complexity ≤ 1).
+  p(
+    "implement",
+    /\b(?:implement|implementing|optimi[sz]e|optimi[sz]ing|wire|wiring|convert|converting|extract|extracting|integrate|integrating|plumb|parallel[iy][sz]e|deduplicate)\b/
+  ),
+  p("refactor", /\b(?:refactor\w*|migrat\w*|rewrit\w*|restructur\w*|consolidat\w*|overhaul\w*)\b/),
+  p("design", /\b(?:design\w*|redesign\w*|re-?architect\w*|architect\w*|subsystem)\b/),
+  p("review", /\b(?:review\w*|audit\w*)\b/),
+  p(
+    "debug",
+    /\b(?:why|debug\w*|fail\w*|slow|crash\w*|race|bug\w*|broken|leak\w*|hang\w*|flaky|error\w*|fix|fixing|deadlock\w*|regressed)\b/,
+    0.9
+  ),
+  p("research", /\b(?:compar\w*|research\w*|providers?|evaluat\w*|benchmark\w*)\b/),
+  p("test", /\b(?:tests?|verify|regression|coverage)\b/, 0.8),
+  p("git", /\b(?:rebase|stash)\b/),
+  p(
+    "ui",
+    /\b(?:dashboard|css|component|view|layout|button|frontend|ui|charts?|badges?|tooltips?|modals?|sidebar|widgets?)\b/,
+    0.8
+  )
+];
+var LEAD_ONLY = [
+  p(
+    "implement",
+    /^(?:make|build|port|handle|store|support|expose|persist|track|enable|ensure|allow|teach|cache|upgrade|harden|speed)\b/,
+    0.8
+  ),
+  // Generic change verbs: a small edit by default, but a change (so breadth counts in full).
+  p("edit_small", /^(?:update|change|modify|adjust|tweak)\b/, 0.3),
+  p("design", /^(?:propose|model)\b/, 0.8),
+  p("plan", /^(?:coordinate|orchestrate)\b/),
+  // amend and squash are code verbs too ("amend the docstring"); they mean git only with a commit
+  // as the object, which the commits-object phrase covers.
+  p("git", /^(?:commit|push|merge|rebase|stash)\b/)
+  // fetch/download/crawl/scrape are a docs lead only with a docs object: a phrase (FETCH_OBJECT)
+];
+var NON_LEAD = 0.7;
+var SELECTOR = /\b(?<!\b(?:caus(?:e|es|ed|ing)|reasons?|sources?|origins?) (?:of |for )?)(?:the|every|each|all|any|only|of|no|some|which|those|these|its|their) (fail(?:ed|ing)) (?=[a-z])/g;
+var CHAT = /^(?:hi|hello|hey|yo|thanks|thank you|thx|ty|ok|okay|yes|yep|no|nope|sure|cool|great|nice|perfect|got it|that works|sounds good|lgtm|good|done)\b[\s\w,.!']*$/;
+var POLITE = /^\s*(?:(?:please|pls|can you|could you|would you|let'?s|i want to|i'?d like to|help me|now|ok(?:ay)?|so)[\s,]+)+/;
+var TASK_TITLE = /^\s*(?:t\d+[a-z]?|task\s*#?\d+)\s*[:.)\]-]\s+/i;
+var STRONG_SCOPE = /\b(?:whole|entire|codebase|code base|across|everywhere|throughout|globally|repo-wide|system-wide|project-wide|end-to-end|every (?:module|file|package|service)|(?:all|every|each) (?:the |of the |its |their )?call[- ]?sites?|all (?:the )?\d+|(?:\d{2,}|three|four|five|six|seven|eight|nine|ten|dozens? of|hundreds of) (?:[\w-]+ )?(?:files|modules|packages|services|hooks|handlers|endpoints|call sites|callers|components|tables|commands|tools|routes|repos))\b/g;
+var WEAK_SCOPE = /\b(?:all|every|system|framework|platform|layer|subsystem|pipeline|architecture|monorepo|monolith\w*|call[- ]?sites?)\b/g;
+var ENUM3 = /(?<![\w.-])[.-]*\b[\w.-]+(?: [\w.-]+)?, (?:the )?[\w.-]+(?: [\w.-]+)?,? (?:and|&) (?:the )?[\w.-]+/g;
+var LIST3 = /(?<![\w.-])[.-]*\b[\w.-]+(?: [\w.-]+)?, (?:the |a |an )?[\w.-]+(?: [\w.-]+)?,? (?:and|&|or) (?:the |a |an )?[\w.-]+(?: [\w.-]+)?/g;
+var LIST_SEP = /,? (?:and|&|or) |, /;
+var UI_PART = new RegExp(
+  String.raw`\b(?:${UI_PLACE}|css|components?|buttons?|frontend|links?|inputs?|fields?|columns?|rows?|tables?|lists?|icons?|labels?|titles?|headings?|fonts?|colou?rs?|themes?|styles?|borders?|nav(?:bar)?s?|breadcrumbs?|toasts?|dropdowns?|checkbox(?:es)?|box(?:es)?|bars?|toggles?|sliders?|spinners?|banners?|popovers?|drawers?|avatars?|logos?|images?|grids?|filters?|graphs?|gauges?)\b`
+);
+var OTHER_LAYER = /\b(?:apis?|endpoints?|servers?|back[- ]?end|cli|command[- ]line|(?<!\b(?:custom|preact|react|use\w+) )hooks?|databases?|db|sqlite|sql|mcp|web ?sockets?|logins?|log-in|log ?into|log in (?:to|with|via|using|as)|sign[- ]?(?:in|on)|auth(?:n|z|enticat\w*|ori[sz]\w*)?)\b|(?<!\b(?:local|session) )\bstorage\b|(?:^|\s)--[a-z]/;
+var RISK = /\b(?:secur\w*|vulnerab\w*|race conditions?|races?|migrat\w*|data loss|concurren\w*|production|prod|auth\w*|o?auth2?|oidc|pkce|sso|saml|jwt|csrf|xss|sandbox\w*|privilege\w*|multi-?tenan\w*|deadlock\w*|credentials?|secrets?|permissions?|delet\w* (?:\w+ ){0,2}(?:data|rows?|records?|tables?|users?|accounts?|database|db|buckets?|backups?|director(?:y|ies)|folders?)|drop (?:table|column)|backfill\w*|payments?|encrypt\w*|injection)\b/g;
+var PERF = /\b(?:optimi[sz]\w*|perf\w*|latency|throughput|slow\w*|faster|speed\w*|bundle size|memory|cpu|p9\d|scal(?:e|es|ing)|takes|went up|grew|regress\w*)\b/;
+var MEASURE = /\b\d[\d,.]*\s?(?:ms|µs|us|s|secs?|seconds?|minutes?|mins?|kb|mb|gb|tb|x|%|rps|qps)\b|\b(?:\d{4,}|\d[\d,.]*\s?[km]|\d{1,3}(?:,\d{3})+|a (?:million|billion|thousand))\s?[a-z]*\b/;
+var INVESTIGATE = /\b(?:why|figure out|look into|investigat\w*|root[- ]?caus\w*|track down|get to the bottom of|diagnos\w*|dig into)\b/;
+var EXPLAIN = /\b(?:explain|walk (?:me )?through)\b/;
+var SYSTEM_SUBJECT = /\b(?:cach(?:e|es|ing)|invalidat\w*|builds?|pipelines?|jobs?|queues?|workers?|schedul\w*|cron|checkout|requests?|sessions?|startup|boot\w*|sync(?:ing|hroni[sz]\w*)?|replicat\w*|retr(?:y|ies)|lifecycle|concurren\w*|locking|index(?:ing|er)|ingest\w*|render(?:ing)?|deploy\w*|memory|latency|throughput|services?|server|database|transactions?|event loop|events|consistency|ordering|timeouts?|expiry|routing|middleware|webhooks?|connection pool|rate limit\w*|garbage collect\w*|token refresh)\b/;
+var EMERGENT = /\b(?:twice|duplicat\w*|intermittent\w*|sometimes|randomly|occasionally|doubl(?:e|ed|es|ing)|tripl\w*|spik\w*|keeps? growing|over time|under load|feels? (?:slow|sluggish|laggy))\b/;
+var THREAD = /\b(?:thread|plumb|propagat|pass|carry|forward)(?:s|es|ed|e|ing)? (?:[\w.'-]+ ){1,6}(?:all the way )?through\b/;
+var IMPACT_OF_CHANGE = /\b(?:impact|effect|consequences?|blast radius) of (?:changing|renaming|removing|dropping|moving|splitting|deleting|replacing|reordering|making)\b|\bwhat (?:would|will) happen if (?:we |i )?(?:change|rename|remove|drop|move|split|delete|replace|make)\b/;
+var FETCH = new RegExp(
+  String.raw`https?:\/\/\S+|\b${FETCH_VERB} (?:${FETCH_OBJECT})|\b(?:latest|current|newest) (?:version|release)s?\b|\brelease notes\b|\bchangelog\b`
+);
+var PARALLEL = /\b(?:in parallel|concurrently|at the same time|simultaneously|both at once|side by side|in one go|in a single (?:call|batch|run))\b|\b(?:and|&) (?:[\w.:-]+ ){1,4}(?:all |both )?at once\b/;
+var REFS = /\b(?:what|who|which \w+) (?:else )?(?:calls?|uses?)\b|\b(?:code|callers?|places?) (?:that|which) (?:uses?|calls?|references?)\b|\b(?:callers|usages?|references) of\b/;
+var CHANGE_IMPACT = /\bwhat (?:would|will|could|might) (?:break|change|fail)\b|\bwhat breaks\b|\b(?:blast radius|impact of|affected by)\b/;
+var WRITE_INTENTS = ["implement", "edit_small", "refactor"];
+var PATH_RE = /(?<![\w./-])[\w./-]+\.(?:ts|tsx|js|py|go|rs|md|json|ya?ml|sql|php)\b/g;
+var SYMBOL_RE = /`[^`\n]+`|\b[a-z][a-z0-9]*[A-Z]\w*\b|\b[A-Z][a-z0-9]+[A-Z]\w*\b|\b[a-z0-9]+_[a-z0-9_]+\b/g;
+var STACK_RE = /^[^\S\n\r]*at .+[^\s()]:\d+(?::\d+)?\)?[^\S\n\r]*$|Traceback \(most recent call last\)/m;
+var PASTED_LINE = /^\s*(?:at .+:\d+|File ".+", line \d+|\[?\d{4}-\d\d-\d\d[T ]\d\d:\d\d|\[(?:error|warn(?:ing)?|info|debug|trace|fatal)\]|(?:ERROR|WARN(?:ING)?|INFO|DEBUG|TRACE|FATAL)\b|(?:error|warn(?:ing)?|fatal):|(?:FAIL|PASS|ERR!|×|✗|✓|✔)\s|(?:[A-Z]\w*)?(?:Error|Exception)\b|(?:Expected|Received|AssertionError)\b|npm (?:ERR|WARN)|\$ |> )/;
+var FENCE = /```[\s\S]*?(?:```|$)/g;
+var SCAN_CHARS = 4e3;
+var count = (re, s) => s.match(re)?.length ?? 0;
+var wordCount = (s) => {
+  const t = s.trim();
+  return t ? t.split(/\s+/).length : 0;
+};
+var SHARED_UI_NOUN = new RegExp(String.raw`\b${UI_NOUN}s$`);
+var OWN_ARTICLE = /^(?:the|a|an) /;
+var uiAmongAreas = (s) => {
+  for (const m of s.matchAll(LIST3)) {
+    const items = m[0].split(LIST_SEP);
+    const last = items[items.length - 1] ?? "";
+    if (SHARED_UI_NOUN.test(last) && !items.slice(1).some((x) => OWN_ARTICLE.test(x))) continue;
+    const ui = items.filter((x) => UI_PART.test(x)).length;
+    if (ui > 0 && ui < items.length) return true;
+  }
+  return false;
+};
+function extractIntents(text, libraries) {
+  let s = text.slice(0, SCAN_CHARS).toLowerCase().replace(TASK_TITLE, "").replace(POLITE, "");
+  const out = {};
+  const put = (i, v) => {
+    if (v > (out[i] ?? 0)) out[i] = Math.min(1, v);
+  };
+  const first = /^\s*\S+/.exec(s)?.[0].length ?? 0;
+  for (const l of PHRASES) {
+    const re = new RegExp(l.re.source, "g");
+    s = s.replace(re, (m, name) => {
+      if (l.pkg && typeof name === "string" && !isPackageName(name, libraries)) return m;
+      put(l.intent, l.w);
+      return " ".repeat(m.length);
+    });
+  }
+  const lead = s.slice(0, first).trim() ? /^\s*(\S+)/.exec(s) : null;
+  s = s.replace(SELECTOR, (m, w) => m.replace(w, " ".repeat(w.length)));
+  const leadEnd = lead ? lead[0].length : 0;
+  if (lead?.[1]) {
+    for (const l of LEAD_ONLY) if (l.re.test(lead[1])) put(l.intent, l.w);
+  }
+  for (const l of STEMS) {
+    const re = new RegExp(l.re.source, "g");
+    for (const m of s.matchAll(re)) put(l.intent, (m.index ?? 0) < leadEnd ? l.w : l.w * NON_LEAD);
+  }
+  return out;
+}
+function splitPasted(text) {
+  let pastedLines = 0;
+  const unfenced = text.replace(FENCE, (block) => {
+    for (const line of block.split("\n")) if (PASTED_LINE.test(line)) pastedLines++;
+    return "\n";
+  });
+  const kept = [];
+  for (const line of unfenced.split("\n")) {
+    if (PASTED_LINE.test(line)) pastedLines++;
+    else kept.push(line);
+  }
+  return { prose: kept.join("\n"), pastedLines };
+}
+function extractFeatures(text, hints) {
+  const trimmed = text.trim();
+  const words = wordCount(trimmed);
+  const stackTrace = STACK_RE.test(trimmed);
+  const { prose: prose2, pastedLines } = splitPasted(trimmed.slice(0, SCAN_CHARS));
+  const pasted2 = stackTrace || pastedLines >= 2;
+  const body = prose2.trim() ? prose2 : trimmed.slice(0, SCAN_CHARS);
+  const lower = body.toLowerCase();
+  const intents = extractIntents(body, hints?.libraries);
+  if (pasted2) intents.debug = Math.max(intents.debug ?? 0, 0.8);
+  const chat = words <= 8 && CHAT.test(lower) && Object.keys(intents).length === 0;
+  if (chat) intents.chat = 1;
+  const scope = Math.min(
+    1,
+    count(STRONG_SCOPE, lower) + 0.5 * (count(WEAK_SCOPE, lower) + count(ENUM3, lower))
+  );
+  const risk = Math.min(1, 0.5 * count(RISK, lower));
+  const perf = PERF.test(lower) && MEASURE.test(lower) ? 1 : 0;
+  const prosePaths = count(PATH_RE, body);
+  const named = prosePaths > 0 || count(SYMBOL_RE, body.replace(PATH_RE, " ")) > 0;
+  const systemic = SYSTEM_SUBJECT.test(lower) || EMERGENT.test(lower);
+  const investigate = systemic && (INVESTIGATE.test(lower) || !named && EXPLAIN.test(lower));
+  const crossCutting = THREAD.test(lower) || IMPACT_OF_CHANGE.test(lower);
+  const writes = WRITE_INTENTS.some((i) => (intents[i] ?? 0) > 0);
+  const fetch = FETCH.test(lower.replace(DOC_WRITE, " "));
+  const batch = (intents.run ?? 0) >= 0.9 && (intents.debug ?? 0) < 0.9 && !writes && (PARALLEL.test(lower) || count(ENUM3, lower) > 0);
+  const refs = REFS.test(lower) && !CHANGE_IMPACT.test(lower) && !crossCutting && !writes;
+  const otherLayer = OTHER_LAYER.test(lower) || uiAmongAreas(lower);
+  const classify = classifyPrompt(trimmed.slice(0, SCAN_CHARS)).find(
+    (d) => d.category !== "user_prompt" && d.category !== "intent"
+  )?.category;
+  const f = {
+    words,
+    chars: trimmed.length,
+    lines: trimmed ? trimmed.split("\n").length : 0,
+    paths: count(PATH_RE, trimmed),
+    symbols: count(SYMBOL_RE, trimmed.replace(PATH_RE, " ")),
+    codeBlock: trimmed.includes("```"),
+    stackTrace,
+    intents,
+    scope,
+    risk,
+    chat,
+    slash: trimmed.startsWith("/"),
+    proseWords: Math.min(words, wordCount(prose2)),
+    prosePaths,
+    pasted: pasted2,
+    taskTitle: TASK_TITLE.test(trimmed),
+    perf,
+    investigate,
+    crossCutting,
+    fetch,
+    batch,
+    refs,
+    otherLayer
+  };
+  if (classify) f.classify = classify;
+  if (hints && (hints.role || hints.files !== void 0 || hints.deps !== void 0)) {
+    f.task = { files: hints.files ?? 0, deps: hints.deps ?? 0 };
+    if (hints.role) f.task.role = hints.role;
+  }
+  return f;
+}
+
+// src/adjudicator/heuristic.ts
+var DEFAULT_FEATURE_WEIGHTS = Object.freeze({
+  base: 0.6,
+  chat: -2,
+  edit_small: -0.6,
+  lookup: -0.3,
+  history: -0.3,
+  docs: -0.3,
+  git: -0.3,
+  impact: 0.6,
+  bigfile: 1,
+  recall: 0.6,
+  implement: 1,
+  debug: 1,
+  review: 1.2,
+  plan: 1.4,
+  refactor: 1.6,
+  design: 2.4,
+  research: 0.6,
+  test: 0.6,
+  run: 0,
+  ui: 0,
+  scope: 1.2,
+  risk: 0.8,
+  perf: 0.8,
+  paths: 0.3,
+  words40: 0.3,
+  words120: 0.6,
+  stackTrace: 0.4,
+  taskFiles: 0.4,
+  taskDeps: 0.2,
+  taskFloor: 2,
+  investigateFloor: 2,
+  crossCuttingFloor: 2,
+  toolProvider: 0,
+  asymmetry: 2
+});
+var DEFAULT_TIER_CENTERS = Object.freeze({
+  haiku: 0.6,
+  sonnet: 2,
+  opus: 3.4
+});
+var TAU = 0.5;
+var AGENT_AT = 3.5;
+var DEFAULT_TIERS = ["haiku", "sonnet", "opus"];
+var r2 = (n) => Math.round(n * 100) / 100;
+var clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+function complexityBucket(c) {
+  return clamp(Math.round(c), 0, 4);
+}
+var MAX_EFFORT_AT = 3.75;
+function effortFor(c) {
+  if (c < 1.5) return "low";
+  if (c < 2.5) return "medium";
+  if (c < 3.5) return "high";
+  if (c < MAX_EFFORT_AT) return "xhigh";
+  return "max";
+}
+function topIntent(f) {
+  let best;
+  for (const [i, v] of Object.entries(f.intents))
+    if (v > 0 && (best === void 0 || v > (f.intents[best] ?? 0))) best = i;
+  return best;
+}
+function tierCenter(tier, index, centers) {
+  return centers[tier] ?? 0.6 + 1.4 * index;
+}
+function tableConfidence(entries) {
+  return 0.5 + ((entries[0]?.score ?? 0) - (entries[1]?.score ?? 0)) / 2;
+}
+function makeTable(dimension, options, raw, fallback) {
+  let total = 0;
+  for (const o of options) total += Math.max(0, raw.get(o)?.s ?? 0);
+  const fb = options.includes(fallback) ? fallback : options[0];
+  const entries = options.map((o) => {
+    const e = raw.get(o);
+    const score = total > 0 ? Math.max(0, e?.s ?? 0) / total : o === fb ? 1 : 0;
+    const reasons = e?.reasons ?? [];
+    if (total <= 0 && o === fb)
+      reasons.push({ feature: "fallback", weight: 1, note: `no signal; default ${fb}` });
+    return { option: o, score, reasons };
+  });
+  entries.sort((a, b) => b.score - a.score);
+  return {
+    dimension,
+    entries,
+    choice: entries[0]?.option ?? fallback,
+    confidence: tableConfidence(entries)
+  };
+}
+function add(raw, option, weight, feature, note) {
+  if (!weight) return;
+  const e = raw.get(option) ?? { s: 0, reasons: [] };
+  e.s += weight;
+  e.reasons.push({ feature, weight: r2(weight), note });
+  raw.set(option, e);
+}
+var CHANGES = [
+  "implement",
+  "edit_small",
+  "refactor",
+  "design",
+  "plan",
+  "review",
+  "debug",
+  "test",
+  "ui"
+];
+var READ_SCOPE = 0.5;
+var WORK = [
+  "implement",
+  "edit_small",
+  "refactor",
+  "design",
+  "plan",
+  "review",
+  "debug",
+  "ui"
+];
+var BROAD = ["design", "plan", "refactor", "implement"];
+function scoreComplexity(f, w) {
+  const reasons = [];
+  let c = 0;
+  const term = (feature, weight, note) => {
+    if (!weight) return;
+    c += weight;
+    reasons.push({ feature, weight: r2(weight), note });
+  };
+  const has = (i) => (f.intents[i] ?? 0) > 0;
+  const readOnly = !WORK.some(has) && (f.intents.test ?? 0) < 0.8;
+  term("base", w.base ?? 0, "base");
+  for (const [i, v] of Object.entries(f.intents)) {
+    if (!(v > 0)) continue;
+    if (readOnly && i === "test") continue;
+    term(`intent.${i}`, (w[i] ?? 0) * v, `${i} ${r2(v)} \xD7 ${w[i] ?? 0}`);
+  }
+  if (f.scope > 0) {
+    const changes = CHANGES.some((i) => (f.intents[i] ?? 0) > 0);
+    term(
+      "scope",
+      (w.scope ?? 0) * f.scope * (changes ? 1 : READ_SCOPE),
+      `scope ${r2(f.scope)}${changes ? "" : " (read only, halved)"}`
+    );
+  }
+  if (f.risk > 0) term("risk", (w.risk ?? 0) * f.risk, `risk ${r2(f.risk)}`);
+  if (f.perf) term("perf", (w.perf ?? 0) * f.perf, "performance work with a measured number");
+  const paths2 = f.prosePaths ?? f.paths;
+  if (paths2 > 0 && !readOnly)
+    term("paths", (w.paths ?? 0) * Math.log2(1 + paths2), `${paths2} path(s) named`);
+  const words = f.proseWords ?? f.words;
+  const report = has("debug") && !BROAD.some(has);
+  if (words > 120 && !report) term("words120", w.words120 ?? 0, `${words} words`);
+  else if (words > 40) term("words40", w.words40 ?? 0, `${words} words`);
+  if (f.stackTrace) term("stackTrace", w.stackTrace ?? 0, "stack trace");
+  if (f.task && f.task.files > 3)
+    term("taskFiles", w.taskFiles ?? 0, `task touches ${f.task.files} files`);
+  if (f.task && f.task.deps > 1) term("taskDeps", w.taskDeps ?? 0, `${f.task.deps} deps`);
+  const invFloor = w.investigateFloor ?? 0;
+  if (f.investigate && c < invFloor)
+    term("investigate", invFloor - c, `investigates system behaviour: floor ${invFloor}`);
+  const ccFloor = w.crossCuttingFloor ?? 0;
+  if (f.crossCutting && c < ccFloor)
+    term("crossCutting", ccFloor - c, `cross-cutting change: floor ${ccFloor}`);
+  const floor = w.taskFloor ?? 0;
+  if (f.taskTitle && c < floor) term("taskFloor", floor - c, `swarm task title: floor ${floor}`);
+  return { complexity: clamp(c, 0, 4), reasons };
+}
+function scoreTier(c, f, ladder, centers, asymmetry = 1) {
+  const a = Math.max(1, Number.isFinite(asymmetry) ? asymmetry : 1);
+  const sonnetAt = ladder.indexOf("sonnet");
+  const riskFrom = sonnetAt >= 0 ? sonnetAt : 1;
+  const logits = ladder.map((t, i) => {
+    const center = tierCenter(t, i, centers);
+    const under = c > center;
+    let s = -(under ? a : 1) * Math.abs(c - center);
+    const reasons = [
+      {
+        feature: "complexity",
+        weight: r2(s),
+        note: `c ${r2(c)} vs centre ${center}${under && a !== 1 ? ` (under-tier \xD7${r2(a)})` : ""}`
+      }
+    ];
+    if (f.risk > 0 && i >= riskFrom) {
+      s += 0.4 * f.risk;
+      reasons.push({ feature: "risk", weight: r2(0.4 * f.risk), note: `risk ${r2(f.risk)}` });
+    }
+    if (f.chat && i === 0) {
+      s += 1;
+      reasons.push({ feature: "chat", weight: 1, note: "chat" });
+    }
+    return { t, s, reasons };
+  });
+  const max = Math.max(...logits.map((l) => l.s));
+  const raw = /* @__PURE__ */ new Map();
+  for (const l of logits) raw.set(l.t, { s: Math.exp((l.s - max) / TAU), reasons: l.reasons });
+  return makeTable("tier", ladder, raw, ladder[0] ?? "haiku");
+}
+var WRITES = ["implement", "edit_small", "refactor"];
+function scoreTool(f, c, tools) {
+  const raw = /* @__PURE__ */ new Map();
+  const i = f.intents;
+  const rule = (intent, tool, w, extra = "") => {
+    const v = i[intent] ?? 0;
+    if (v > 0) add(raw, tool, w * v, `intent.${intent}`, `${intent} \u2192 ${tool}${extra}`);
+  };
+  const lookup = Math.max(0, (i.lookup ?? 0) - Math.max(i.docs ?? 0, i.history ?? 0));
+  if (lookup > 0) {
+    add(raw, "em_symbols", 0.6 * lookup, "intent.lookup", "lookup \u2192 em_symbols");
+    add(raw, "em_search", 0.4 * lookup, "intent.lookup", "lookup \u2192 em_search");
+  }
+  rule("impact", f.refs ? "em_symbols" : "em_graph_impact", 1, f.refs ? " (callers/usages)" : "");
+  rule("history", "em_history", 1);
+  const run = f.batch ? "em_batch_execute" : "em_execute";
+  rule("run", run, 1);
+  if (WRITES.some((w) => (i[w] ?? 0) > 0)) rule("test", "Edit", 1, " (write tests)");
+  else rule("test", run, 1);
+  rule("bigfile", "em_execute_file", 1);
+  rule("docs", f.fetch ? "em_fetch_and_index" : "em_docs", 0.6);
+  rule("docs", f.fetch ? "em_docs" : "em_fetch_and_index", 0.4);
+  rule("research", "em_fetch_and_index", 0.6);
+  rule("research", "em_search", 0.3);
+  rule("recall", "em_recall", 1);
+  rule("plan", "em_swarm", 1);
+  rule("edit_small", "Edit", 1);
+  rule("implement", "Edit", 1);
+  rule("git", "Bash", 1);
+  rule("debug", "em_execute", 0.6, " (reproduce)");
+  rule("debug", "em_search", 0.3);
+  rule("chat", "none", 1);
+  if (c >= AGENT_AT) {
+    rule("design", "Agent", 1.5, ` (c \u2265 ${AGENT_AT})`);
+    rule("refactor", "Agent", 1.5, ` (c \u2265 ${AGENT_AT})`);
+    rule("review", "Agent", 1, ` (c \u2265 ${AGENT_AT})`);
+  } else {
+    rule("design", "em_recall", 0.5, " (check past decisions)");
+    rule("refactor", "Edit", 0.8);
+    rule("review", "Agent", 0.6);
+    rule("review", "em_search", 0.3);
+  }
+  if (f.symbols > 0 || f.paths > 0) {
+    const v = Math.min(1, (f.symbols + f.paths) / 2);
+    add(raw, "em_symbols", 0.2 * v, "symbols", "symbols or paths named");
+    add(raw, "em_graph_impact", 0.1 * v, "symbols", "symbols or paths named");
+  }
+  const options = TOOL_IDS.filter((t) => tools.includes(t));
+  return makeTable("tool", options, raw, f.chat ? "none" : "em_search");
+}
+var ROLE_MAP = {
+  lookup: { explorer: 1 },
+  impact: { explorer: 1 },
+  bigfile: { explorer: 1 },
+  history: { explorer: 0.5, researcher: 0.5 },
+  docs: { researcher: 1 },
+  research: { researcher: 1 },
+  recall: { reviewer: 0.6, architect: 0.4 },
+  implement: { coder: 1 },
+  edit_small: { coder: 1 },
+  refactor: { coder: 1 },
+  debug: { coder: 1 },
+  git: { coder: 1 },
+  test: { tester: 1.2 },
+  run: { tester: 1 },
+  review: { reviewer: 1.2 },
+  design: { architect: 1.2 },
+  plan: { architect: 1.2 },
+  ui: { ui: 0.8 },
+  chat: { none: 1 }
+};
+var profiles = /* @__PURE__ */ new Map();
+function profile(name, description) {
+  const k = `${name}
+${description}`;
+  let p2 = profiles.get(k);
+  if (!p2) {
+    p2 = extractIntents(`${name} ${description}`);
+    if (profiles.size > 256) profiles.clear();
+    profiles.set(k, p2);
+  }
+  return p2;
+}
+function scoreRole(f, catalogue, c = 0) {
+  const raw = /* @__PURE__ */ new Map();
+  const options = catalogue?.length ? catalogue.map((r) => r.name) : [...DEFAULT_ROLES];
+  const known = new Set(options);
+  const bounded2 = !(f.intents.refactor ?? 0) && f.scope < 1;
+  const crossLayer = bounded2 && (f.risk > 0 || f.otherLayer === true);
+  const uiWork = known.has("ui") && (f.intents.ui ?? 0) > 0 && bounded2 && !crossLayer;
+  for (const [intent, v] of Object.entries(f.intents)) {
+    if (!(v > 0)) continue;
+    const edit = intent === "implement" || intent === "edit_small";
+    for (const [r, w] of Object.entries(ROLE_MAP[intent] ?? {})) {
+      const role = uiWork && edit && r === "coder" ? "ui" : crossLayer && r === "ui" && known.has("coder") ? "coder" : r;
+      if (known.has(role)) add(raw, role, w * v, `intent.${intent}`, `${intent} \u2192 ${role}`);
+    }
+  }
+  for (const r of catalogue ?? []) {
+    if (!r.description) continue;
+    const prof = profile(r.name, r.description);
+    let overlap = 0;
+    for (const [intent, v] of Object.entries(f.intents))
+      overlap += v * (prof[intent] ?? 0);
+    if (overlap > 0) add(raw, r.name, 0.5 * overlap, "description", "matches the role description");
+  }
+  const refactor = f.intents.refactor ?? 0;
+  if (c >= AGENT_AT && refactor > 0 && known.has("architect"))
+    add(
+      raw,
+      "architect",
+      1.2 * refactor,
+      "intent.refactor",
+      `large refactor (c \u2265 ${AGENT_AT}) \u2192 architect`
+    );
+  if (f.task?.role && known.has(f.task.role))
+    add(raw, f.task.role, 1, "task.role", "role assigned by the plan");
+  const fallback = f.chat || Object.keys(f.intents).length === 0 ? "none" : "explorer";
+  return makeTable("role", options, raw, known.has(fallback) ? fallback : options[0] ?? "none");
+}
+function scoreHeuristic(f, weights = {}, catalogue = {}) {
+  const w = { ...DEFAULT_FEATURE_WEIGHTS, ...weights.features ?? {} };
+  const centers = { ...DEFAULT_TIER_CENTERS, ...weights.tierCenters ?? {} };
+  const ladder = (catalogue.tiers?.length ? catalogue.tiers : DEFAULT_TIERS).filter(
+    (t) => TIERS.includes(t)
+  );
+  const { complexity, reasons } = scoreComplexity(f, w);
+  return {
+    complexity,
+    complexityReasons: reasons,
+    tool: scoreTool(f, complexity, catalogue.tools ?? TOOL_IDS),
+    tier: scoreTier(complexity, f, ladder, centers, w.asymmetry),
+    role: scoreRole(f, catalogue.roles, complexity),
+    effort: effortFor(complexity)
+  };
+}
+
+// src/adjudicator/blend.ts
+var BLEND_DEFAULTS = Object.freeze({
+  providerMax: 0.7,
+  embeddingMax: 0.4,
+  selfReportScale: 0.6,
+  lowConfidence: 0.55
+});
+var NOUL_BOOST = 0.3;
+var NOUL_AT = 0.7;
+var r22 = (n) => Math.round(n * 100) / 100;
+var clamp01 = (n) => Math.min(1, Math.max(0, n));
+function providerAlpha(provider, answer, weights = {}) {
+  if (!answer || provider === "heuristic") return {};
+  const w = { ...BLEND_DEFAULTS, ...weights };
+  const embedding = provider === "embedding";
+  const cap2 = clamp01(embedding ? w.embeddingMax : w.providerMax);
+  const scale = clamp01(w.selfReportScale);
+  const conf = (d) => clamp01(d.calibrated ? d.confidence : d.confidence * scale);
+  const out = {};
+  if (answer.complexity) {
+    const calibrated = answer.tier?.calibrated ?? provider === "typesafe";
+    const c = clamp01(answer.complexity.confidence * (calibrated ? 1 : scale));
+    out.complexity = Math.min(cap2, c);
+  }
+  if (answer.tier) out.tier = Math.min(cap2, conf(answer.tier));
+  if (!embedding) {
+    if (answer.role) out.role = Math.min(cap2, conf(answer.role));
+    const toolProvider = clamp01(w.features?.toolProvider ?? 0);
+    if (answer.tool && toolProvider > 0) out.tool = Math.min(cap2, toolProvider, conf(answer.tool));
+  }
+  return out;
+}
+function mixTable(h, dist, alpha, provider, adds, bias) {
+  const options = h.entries.map((e) => e.option);
+  let pSum = 0;
+  if (dist && alpha > 0) for (const o of options) pSum += Math.max(0, dist.probs[o] ?? 0);
+  const a = pSum > 0 ? alpha : 0;
+  const rows = h.entries.map((e) => {
+    const reasons = [...e.reasons];
+    const p2 = a > 0 && dist ? Math.max(0, dist.probs[e.option] ?? 0) / pSum : 0;
+    let s = (1 - a) * e.score + a * p2;
+    if (a > 0 && p2 > 0)
+      reasons.push({
+        feature: "provider",
+        weight: r22(a * p2),
+        note: `${provider} p ${r22(p2)} \xD7 \u03B1 ${r22(a)}`
+      });
+    for (const add2 of adds)
+      if (add2.option === e.option) {
+        s += add2.weight;
+        reasons.push(add2.reason);
+      }
+    const b = bias[`${h.dimension}:${e.option}`] ?? 0;
+    if (b) {
+      s += b;
+      reasons.push({ feature: "bias", weight: r22(b), note: "learned from outcomes" });
+    }
+    return { option: e.option, s: Math.max(0, s), reasons };
+  });
+  const total = rows.reduce((n, r) => n + r.s, 0);
+  if (!(total > 0)) return { table: h, alpha: a };
+  const entries = rows.map((r) => ({ option: r.option, score: r.s / total, reasons: r.reasons })).sort((x, y) => y.score - x.score);
+  return {
+    table: {
+      dimension: h.dimension,
+      entries,
+      choice: entries[0]?.option ?? h.choice,
+      confidence: tableConfidence(entries)
+    },
+    alpha: a
+  };
+}
+function ladderOf(table, tiers) {
+  const present = new Set(table.entries.map((e) => e.option));
+  const base = tiers?.length ? tiers : TIERS;
+  const ladder = base.filter((t) => present.has(t));
+  return ladder.length ? ladder : [...DEFAULT_TIERS];
+}
+function blend(h, answer, bias = {}, weights = {}, opts = { key: "", provider: "heuristic" }) {
+  const w = { ...BLEND_DEFAULTS, ...weights };
+  const alpha = providerAlpha(opts.provider, answer, weights);
+  const tierLadder = ladderOf(h.tier, opts.tiers);
+  const sonnetAt = tierLadder.indexOf("sonnet");
+  const riskFrom = sonnetAt >= 0 ? sonnetAt : 1;
+  let complexity = h.complexity;
+  const complexityReasons = [...h.complexityReasons];
+  const ac = alpha.complexity ?? 0;
+  if (answer?.complexity && ac > 0) {
+    const cp = Math.min(4, Math.max(0, answer.complexity.value));
+    complexity = (1 - ac) * h.complexity + ac * cp;
+    complexityReasons.push({
+      feature: "provider",
+      weight: r22(complexity - h.complexity),
+      note: `${opts.provider} says ${r22(cp)} (\u03B1 ${r22(ac)})`
+    });
+  }
+  const tierAdds = [];
+  const toolAdds = [];
+  const roleAdds = [];
+  if ((answer?.risky ?? 0) > NOUL_AT)
+    for (const t of tierLadder.slice(riskFrom))
+      tierAdds.push({
+        option: t,
+        weight: NOUL_BOOST,
+        reason: {
+          feature: "risky",
+          weight: NOUL_BOOST,
+          note: `${opts.provider}: risky ${r22(answer?.risky ?? 0)}`
+        }
+      });
+  if ((answer?.needsPlan ?? 0) > NOUL_AT) {
+    const reason = (o) => ({
+      option: o,
+      weight: NOUL_BOOST,
+      reason: {
+        feature: "needsPlan",
+        weight: NOUL_BOOST,
+        note: `${opts.provider}: needs a plan ${r22(answer?.needsPlan ?? 0)}`
+      }
+    });
+    toolAdds.push(reason("em_swarm"));
+    roleAdds.push(reason("architect"));
+  }
+  const tier = mixTable(h.tier, answer?.tier, alpha.tier ?? 0, opts.provider, tierAdds, bias);
+  const role = mixTable(h.role, answer?.role, alpha.role ?? 0, opts.provider, roleAdds, bias);
+  const tool = mixTable(h.tool, answer?.tool, alpha.tool ?? 0, opts.provider, toolAdds, bias);
+  let tierTable = tier.table;
+  if (tierTable.confidence < w.lowConfidence) {
+    const at = tierLadder.indexOf(tierTable.choice);
+    const up = at >= 0 && at < tierLadder.length - 1 ? tierLadder[at + 1] : void 0;
+    if (up) {
+      tierTable = {
+        ...tierTable,
+        choice: up,
+        entries: tierTable.entries.map(
+          (e) => e.option === up ? {
+            ...e,
+            reasons: [
+              ...e.reasons,
+              {
+                feature: "lowConfidence",
+                weight: r22(w.lowConfidence - tierTable.confidence),
+                note: "low confidence \u2192 rounded up"
+              }
+            ]
+          } : e
+        )
+      };
+    }
+  }
+  const effective = {};
+  if (ac > 0 && answer?.complexity) effective.complexity = r22(ac);
+  if (tier.alpha > 0) effective.tier = r22(tier.alpha);
+  if (role.alpha > 0) effective.role = r22(role.alpha);
+  if (tool.alpha > 0) effective.tool = r22(tool.alpha);
+  const v = {
+    key: opts.key,
+    complexity,
+    complexityReasons,
+    tool: tool.table,
+    tier: tierTable,
+    role: role.table,
+    effort: effortFor(complexity),
+    source: opts.source ?? (answer && opts.provider !== "heuristic" ? "blend" : "heuristic"),
+    provider: opts.provider,
+    providerStatus: opts.providerStatus ?? (answer ? "ok" : "n/a"),
+    alpha: effective,
+    bias,
+    latencyMs: opts.latencyMs ?? 0,
+    version: SCORER_VERSION
+  };
+  if (opts.providerLatencyMs !== void 0) v.providerLatencyMs = opts.providerLatencyMs;
+  if (opts.usage) v.usage = opts.usage;
+  return v;
+}
+
+// src/adjudicator/breaker.ts
+init_esm_shims();
+import { createHash } from "crypto";
+var SLOW_MIN_SAMPLES = 20;
+var AUTH_LOCKOUT_MS = 36e5;
+function utcDay(now) {
+  return new Date(now).toISOString().slice(0, 10);
+}
+function p95(values) {
+  if (!values.length) return void 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.min(sorted.length - 1, Math.ceil(0.95 * sorted.length) - 1)];
+}
+function spendToday(s, now) {
+  if (!s || s.spendDay !== utcDay(now)) return 0;
+  return s.spendUsd;
+}
+function callsToday(s, now) {
+  if (!s || s.spendDay !== utcDay(now)) return 0;
+  return s.calls ?? 0;
+}
+function keyFingerprint(key) {
+  return createHash("sha256").update(key).digest("hex").slice(0, 12);
+}
+function isAuthFailure(kind, status) {
+  return kind === "http_error" && (status === 401 || status === 403);
+}
+function authLockout(s, now, currentFingerprint) {
+  if (s?.state !== "auth_failed") return void 0;
+  const keyChanged = currentFingerprint !== void 0 && (currentFingerprint ?? null) !== s.authFingerprint;
+  const expired = s.retryAt === null || now >= s.retryAt;
+  return {
+    locked: !keyChanged && !expired,
+    until: s.retryAt,
+    fingerprint: s.authFingerprint,
+    keyChanged,
+    errorClass: s.lastErrorClass
+  };
+}
+var unrecordedByStore = /* @__PURE__ */ new WeakMap();
+function unrecorded(store, provider, now) {
+  const day = utcDay(now);
+  const u = unrecordedByStore.get(store)?.get(provider);
+  return u && u.day === day ? { ...u } : { day, calls: 0, spendUsd: 0 };
+}
+function carry(store, provider, now, calls, spendUsd) {
+  if (!calls && !spendUsd) return;
+  const u = unrecorded(store, provider, now);
+  let m = unrecordedByStore.get(store);
+  if (!m) {
+    m = /* @__PURE__ */ new Map();
+    unrecordedByStore.set(store, m);
+  }
+  m.set(provider, { day: u.day, calls: u.calls + calls, spendUsd: u.spendUsd + spendUsd });
+}
+function settle(store, provider) {
+  unrecordedByStore.get(store)?.delete(provider);
+}
+function withUnrecorded(s, u, now) {
+  if (!u.calls && !u.spendUsd) return s;
+  const base = s ?? {
+    provider: "",
+    state: "closed",
+    failures: 0,
+    retryAt: null,
+    lastOkAt: null,
+    lastErrorAt: null,
+    lastErrorClass: null,
+    latencies: [],
+    spendDay: null,
+    spendUsd: 0,
+    calls: 0,
+    authFingerprint: null
+  };
+  return {
+    ...base,
+    spendDay: u.day,
+    spendUsd: spendToday(s, now) + u.spendUsd,
+    calls: callsToday(s, now) + u.calls
+  };
+}
+function gate(store, provider, cfg, o) {
+  const u = unrecorded(store, provider, o.now);
+  const s = store.providerState(provider);
+  const read = planGate(withUnrecorded(s, u, o.now), cfg, o);
+  if (read !== "write") return read.allow ? { ...read, state: s } : read;
+  return atomically(store, () => gateTx(store, provider, cfg, o, u), o.lockWaitMs);
+}
+function planGate(s, cfg, o) {
+  const over = o.remote && overBudget(s, cfg, o.now);
+  const future = s?.retryAt !== null && s?.retryAt !== void 0 && o.now < s.retryAt;
+  if (s?.state === "auth_failed") {
+    if (authLockout(s, o.now, o.keyFingerprint)?.locked)
+      return { allow: false, status: "auth_failed" };
+  } else if (s?.state === "open" || s?.state === "half_open") {
+    if (future) return { allow: false, status: "breaker_open" };
+  } else if (s?.state === "slow") {
+    if (future) return { allow: false, status: "slow_guard" };
+  } else {
+    return over ? { allow: false, status: "over_budget" } : { allow: true, halfOpen: false, state: s };
+  }
+  return over ? { allow: false, status: "over_budget" } : "write";
+}
+function gateTx(store, provider, cfg, o, u) {
+  let s = store.providerState(provider);
+  const cooldownMs = cfg.breaker.cooldownSec * 1e3;
+  let halfOpen = false;
+  if (s?.state === "auth_failed") {
+    const lock = authLockout(s, o.now, o.keyFingerprint);
+    if (lock?.locked) return { allow: false, status: "auth_failed" };
+    s = store.saveProviderState(provider, {
+      state: "closed",
+      retryAt: null,
+      authFingerprint: null
+    });
+  }
+  if (s?.state === "open" || s?.state === "half_open") {
+    if (s.retryAt !== null && o.now < s.retryAt) return { allow: false, status: "breaker_open" };
+    s = store.saveProviderState(provider, { state: "half_open", retryAt: o.now + cooldownMs });
+    halfOpen = true;
+  } else if (s?.state === "slow") {
+    if (s.retryAt !== null && o.now < s.retryAt) return { allow: false, status: "slow_guard" };
+    s = store.saveProviderState(provider, {
+      state: "closed",
+      retryAt: null,
+      latencies: [],
+      latencyBudgets: []
+    });
+  }
+  if (o.remote && overBudget(withUnrecorded(s, u, o.now), cfg, o.now)) {
+    if (halfOpen) store.saveProviderState(provider, { state: "open", retryAt: o.now });
+    return { allow: false, status: "over_budget" };
+  }
+  return { allow: true, halfOpen, state: s };
+}
+function overBudget(s, cfg, now) {
+  if (spendToday(s, now) >= cfg.budget.dailyUsd) return true;
+  const cap2 = cfg.budget.dailyCalls;
+  return typeof cap2 === "number" && cap2 > 0 && callsToday(s, now) >= cap2;
+}
+function recordSuccess(store, provider, cfg, o) {
+  const u = unrecorded(store, provider, o.now);
+  return recorded(
+    store,
+    provider,
+    o.now,
+    1,
+    o.costUsd ?? 0,
+    () => atomically(
+      store,
+      () => {
+        const s = store.providerState(provider);
+        const day = utcDay(o.now);
+        const spent = spendToday(s, o.now) + u.spendUsd + (o.costUsd ?? 0);
+        const ring = o.sample === false ? ringOf(s) : addSample(s, o.latencyMs, o.budgetMs);
+        const slow = isSlow(ring);
+        return store.saveProviderState(provider, {
+          state: slow ? "slow" : "closed",
+          failures: 0,
+          retryAt: slow ? o.now + cfg.breaker.cooldownSec * 1e3 : null,
+          lastOkAt: o.now,
+          ...ring,
+          spendDay: day,
+          spendUsd: spent,
+          calls: callsToday(s, o.now) + u.calls + 1,
+          authFingerprint: null
+        });
+      },
+      o.lockWaitMs
+    )
+  );
+}
+function recorded(store, provider, now, calls, spendUsd, fn) {
+  let out;
+  try {
+    out = fn();
+  } catch (err) {
+    carry(store, provider, now, calls, spendUsd);
+    throw err;
+  }
+  settle(store, provider);
+  return out;
+}
+function countsAsFailure(kind, status) {
+  if (kind === "timeout" || kind === "rate_limited") return true;
+  if (kind === "http_error") return status === void 0 || status >= 500;
+  return false;
+}
+function recordFailure(store, provider, cfg, o) {
+  const u = unrecorded(store, provider, o.now);
+  const calls = o.kind === "no_key" ? 0 : 1;
+  return recorded(
+    store,
+    provider,
+    o.now,
+    calls,
+    0,
+    () => atomically(store, () => recordFailureTx(store, provider, cfg, o, u), o.lockWaitMs)
+  );
+}
+function recordFailureTx(store, provider, cfg, o, u) {
+  const s = store.providerState(provider);
+  const cooldownMs = cfg.breaker.cooldownSec * 1e3;
+  const errorClass = o.status !== void 0 ? `${o.kind}:${o.status}` : o.kind;
+  const day = { spendDay: utcDay(o.now), spendUsd: spendToday(s, o.now) + u.spendUsd };
+  const calls = callsToday(s, o.now) + u.calls + (o.kind === "no_key" ? 0 : 1);
+  if (isAuthFailure(o.kind, o.status)) {
+    return store.saveProviderState(provider, {
+      state: "auth_failed",
+      retryAt: o.now + AUTH_LOCKOUT_MS,
+      authFingerprint: o.keyFingerprint ?? null,
+      lastErrorAt: o.now,
+      lastErrorClass: errorClass,
+      ...day,
+      calls
+    });
+  }
+  const counts = countsAsFailure(o.kind, o.status);
+  const failures = counts ? (s?.failures ?? 0) + 1 : s?.failures ?? 0;
+  const ring = o.kind === "timeout" && o.sample !== false ? addSample(s, timeoutLatency(o.latencyMs, o.budgetMs), o.budgetMs) : ringOf(s);
+  let state;
+  let retryAt;
+  if (counts && (o.halfOpen || failures >= cfg.breaker.failures)) {
+    state = "open";
+    retryAt = o.now + cooldownMs;
+  } else if (o.halfOpen) {
+    state = "closed";
+    retryAt = null;
+  } else if (isSlow(ring)) {
+    state = "slow";
+    retryAt = o.now + cooldownMs;
+  } else {
+    state = s?.state === "slow" ? "closed" : s?.state ?? "closed";
+    retryAt = s?.retryAt ?? null;
+  }
+  return store.saveProviderState(provider, {
+    state,
+    failures,
+    retryAt,
+    lastErrorAt: o.now,
+    lastErrorClass: errorClass,
+    ...ring,
+    ...day,
+    calls
+  });
+}
+function timeoutLatency(latencyMs, budgetMs) {
+  return Math.max(Math.round(latencyMs ?? 0), Math.round(budgetMs) + 1);
+}
+function atomically(store, fn, lockWaitMs) {
+  if (store.atomically) return store.atomically(fn, { lockWaitMs });
+  return lockWaitMs !== void 0 && store.withLockWait ? store.withLockWait(lockWaitMs, fn) : fn();
+}
+function ringOf(s) {
+  const latencies = [...s?.latencies ?? []];
+  const all = s?.latencyBudgets ?? [];
+  const known = all.slice(Math.max(0, all.length - latencies.length));
+  const pad = Math.max(0, latencies.length - known.length);
+  return { latencies, latencyBudgets: [...new Array(pad).fill(0), ...known] };
+}
+function addSample(s, latencyMs, budgetMs) {
+  const r = ringOf(s);
+  r.latencies.push(Math.max(0, Math.round(latencyMs)));
+  r.latencyBudgets.push(Math.max(0, Math.round(budgetMs)));
+  return r;
+}
+function isSlow(ring) {
+  const ratios = [];
+  const from = Math.max(0, ring.latencies.length - 50);
+  for (let i = from; i < ring.latencies.length; i++) {
+    const budget = ring.latencyBudgets[i] ?? 0;
+    const latency = ring.latencies[i];
+    if (budget > 0 && latency !== void 0) ratios.push(latency / budget);
+  }
+  if (ratios.length < SLOW_MIN_SAMPLES) return false;
+  const p2 = p95(ratios);
+  return p2 !== void 0 && p2 > 1;
+}
+
+// src/adjudicator/config.ts
+init_esm_shims();
+
+// src/adjudicator/secrets.ts
+init_esm_shims();
+import { randomBytes } from "crypto";
+import { mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { dirname } from "path";
+var GENERIC_KEY_ENV = "EMINIAR_ADJUDICATOR_KEY";
+var cached;
+var checksMode = () => process.platform !== "win32";
+function keyFileStatus() {
+  const path = paths().adjudicatorKey;
+  try {
+    const mode = statSync(path).mode & 511;
+    return { path, exists: true, mode, secure: !checksMode() || (mode & 63) === 0 };
+  } catch {
+    return { path, exists: false, secure: true };
+  }
+}
+function parseKeys(text) {
+  try {
+    const raw = JSON.parse(text);
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {};
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) if (typeof v === "string" && v) out[k] = v;
+    return out;
+  } catch {
+    return {};
+  }
+}
+function load() {
+  if (cached) return cached;
+  const st = keyFileStatus();
+  if (!st.exists) cached = { keys: {}, refused: false };
+  else if (!st.secure) cached = { keys: {}, refused: true };
+  else {
+    try {
+      cached = { keys: parseKeys(readFileSync(st.path, "utf8")), refused: false };
+    } catch {
+      cached = { keys: {}, refused: false };
+    }
+  }
+  return cached;
+}
+function resolveKey(id, opts = {}) {
+  const env = opts.env ?? process.env;
+  const names = opts.fileOnly ? [] : [opts.keyEnv, opts.providerEnv, GENERIC_KEY_ENV];
+  for (const name of names) {
+    const v = name ? env[name]?.trim() : void 0;
+    if (name && v) return { key: v, source: "env", envName: name };
+  }
+  const file = load();
+  const key = file.keys[id];
+  if (key) return { key, source: "file" };
+  return file.refused ? { source: "none", refused: "permissions" } : { source: "none" };
+}
+function mask(key) {
+  if (!key) return "none";
+  return key.length >= 12 ? `****${key.slice(-4)}` : "****";
+}
+
+// src/adjudicator/config.ts
+var PRESETS = {
+  groq: {
+    id: "groq",
+    baseUrl: "https://api.groq.com/openai/v1",
+    model: "openai/gpt-oss-20b",
+    keyEnv: "GROQ_API_KEY",
+    price: { inPerM: 0.075, outPerM: 0.3 },
+    local: false
+  },
+  cerebras: {
+    id: "cerebras",
+    baseUrl: "https://api.cerebras.ai/v1",
+    model: "gpt-oss-120b",
+    keyEnv: "CEREBRAS_API_KEY",
+    price: null,
+    local: false
+  },
+  ollama: {
+    id: "ollama",
+    baseUrl: "http://localhost:11434/v1",
+    model: "qwen2.5:1.5b-instruct",
+    price: { inPerM: 0, outPerM: 0 },
+    local: true,
+    extra: { keep_alive: "30m", options: { temperature: 0, num_predict: 256 } }
+  },
+  lmstudio: {
+    id: "lmstudio",
+    baseUrl: "http://localhost:1234/v1",
+    price: { inPerM: 0, outPerM: 0 },
+    local: true
+  },
+  llamacpp: {
+    id: "llamacpp",
+    baseUrl: "http://localhost:8080/v1",
+    price: { inPerM: 0, outPerM: 0 },
+    local: true
+  },
+  custom: { id: "custom", price: null, local: false }
+};
+var TYPESAFE_KEY_ENV = "TYPESAFE_API_KEY";
+var TYPESAFE_BASE_URL = "https://api.typesafe.ai/v1";
+function originOf(url) {
+  if (!url) return void 0;
+  try {
+    const u = new URL(url);
+    if (u.protocol !== "https:" && u.protocol !== "http:") return void 0;
+    return u.origin;
+  } catch {
+    return void 0;
+  }
+}
+var BUILTIN_REMOTE_ORIGINS = [
+  ...Object.values(PRESETS).filter((p2) => !p2.local && p2.baseUrl).map((p2) => originOf(p2.baseUrl)),
+  originOf(TYPESAFE_BASE_URL)
+];
+function consentFor(a, origin, env = process.env) {
+  if (!origin || env.EMINIAR_ADJUDICATOR_REMOTE === "0" || !a.remoteConsent) return void 0;
+  if (consentedOrigins(a).includes(origin)) return "config";
+  if (a.remoteConsentOrigins !== void 0 || !BUILTIN_REMOTE_ORIGINS.includes(origin))
+    return void 0;
+  return env.EMINIAR_ADJUDICATOR_PROVIDER ? void 0 : "legacy";
+}
+function consentedOrigins(a) {
+  const out = [];
+  for (const s of a.remoteConsentOrigins ?? []) {
+    const o = originOf(s);
+    if (o && !out.includes(o)) out.push(o);
+  }
+  return out;
+}
+function isLoopback(url) {
+  if (!url) return false;
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+  if (host === "localhost" || host.endsWith(".localhost")) return true;
+  if (host === "::1" || host === "0:0:0:0:0:0:0:1") return true;
+  const v4 = host.replace(/^::ffff:/, "");
+  const m = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(v4);
+  return !!m && m.slice(1).every((o) => Number(o) <= 255) && m[1] === "127";
+}
+function target(a) {
+  switch (a.provider) {
+    case "heuristic":
+    case "embedding":
+      return { remote: false, needsKey: false };
+    case "typesafe":
+      return {
+        remote: !isLoopback(a.typesafe.baseUrl),
+        needsKey: true,
+        keyId: "typesafe",
+        providerEnv: TYPESAFE_KEY_ENV,
+        baseUrl: a.typesafe.baseUrl,
+        model: a.typesafe.model,
+        price: null
+      };
+    case "openai-compatible": {
+      const p2 = PRESETS[a.openai.preset];
+      const baseUrl = a.openai.baseUrl ?? p2.baseUrl;
+      const model = a.openai.model ?? p2.model;
+      const remote = !isLoopback(baseUrl);
+      const t = {
+        remote,
+        needsKey: remote,
+        keyId: `openai:${p2.id}`,
+        preset: p2.id,
+        price: a.openai.price ?? p2.price
+      };
+      if (p2.keyEnv) t.providerEnv = p2.keyEnv;
+      if (baseUrl) t.baseUrl = baseUrl;
+      if (model) t.model = model;
+      if (p2.extra) t.extra = p2.extra;
+      if (p2.id === "custom" && (!a.openai.baseUrl || !a.openai.model))
+        t.misconfigured = "the custom preset needs openai.baseUrl and openai.model";
+      return t;
+    }
+  }
+}
+function resolveAdjudicator(config, opts = {}) {
+  const a = "adjudicator" in config ? config.adjudicator : config;
+  const context = opts.context ?? "hook";
+  const t = target(a);
+  const key = t.keyId ? resolveKey(t.keyId, {
+    keyEnv: a.keyEnv,
+    providerEnv: t.providerEnv,
+    env: opts.env,
+    fileOnly: !t.remote
+  }) : void 0;
+  const r = {
+    enabled: a.enabled,
+    configured: a.provider,
+    provider: a.provider,
+    remote: t.remote,
+    configuredRemote: t.remote,
+    keySource: key?.source ?? "none",
+    keyMasked: mask(key?.key),
+    consent: a.remoteConsent,
+    local: !t.remote && a.provider !== "heuristic"
+  };
+  const origin = t.remote ? originOf(t.baseUrl) : void 0;
+  const via = t.remote ? consentFor(a, origin, opts.env) : void 0;
+  if (t.remote) r.consent = via !== void 0;
+  if (via) r.consentVia = via;
+  if (origin) r.origin = origin;
+  if (t.preset) r.preset = t.preset;
+  if (t.baseUrl) r.baseUrl = t.baseUrl;
+  if (t.model) r.model = t.model;
+  if (t.price !== void 0) r.price = t.price;
+  if (t.extra) r.extra = t.extra;
+  if (t.keyId) r.keyId = t.keyId;
+  if (a.keyEnv) r.keyEnv = a.keyEnv;
+  if (t.providerEnv) r.providerEnv = t.providerEnv;
+  if (key?.refused) r.keyFileRefused = true;
+  const degrade = (why, detail) => ({
+    ...r,
+    provider: "heuristic",
+    degraded: why,
+    detail,
+    remote: false,
+    local: false
+  });
+  if (t.misconfigured) return degrade("misconfigured", t.misconfigured);
+  if (a.provider === "embedding" && context === "hook")
+    return degrade("hook_context", "the embedding provider runs only in the MCP server and CLI");
+  if (t.remote && !via)
+    return degrade(
+      "no_consent",
+      `${a.provider} sends redacted prompt text to ${origin ?? hostOf(t.baseUrl)}${a.remoteConsent && origin ? ", which you have not agreed to (consent is per origin)" : ""}: run \`eminiar adjudicator enable --accept-remote\``
+    );
+  if (t.needsKey && key?.source !== "env" && key?.source !== "file")
+    return degrade(
+      "no_key",
+      key?.refused ? "the key file is readable by others and was ignored: chmod 600 ~/.eminiar/adjudicator.key" : `no key for ${t.keyId}: run \`eminiar adjudicator key set\``
+    );
+  return r;
+}
+function keyFor(r, env) {
+  if (!r.keyId) return void 0;
+  return resolveKey(r.keyId, {
+    keyEnv: r.keyEnv,
+    providerEnv: r.providerEnv,
+    env,
+    fileOnly: !r.configuredRemote
+  });
+}
+function currentKeyFingerprint(r, env) {
+  const k = keyFor(r, env);
+  return k?.key ? keyFingerprint(k.key) : null;
+}
+function hostOf(url) {
+  if (!url) return "a remote host";
+  try {
+    return new URL(url).host;
+  } catch {
+    return "a remote host";
+  }
+}
+
+// src/adjudicator/providers/index.ts
+init_esm_shims();
+
+// src/adjudicator/providers/openai.ts
+init_esm_shims();
+
+// src/adjudicator/prompt.ts
+init_esm_shims();
+
+// src/adjudicator/redact.ts
+init_esm_shims();
+import { createHash as createHash2 } from "crypto";
+function normalize(text) {
+  return text.normalize("NFKC").replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "").replace(/[ \t]{2,}/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function inputHash(text) {
+  return createHash2("sha256").update(normalize(text)).digest("hex");
+}
+var SECRET_WORDS = /* @__PURE__ */ new Set([
+  "key",
+  "token",
+  "secret",
+  "secrets",
+  "pass",
+  "password",
+  "passwd",
+  "passphrase",
+  "pwd",
+  "pw",
+  "credential",
+  "credentials",
+  "creds",
+  "auth",
+  "authorization",
+  "pat"
+]);
+var SECRET_WORD_SUFFIX = /(?:password|passwd|passphrase|secret|token|apikey|accesskey|secretkey|privatekey|authkey|signingkey|masterkey)$/;
+var SECRET_QUALIFIERS = /* @__PURE__ */ new Set([
+  "base",
+  "hash",
+  "value",
+  "val",
+  "b64",
+  "base64",
+  "enc",
+  "encrypted",
+  "raw",
+  "plain",
+  "str",
+  "string",
+  "live",
+  "prod",
+  "test",
+  "data"
+]);
+function isSecretName(name) {
+  const words = name.split(/[_.-]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/).map((w) => w.toLowerCase()).filter(Boolean);
+  for (let i = words.length - 1; i >= 0; i--) {
+    const w = words[i];
+    if (SECRET_WORDS.has(w) || SECRET_WORD_SUFFIX.test(w)) return true;
+    if (!SECRET_QUALIFIERS.has(w) && !/^v?\d+$/.test(w)) return false;
+  }
+  return false;
+}
+var NOT_A_SECRET_VALUE = /^(?:true|false|null|nil|none|undefined|yes|no|on|off|\*+|\[[a-z ]+\]|\$\{?[A-Za-z_][A-Za-z0-9_]*\}?|process\.env\.[A-Za-z_][A-Za-z0-9_]*|<[^>]*>|\d{1,4})$/i;
+var ASSIGN_NAME = /(?<![A-Za-z0-9_.-])([A-Za-z0-9_.-]+)(["'`]?[ \t]*(?::=|=>|[:=])[ \t]*)/g;
+var ASSIGN_VALUE = new RegExp(
+  [
+    "(?!(?:Basic|Bearer|Token|Digest|Negotiate|NTLM)[ \\t]+\\*\\*\\*)",
+    "(?:",
+    "([\"'`])((?:(?!\\1)[^\\\\\\n]|\\\\.){0,512})\\1",
+    // 1 quote, 2 quoted value
+    "|",
+    "([^\\s\"'`&;,=<\\[{(|>](?:[^\\s\"'`&;,]|[&;,](?=[^\\s\"'`&;,])(?![A-Za-z0-9_.\\- ]*=))*)",
+    // 3 bare
+    ")"
+  ].join(""),
+  "y"
+);
+function maskAssignments(text) {
+  ASSIGN_NAME.lastIndex = 0;
+  let out = "";
+  let last = 0;
+  for (let m = ASSIGN_NAME.exec(text); m; m = ASSIGN_NAME.exec(text)) {
+    if (!isSecretName(m[1])) continue;
+    const start = m.index + m[0].length;
+    ASSIGN_VALUE.lastIndex = start;
+    const v = ASSIGN_VALUE.exec(text);
+    if (!v) continue;
+    const [value, q, quoted, bare] = v;
+    const raw = q ? quoted ?? "" : bare ?? "";
+    if (!raw || NOT_A_SECRET_VALUE.test(raw)) continue;
+    out += text.slice(last, start) + (q ? `${q}***${q}` : "***");
+    last = start + value.length;
+    ASSIGN_NAME.lastIndex = last;
+  }
+  return out + text.slice(last);
+}
+function maskYamlBlocks(text) {
+  if (!/:[ \t]*[|>]/.test(text)) return text;
+  const lines = text.split("\n");
+  const header = /^([ \t]*)(?:-[ \t]+)?["']?([A-Za-z0-9_.-]+)["']?[ \t]*:[ \t]*[|>][+-]?[1-9]?[ \t\r]*$/;
+  for (let i = 0; i < lines.length; i++) {
+    const h = header.exec(lines[i]);
+    if (!h || !isSecretName(h[2])) continue;
+    const indent = h[1].length;
+    let last = i;
+    let pad = "";
+    for (let j = i + 1; j < lines.length; j++) {
+      const line = lines[j];
+      if (line.trim() === "") continue;
+      const n = /^[ \t]*/.exec(line)[0].length;
+      if (n <= indent) break;
+      if (last === i) pad = line.slice(0, n);
+      last = j;
+    }
+    if (last === i) continue;
+    lines.splice(i + 1, last - i, `${pad}***`);
+    i++;
+  }
+  return lines.join("\n");
+}
+var COOKIE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "path",
+  "domain",
+  "expires",
+  "max-age",
+  "samesite",
+  "secure",
+  "httponly",
+  "priority",
+  "partitioned",
+  "version",
+  "comment"
+]);
+function maskCookiePairs(pairs) {
+  return pairs.replace(
+    /(^|;[ \t]*)([^=;]+)=([^;]*)/g,
+    (m, sep, name, value) => !value || value === "***" || COOKIE_ATTRIBUTES.has(name.trim().toLowerCase()) ? m : `${sep}${name}=***`
+  );
+}
+var IGNORABLE = new RegExp("\\p{Default_Ignorable_Code_Point}", "gu");
+function clean(text) {
+  return text.replace(IGNORABLE, "").normalize("NFKC").replace(IGNORABLE, "");
+}
+var RULES = [
+  // PEM / OpenSSH / PGP private key blocks, whole (to the END line, or the end of the text).
+  [
+    /-----BEGIN [A-Z0-9 ]{0,40}PRIVATE KEY(?: BLOCK)?-----[\s\S]*?(?:-----END [A-Z0-9 ]{0,60}-----|$)/g,
+    "[private key]"
+  ],
+  // Credentials inside URLs: scheme://user:pass@host, scheme://:pass@host
+  [/\b([a-z][a-z0-9+.-]{0,30}:\/\/)[^\s/:@]*:[^\s/@]+@/gi, "$1***@"],
+  // Authorization / Proxy-Authorization headers: the scheme stays, the credentials go.
+  [
+    /\b((?:Proxy-)?Authorization["']?[ \t]*[:=][ \t]*["']?)(?!(?:(?:Basic|Bearer|Token|Digest|Negotiate|NTLM|ApiKey|Key)[ \t]+)?\*\*\*)(?:(Basic|Bearer|Token|Digest|Negotiate|NTLM|ApiKey|Key)[ \t]+)?[^\s"'`]+/gi,
+    (_m, pre = "", scheme = "") => `${pre}${scheme ? `${scheme} ` : ""}***`
+  ],
+  [/\bBearer[ \t]+(?!\*\*\*)[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer ***"],
+  // curl -u / --user user:pass (the user stays)
+  [/(?<!\S)(-u|--user)([ \t]*=?[ \t]*)(["']?)([^\s:"'@]+):(?!\*\*\*)[^\s"']+\3/g, "$1$2$3$4:***$3"],
+  // --password x, --token x, --api-key x, --client-secret x … (the `=` form is an assignment)
+  [
+    /(?<!\S)(--(?:[a-z0-9]+-){0,4}(?:password|passwd|pass|passphrase|token|secret|api-?key|access-key|secret-key|auth-token|credentials?))([ \t]+)(?!-|\*\*\*)(?:(["'])[^\n]{0,256}?\3|[^\s"']+)/gi,
+    "$1$2$3***$3"
+  ],
+  // mysql / mariadb -p<password> (attached; `-p` alone prompts)
+  [
+    /\b((?:mysql|mysqldump|mysqladmin|mariadb|mariadb-dump)\b[^\n]{0,300}?(?<!\S)-p)(?![\s*])(?:(["'])[^\n]{0,256}?\2|[^\s"']+)/g,
+    "$1$2***$2"
+  ],
+  // Tools whose short password flag takes the next word, only on that tool's own command (the
+  // context stops at ; & | so `docker login … && docker run -p 8080:80` keeps the port):
+  // registry logins -p, mongo* -p, redis-cli -a, ldap* -w, zip/unzip -P, mosquitto_* -P.
+  [
+    /\b((?:(?:(?:docker|podman|nerdctl|buildah|skopeo|oras|finch)(?:[ \t]+registry)?|helm[ \t]+registry|crane[ \t]+auth)[ \t]+login\b[^\n;&|]{0,300}?(?<!\S)-p|mongo(?:sh|dump|restore|import|export|stat|top|files)?\b[^\n;&|]{0,300}?(?<!\S)-p|redis-cli\b[^\n;&|]{0,300}?(?<!\S)-a|ldap(?:search|add|modify|delete|whoami|passwd|compare|modrdn|exop)\b[^\n;&|]{0,300}?(?<!\S)-w|(?:zip|unzip|zipcloak)\b[^\n;&|]{0,300}?(?<!\S)-P|mosquitto_(?:pub|sub|rr)\b[^\n;&|]{0,300}?(?<!\S)-P)[ \t]+)(?!-|\*\*\*)(?:(["'])[^\n]{0,256}?\2|[^\s"']+)/g,
+    "$1$2***$2"
+  ],
+  // 7z -p<password> (attached, like mysql)
+  [
+    /\b(7z[az]?\b[^\n;&|]{0,300}?(?<!\S)-p)(?![\s*])(?:(["'])[^\n]{0,256}?\2|[^\s"']+)/g,
+    "$1$2***$2"
+  ],
+  // sshpass -p <password> / -p<password>: only sshpass's own options may come before it, so
+  // `sshpass -f file ssh -p 22 host` keeps ssh's port.
+  [
+    /\b(sshpass(?:[ \t]+(?:-[fdP][ \t]*[^\s-]\S*|-[a-oq-zA-Z]\S*)){0,3}[ \t]+-p[ \t]*)(?!-|\*\*\*)(?:(["'])[^\n]{0,256}?\2|[^\s"']+)/g,
+    "$1$2***$2"
+  ],
+  // htpasswd -b[n] [file] user password: the last word is the password.
+  [
+    /\b(htpasswd((?:[ \t]+-[A-Za-z]+){1,4})[ \t]+)([^\s-]\S*)[ \t]+([^\s-]\S*)(?:[ \t]+([^\s-]\S*))?/g,
+    (m, pre = "", flags = "", a = "", b = "", c) => {
+      if (!/b/.test(flags)) return m;
+      if (/n/.test(flags))
+        return b === "***" ? m : `${pre}${a} ***${c === void 0 ? "" : ` ${c}`}`;
+      return c === void 0 || c === "***" ? m : `${pre}${a} ${b} ***`;
+    }
+  ],
+  // echo <password> | docker login --password-stdin, and … --password-stdin <<< <password>
+  [
+    /(?<!\S)((?:echo(?:[ \t]+-[neE]+)?|printf(?:[ \t]+(["'])%s(?:\\n)?\2)?)[ \t]+)(["']?)(?!\$|\*\*\*)[^\s"'|]{1,256}\3(?=[ \t]*\|[^\n]{0,200}?--password-stdin\b)/g,
+    "$1$3***$3"
+  ],
+  [/(--password-stdin\b[^\n]{0,200}?<<<[ \t]*)(["']?)(?!\$|\*\*\*)[^\s"']{1,256}\2/g, "$1$2***$2"],
+  // openssl -pass/-passin/-passout pass:<password> (env:/file:/fd: name a source, kept)
+  [/(?<!\S)(-pass(?:in|out)?[ \t]+pass:)(?!\*\*\*)[^\s"']+/g, "$1***"],
+  // keytool -storepass x / -keypass x (… -storepass:env VAR names a source, kept)
+  [
+    /(?<!\S)(-(?:store|key|srcstore|deststore|srckey|destkey)pass[ \t]+)(?!-|\*\*\*)(?:(["'])[^\n]{0,256}?\2|[^\s"']+)/g,
+    "$1$2***$2"
+  ],
+  // smbclient / rpcclient -U user%password (the user stays)
+  [/(?<!\S)(-U[ \t]*)(["']?)([^\s%"']+)%(?!\*\*\*)[^\s"']+\2/g, "$1$2$3%***$2"],
+  // .netrc: `machine host login me password x` on one line or across lines, `default …`, and a
+  // bare `login me` / `password x` pair of lines.
+  [
+    /((?:\bmachine[ \t]+[^\s]+|^[ \t]*default\b)(?:\s+(?:login|account)[ \t]+[^\s]+){0,2}\s+password[ \t]+|^[ \t]*login[ \t]+[^\s]+[ \t]*\n[ \t]*password[ \t]+)(?!\*\*\*)("[^"\n]{0,256}"|[^\s"]+)/gm,
+    (_m, pre = "", v = "") => `${pre}${v.startsWith('"') ? '"***"' : "***"}`
+  ],
+  // Cookie / Set-Cookie headers (and curl --cookie / -b): every cookie value goes, the names and
+  // the Set-Cookie attributes (Path, Expires, …) stay.
+  [
+    /(\b(?:Set-)?Cookie["']?[ \t]*:[ \t]*["']?|(?:\bcurl\b[^\n;&|]{0,300}?(?<!\S)-b|(?<!\S)--cookie)(?:[ \t]+|=)["']?)([^\s=;,"'`]+=[^\s;,"'`]*(?:;[ \t]*[^\s=;,"'`]+(?:=[^\s;,"'`]*)?)*)/gi,
+    (_m, pre = "", pairs = "") => pre + maskCookiePairs(pairs)
+  ],
+  // Prose: "the password is Wint3rIsComing", "the signing secret was x9-y" (only when the word
+  // looks like a secret: it has a digit or a symbol).
+  [
+    /\b((?:pass(?:word|phrase|wd)|secret|token|api[ -]?key|access[ -]key)[ \t]+(?:is|was)[ \t]*:?[ \t]+)(["']?)(?=[^\s"']{0,128}[\d!@#$%^&*])(?!\*\*\*)[^\s"']{4,128}\2/gi,
+    "$1$2***$2"
+  ],
+  [/\b(sk|rk|pk)_(live|test)_[A-Za-z0-9]{10,}/g, "$1_$2_***"],
+  [/\bwhsec_[A-Za-z0-9]{16,}/g, "whsec_***"],
+  [/\bsk-[A-Za-z0-9_-]{16,}/g, "sk-***"],
+  [/\b(gh[pousr]|github_pat)_[A-Za-z0-9_]{20,}/g, "$1_***"],
+  [/\bglpat-[A-Za-z0-9_-]{20,}/g, "glpat-***"],
+  [/\bnpm_[A-Za-z0-9]{36,}/g, "npm_***"],
+  [/\bhf_[A-Za-z0-9]{30,}/g, "hf_***"],
+  [/\bxox[a-z]-[A-Za-z0-9-]{10,}/g, "xox*-***"],
+  [/\b(hooks\.slack\.com\/services\/)[A-Za-z0-9/]{10,}/g, "$1***"],
+  [/\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, "AKIA***"],
+  [/\bAIza[0-9A-Za-z_-]{35}/g, "AIza***"],
+  [/\bSG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}/g, "SG.***"],
+  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, "[jwt]"],
+  ["assignments", maskAssignments],
+  // (the local part starts at the start of its run, not at every \b inside it: `--a-a-a…`)
+  [/(?<![A-Za-z0-9._%+-])[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, "[email]"],
+  [/\b[0-9a-fA-F]{24,}\b/g, "[hex]"],
+  // base64 / base64url runs of 32+ chars mixing upper, lower and digits (not a word or a path)
+  [
+    /(?<![A-Za-z0-9+/_-])(?=[A-Za-z0-9+/_-]*\d)(?=[A-Za-z0-9+/_-]*[A-Z])(?=[A-Za-z0-9+/_-]*[a-z])[A-Za-z0-9+/_-]{32,}={0,2}/g,
+    "[b64]"
+  ]
+];
+function redact(text) {
+  let out = maskYamlBlocks(clean(text));
+  for (const rule of RULES) {
+    if (rule[0] === "assignments") out = rule[1](out);
+    else if (typeof rule[1] === "string") out = out.replace(rule[0], rule[1]);
+    else out = out.replace(rule[0], rule[1]);
+  }
+  return out;
+}
+function head(text, n = 80) {
+  const chars = Array.from(redact(normalize(maskYamlBlocks(clean(text)))).replace(/\s+/g, " "));
+  if (chars.length <= n) return chars.join("");
+  return `${chars.slice(0, Math.max(0, n - 1)).join("")}\u2026`;
+}
+function forRemote(text, maxChars) {
+  return Array.from(redact(normalize(maskYamlBlocks(clean(text))))).slice(0, maxChars).join("");
+}
+
+// src/adjudicator/prompt.ts
+var COMPLEXITY_CRITERIA = [
+  "trivial chat or lookup",
+  "small single-file change",
+  "multi-step change in one area",
+  "cross-cutting change",
+  "architectural or multi-subsystem"
+];
+var TIER_CRITERIA = {
+  haiku: "fast and cheap: lookups, searches, small mechanical edits, summaries",
+  sonnet: "default coder: features and fixes in one area, tests, ordinary reviews",
+  opus: "hard reasoning: cross-cutting or architectural work, subtle debugging, design",
+  fable: "largest model: only the hardest open-ended, multi-subsystem problems"
+};
+var ROLE_DESCRIPTIONS = {
+  explorer: "finds where code lives and what depends on it",
+  researcher: "reads documentation and external sources",
+  coder: "implements and edits code",
+  tester: "writes and runs tests",
+  reviewer: "reviews changes for bugs and quality",
+  architect: "designs and plans larger changes",
+  ui: "builds user interface work",
+  none: "no delegation needed"
+};
+var TOOL_DESCRIPTIONS = {
+  em_symbols: "find a symbol or list a file's symbols",
+  em_search: "search indexed code, docs and past output",
+  em_graph_impact: "what depends on or breaks from a change",
+  em_history: "git history of a file or change",
+  em_execute: "run a command or tests, keep output small",
+  em_batch_execute: "run several commands in one call, keep output small",
+  em_execute_file: "process a large file without reading it",
+  em_docs: "answer from indexed library docs",
+  em_fetch_and_index: "fetch and index a web page",
+  em_recall: "recall past decisions and constraints",
+  em_swarm: "plan and fan out work to agents",
+  Edit: "edit a file directly",
+  Bash: "run a short shell command",
+  Agent: "delegate to a subagent",
+  none: "no tool, just answer"
+};
+function itemId(i) {
+  return `i${i}`;
+}
+var MAX_ROLES = 16;
+var ROLE_NAME = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/;
+function buildCatalogue(reqs, o) {
+  const roles = /* @__PURE__ */ new Map();
+  for (const r of reqs)
+    for (const role of r.hints?.roles ?? []) {
+      if (roles.size >= MAX_ROLES - 1) break;
+      if (typeof role.name === "string" && ROLE_NAME.test(role.name) && !roles.has(role.name))
+        roles.set(role.name, typeof role.description === "string" ? role.description : "");
+    }
+  if (roles.size === 0) for (const r of DEFAULT_ROLES) roles.set(r, ROLE_DESCRIPTIONS[r]);
+  else if (!roles.has("none")) roles.set("none", ROLE_DESCRIPTIONS.none);
+  const allowed = o.tools ? new Set(o.tools) : void 0;
+  const tools = TOOL_IDS.filter((t) => !allowed || allowed.has(t) || t === "none");
+  const tiers = [...new Set(o.tiers)].filter((t) => t in TIER_CRITERIA);
+  return {
+    tiers: tiers.map((t) => ({ name: t, description: TIER_CRITERIA[t] })),
+    roles: [...roles].map(([name, description]) => ({ name, description: oneLine(description) })),
+    tools: tools.map((t) => ({ name: t, description: TOOL_DESCRIPTIONS[t] }))
+  };
+}
+function buildItems(reqs, maxChars, offset = 0) {
+  return reqs.map((r, i) => {
+    const item = { id: itemId(offset + i), text: forRemote(r.text, maxChars) };
+    if (r.hints?.role) item.role = r.hints.role;
+    if (r.hints?.files !== void 0) item.files = r.hints.files;
+    if (r.hints?.deps !== void 0) item.deps = r.hints.deps;
+    return item;
+  });
+}
+function jevQuestionId(item, q) {
+  return `${item}.${q}`;
+}
+function jevState(cat, items) {
+  return {
+    catalogue: {
+      tiers: cat.tiers.map((t) => t.name),
+      roles: cat.roles,
+      tools: cat.tools.map((t) => t.name)
+    },
+    items
+  };
+}
+function jevQuestions(items, cat, o) {
+  const tierCriteria = Object.fromEntries(cat.tiers.map((t) => [t.name, t.description]));
+  const roleCriteria = Object.fromEntries(
+    cat.roles.map((r) => [r.name, r.description || `the ${r.name} role`])
+  );
+  const toolCriteria = Object.fromEntries(cat.tools.map((t) => [t.name, t.description]));
+  const out = {};
+  for (const { id } of items) {
+    const it = `item "${id}" in state.items`;
+    out[jevQuestionId(id, "complexity")] = {
+      type: "score",
+      instructions: `How complex is the software work described by ${it}?`,
+      criteria: [...COMPLEXITY_CRITERIA]
+    };
+    out[jevQuestionId(id, "tier")] = {
+      type: "choice",
+      instructions: `Which Claude model tier is the smallest that can do ${it} well?`,
+      criteria: tierCriteria
+    };
+    out[jevQuestionId(id, "role")] = {
+      type: "choice",
+      instructions: `Which agent role (state.catalogue.roles) fits ${it} best?`,
+      criteria: roleCriteria
+    };
+    out[jevQuestionId(id, "risky")] = {
+      type: "noul",
+      instructions: `Is ${it} risky: could it break shared code, data, security or a release?`
+    };
+    out[jevQuestionId(id, "needs_plan")] = {
+      type: "noul",
+      instructions: `Does ${it} need a plan split into several tasks before any code is written?`
+    };
+    if (o.askTool)
+      out[jevQuestionId(id, "tool")] = {
+        type: "choice",
+        instructions: `Which tool should be used first for ${it}?`,
+        criteria: toolCriteria
+      };
+  }
+  return out;
+}
+var SCHEMA_MAX_CHARS = 5e3;
+function openaiSchema(cat, ids, o) {
+  const item = {
+    id: { type: "string", enum: [...ids] },
+    complexity: { type: "integer", enum: [0, 1, 2, 3, 4] },
+    tier: { type: "string", enum: cat.tiers.map((t) => t.name) },
+    role: { type: "string", enum: cat.roles.map((r) => r.name) }
+  };
+  if (o.askTool) item.tool = { type: "string", enum: cat.tools.map((t) => t.name) };
+  item.risky = { type: "boolean" };
+  item.confidence = { type: "number" };
+  const schema = {
+    type: "object",
+    properties: {
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: item,
+          required: Object.keys(item),
+          additionalProperties: false
+        }
+      }
+    },
+    required: ["items"],
+    additionalProperties: false
+  };
+  if (schemaText(schema).length > SCHEMA_MAX_CHARS) item.id = { type: "string" };
+  return schema;
+}
+function schemaText(schema) {
+  return JSON.stringify(schema);
+}
+function rubric(cat, o) {
+  const lines = [
+    "You route software-engineering requests for a coding assistant. For each item in the user's JSON, judge the work it describes.",
+    "complexity (integer):",
+    ...COMPLEXITY_CRITERIA.map((c, i) => `  ${i} = ${c}`),
+    "tier: the smallest Claude model that does the item well:",
+    ...cat.tiers.map((t) => `  ${t.name}: ${t.description}`),
+    "role: the agent role that fits best:",
+    ...cat.roles.map((r) => `  ${r.name}${r.description ? `: ${r.description}` : ""}`)
+  ];
+  if (o.askTool)
+    lines.push(
+      "tool: the tool to use first:",
+      ...cat.tools.map((t) => `  ${t.name}: ${t.description}`)
+    );
+  lines.push(
+    "risky: true when the work could break shared code, data, security or a release.",
+    "confidence: 0..1, how sure you are of tier and complexity.",
+    "Answer every item, once, with its id. Reply with JSON only."
+  );
+  if (o.schema !== void 0)
+    lines.push(`The JSON must match this schema: ${schemaText(o.schema)}`);
+  return lines.join("\n");
+}
+function oneLine(s) {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > 120 ? `${t.slice(0, 119)}\u2026` : t;
+}
+
+// src/adjudicator/providers/http.ts
+init_esm_shims();
+
+// src/adjudicator/providers/capture.ts
+init_esm_shims();
+var EXCHANGE_BODY_MAX = 65536;
+var SCRUB_WINDOW = EXCHANGE_BODY_MAX * 2;
+var MAX_DEPTH = 64;
+var SECRET_HEADERS = /* @__PURE__ */ new Set(["cookie", "set-cookie", "proxy-authorization"]);
+var IGNORABLE2 = new RegExp("\\p{Default_Ignorable_Code_Point}", "gu");
+function unhide(s) {
+  return s.replace(IGNORABLE2, "").normalize("NFKC").replace(IGNORABLE2, "");
+}
+function replaceAll(s, needle) {
+  return s.includes(needle) ? s.split(needle).join("***") : s;
+}
+function scrubKey(s, key) {
+  if (!key || key.length < 4) return redact(s);
+  const plain = unhide(key);
+  let out = unhide(replaceAll(s, key));
+  if (plain.length >= 4) out = replaceAll(out, plain);
+  out = redact(out);
+  return plain.length >= 4 ? replaceAll(out, plain) : out;
+}
+function dropKeyTail(s, key) {
+  if (!key || key.length < 4) return s;
+  const plain = unhide(key);
+  for (let n = Math.min(plain.length - 1, s.length); n > 0; n--)
+    if (s.endsWith(plain.slice(0, n))) return s.slice(0, s.length - n);
+  return s;
+}
+function scrubHead(text, window, key) {
+  if (text.length <= window) return scrubKey(text, key);
+  return dropKeyTail(scrubKey(text.slice(0, window), key), key);
+}
+function trivial(s) {
+  return s === "" || /^\*+$/.test(s);
+}
+function walk(v, key, depth, secret) {
+  if (typeof v === "string") return secret && !trivial(v) ? "***" : scrubKey(v, key);
+  if (v === null || typeof v !== "object") return v;
+  if (depth >= MAX_DEPTH) return "[too deep]";
+  if (Array.isArray(v)) return v.map((x) => walk(x, key, depth + 1, secret));
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [k, x] of Object.entries(v)) {
+    const name = scrubKey(k, key);
+    const hidden = unhide(k);
+    const secret2 = isSecretName(hidden) || SECRET_HEADERS.has(hidden.toLowerCase());
+    out[name] = walk(x, key, depth + 1, secret2);
+  }
+  return out;
+}
+function cap(text, json) {
+  return text.length > EXCHANGE_BODY_MAX ? { text: text.slice(0, EXCHANGE_BODY_MAX), json, bytes: text.length, truncated: true } : { text, json, bytes: text.length, truncated: false };
+}
+function captureBody(value, key) {
+  if (value === void 0) return { text: "", json: false, bytes: 0, truncated: false };
+  return cap(JSON.stringify(walk(value, key, 0, false)) ?? "", true);
+}
+function captureText(text, key, parsed) {
+  if (text.length > SCRUB_WINDOW) {
+    return {
+      text: scrubHead(text, SCRUB_WINDOW, key).slice(0, EXCHANGE_BODY_MAX),
+      json: false,
+      bytes: text.length,
+      truncated: true
+    };
+  }
+  if (parsed !== void 0) return captureBody(parsed, key);
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return cap(scrubKey(text, key), false);
+  }
+  return captureBody(value, key);
+}
+
+// src/adjudicator/providers/http.ts
+var RETRY_MIN_REMAINING_MS = 300;
+var RETRY_BACKOFF_MS = 100;
+var BODY_SNIPPET = 500;
+var ProviderError = class extends Error {
+  kind;
+  /** HTTP status, when the server answered. */
+  status;
+  /** Scrubbed start of the response body, for http_error. */
+  body;
+  constructor(kind, message, o = {}) {
+    super(message);
+    this.name = "ProviderError";
+    this.kind = kind;
+    this.status = o.status;
+    this.body = o.body;
+  }
+};
+var PROBE_TIMEOUT_MS = 2e3;
+function scrub(text, key) {
+  return scrubKey(text, key);
+}
+function postJson(url, body, o) {
+  return request("POST", url, body, o);
+}
+function getJson(url, o) {
+  return request("GET", url, void 0, o);
+}
+function joinUrl(base, path) {
+  return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+async function request(method, url, body, o) {
+  const now = o.now ?? Date.now;
+  const doFetch = o.fetch ?? ((u, i) => globalThis.fetch(u, i));
+  const start = now();
+  const end = start + Math.max(0, o.deadlineMs);
+  const target2 = safeTarget(url);
+  const payload = method === "POST" ? JSON.stringify(body) : void 0;
+  let x;
+  let lastText;
+  let lastStatus;
+  const settle2 = (outcome, status, error) => {
+    if (!x) return;
+    try {
+      x.durationMs = now() - x.sentAt;
+      x.status = status;
+      if (x.response === null && lastText !== void 0) x.response = captureText(lastText, o.key);
+      if (error !== void 0) x.error = error;
+      x.outcome = outcome;
+    } catch {
+      x.outcome = outcome;
+    }
+  };
+  const fail = (e) => {
+    if (x) settle2(e.kind, e.status ?? lastStatus ?? null, scrub(e.message, o.key));
+    o.log?.(scrub(`adjudicator ${method} ${target2}: ${e.kind} ${e.message}`, o.key));
+    throw e;
+  };
+  const headers = { accept: "application/json", ...o.headers };
+  if (payload !== void 0) headers["content-type"] = "application/json";
+  if (o.key) headers.authorization = `Bearer ${o.key}`;
+  for (let attempt = 1; ; attempt++) {
+    const remaining = end - now();
+    if (remaining <= 0 || o.signal?.aborted)
+      return fail(new ProviderError("timeout", `deadline of ${o.deadlineMs} ms passed`));
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), remaining);
+    const onAbort = () => ctl.abort();
+    o.signal?.addEventListener("abort", onAbort, { once: true });
+    let res;
+    let text;
+    const attemptStart = now();
+    try {
+      const init = { method, headers, signal: ctl.signal, redirect: "manual" };
+      if (payload !== void 0) init.body = payload;
+      const sent = doFetch(url, init);
+      if (o.exchange && !x) {
+        try {
+          const rec = {
+            method,
+            target: target2,
+            sentAt: attemptStart,
+            deadlineMs: o.deadlineMs,
+            attempts: 1,
+            retryWaitMs: 0,
+            ttfbMs: null,
+            durationMs: null,
+            status: null,
+            outcome: "pending",
+            request: captureBody(body, o.key),
+            response: null,
+            error: null
+          };
+          o.exchange(rec);
+          x = rec;
+        } catch {
+          x = void 0;
+        }
+      }
+      res = await sent;
+      if (x) x.ttfbMs = now() - attemptStart;
+      text = await res.text();
+      lastText = text;
+      lastStatus = res.status;
+    } catch (err) {
+      if (ctl.signal.aborted || o.signal?.aborted || isAbort(err))
+        return fail(new ProviderError("timeout", `no answer within ${o.deadlineMs} ms`));
+      return fail(new ProviderError("http_error", `request failed: ${scrub(errText(err), o.key)}`));
+    } finally {
+      clearTimeout(timer);
+      o.signal?.removeEventListener("abort", onAbort);
+    }
+    if (res.status >= 300 && res.status < 400 || res.type === "opaqueredirect") {
+      const to = res.headers.get("location");
+      return fail(
+        new ProviderError(
+          "http_error",
+          `HTTP ${res.status || "redirect"}: redirect${to ? ` to ${redirectTarget(to, url)}` : ""} refused; set the provider's base URL to the final endpoint`,
+          { status: res.status }
+        )
+      );
+    }
+    if (res.status === 429 || res.status === 529) {
+      const wait = retryWait(res.headers.get("retry-after"));
+      const left = end - now() - wait;
+      if (o.retry !== false && attempt === 1 && left >= RETRY_MIN_REMAINING_MS) {
+        o.log?.(`adjudicator ${method} ${target2}: ${res.status}, retrying in ${wait} ms`);
+        if (x) {
+          x.attempts = 2;
+          x.retryWaitMs = wait;
+          x.ttfbMs = null;
+        }
+        lastText = void 0;
+        lastStatus = void 0;
+        if (!await sleep(wait, o.signal))
+          return fail(new ProviderError("timeout", "aborted while waiting to retry"));
+        continue;
+      }
+      return fail(
+        new ProviderError("rate_limited", `HTTP ${res.status}`, {
+          status: res.status,
+          body: scrubHead(text, BODY_SNIPPET, o.key)
+        })
+      );
+    }
+    if (res.status < 200 || res.status >= 300) {
+      const snippet = scrubHead(text, BODY_SNIPPET, o.key);
+      return fail(
+        new ProviderError("http_error", `HTTP ${res.status}: ${snippet.slice(0, 160)}`, {
+          status: res.status,
+          body: snippet
+        })
+      );
+    }
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      return fail(new ProviderError("invalid", "the response is not JSON", { status: res.status }));
+    }
+    if (x) {
+      try {
+        x.response = captureText(text, o.key, json);
+      } catch {
+        x.response = null;
+      }
+      lastText = void 0;
+    }
+    settle2("ok", res.status);
+    return { status: res.status, json, latencyMs: now() - start, attempts: attempt };
+  }
+}
+function retryWait(header) {
+  if (!header) return RETRY_BACKOFF_MS;
+  const s = Number(header);
+  if (Number.isFinite(s) && s >= 0) return Math.round(s * 1e3);
+  const at = Date.parse(header);
+  return Number.isFinite(at) ? Math.max(0, at - Date.now()) : RETRY_BACKOFF_MS;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve(false);
+    const t = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(true);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      resolve(false);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function isAbort(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+function errText(err) {
+  if (!(err instanceof Error)) return String(err);
+  const cause = err.cause;
+  const code = cause && typeof cause === "object" ? cause.code : void 0;
+  return typeof code === "string" ? `${err.message} (${code})` : err.message;
+}
+function safeTarget(url) {
+  try {
+    const u = new URL(url);
+    return `${u.host}${u.pathname}`;
+  } catch {
+    return "(bad url)";
+  }
+}
+function redirectTarget(location, base) {
+  try {
+    return safeTarget(new URL(location, base).href);
+  } catch {
+    return "(bad url)";
+  }
+}
+function probeDetail(err) {
+  if (err instanceof ProviderError) return `${err.kind}: ${err.message}`;
+  return scrub(err instanceof Error ? err.message : String(err));
+}
+
+// src/adjudicator/providers/openai.ts
+var MAX_TOKENS_BASE = 64;
+var MAX_TOKENS_PER_ITEM = 48;
+function rejectsSchema(err) {
+  return err instanceof ProviderError && err.status === 400 && /response_format|json_schema/i.test(`${err.body ?? ""} ${err.message}`);
+}
+var Completion = external_exports.object({
+  model: external_exports.string().optional(),
+  choices: external_exports.array(external_exports.object({ message: external_exports.object({ content: external_exports.string().nullable().optional() }) })).min(1),
+  usage: external_exports.object({
+    prompt_tokens: external_exports.number().nonnegative().optional(),
+    completion_tokens: external_exports.number().nonnegative().optional()
+  }).nullable().optional()
+});
+function parseContent(content) {
+  const t = content.trim();
+  const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(t);
+  try {
+    return JSON.parse(fenced?.[1] ?? t);
+  } catch {
+    throw new ProviderError("invalid", "the model's answer is not JSON");
+  }
+}
+function itemSchema(cat, askTool) {
+  const names = (xs) => xs.map((x) => x.name);
+  return external_exports.object({
+    id: external_exports.string(),
+    complexity: external_exports.number().min(0).max(4),
+    tier: external_exports.enum(names(cat.tiers)),
+    role: external_exports.enum(names(cat.roles)),
+    tool: askTool ? external_exports.enum(names(cat.tools)) : external_exports.unknown().optional(),
+    risky: external_exports.boolean(),
+    confidence: external_exports.number().min(0).max(1)
+  });
+}
+function createOpenAIProvider(r, cfg, deps = {}) {
+  const baseUrl = r.baseUrl;
+  const askTool = (cfg.weights.features.toolProvider ?? 0) > 0;
+  const json = cfg.openai.json;
+  const price = r.local ? { inPerM: 0, outPerM: 0 } : r.price ?? null;
+  let schemaRejected = false;
+  const key = () => {
+    if (!r.keyId) return void 0;
+    const k = keyFor(r, deps.env)?.key;
+    if (!k && r.remote) throw new ProviderError("no_key", `no key for ${r.keyId}`);
+    return k;
+  };
+  function body(cat, items, schema, mode) {
+    const b = {
+      ...r.extra,
+      temperature: 0,
+      max_tokens: MAX_TOKENS_BASE + MAX_TOKENS_PER_ITEM * items.length,
+      messages: [
+        {
+          role: "system",
+          content: rubric(cat, mode === "object" ? { askTool, schema } : { askTool })
+        },
+        { role: "user", content: JSON.stringify({ items }) }
+      ],
+      response_format: mode === "schema" ? { type: "json_schema", json_schema: { name: "adjudication", strict: true, schema } } : { type: "json_object" }
+    };
+    if (r.model) b.model = r.model;
+    if (r.model && /gpt-oss/i.test(r.model) && b.reasoning_effort === void 0)
+      b.reasoning_effort = "low";
+    return b;
+  }
+  return {
+    id: "openai-compatible",
+    remote: r.remote,
+    dims: askTool ? ["complexity", "tier", "role", "tool"] : ["complexity", "tier", "role"],
+    async adjudicate(reqs, o) {
+      if (reqs.length === 0)
+        return {
+          answers: [],
+          usage: { inTok: 0, outTok: 0, costUsd: 0 },
+          latencyMs: 0,
+          model: r.model ?? ""
+        };
+      if (!baseUrl)
+        throw new ProviderError("invalid", "no baseUrl for the openai-compatible provider");
+      const now = deps.now ?? Date.now;
+      const start = now();
+      const cat = buildCatalogue(reqs, { tiers: cfg.tiers, tools: deps.tools });
+      const items = buildItems(reqs, cfg.privacy.maxChars);
+      const schema = openaiSchema(
+        cat,
+        items.map((i) => i.id),
+        { askTool }
+      );
+      const k = key();
+      const send = (mode) => postJson(joinUrl(baseUrl, "chat/completions"), body(cat, items, schema, mode), {
+        deadlineMs: o.deadlineMs - (now() - start),
+        signal: o.signal,
+        key: k,
+        fetch: deps.fetch,
+        now: deps.now,
+        log: deps.log
+      });
+      let res;
+      const first = json === "object" || json === "auto" && schemaRejected ? "object" : "schema";
+      try {
+        res = await send(first);
+      } catch (err) {
+        if (first !== "schema" || json !== "auto" || !rejectsSchema(err)) throw err;
+        schemaRejected = true;
+        deps.log?.("adjudicator openai: json_schema rejected, retrying with json_object");
+        res = await send("object");
+      }
+      const parsed = Completion.safeParse(res.json);
+      if (!parsed.success)
+        throw new ProviderError("invalid", "the completion has an unexpected shape");
+      const content = parsed.data.choices[0]?.message.content;
+      if (!content) throw new ProviderError("invalid", "the completion has no content");
+      const answers = mapAnswers(reqs, items, parseContent(content), cat, askTool);
+      if (answers.length === 0) throw new ProviderError("invalid", "the answer matched no item");
+      const inTok = parsed.data.usage?.prompt_tokens ?? 0;
+      const outTok = parsed.data.usage?.completion_tokens ?? 0;
+      return {
+        answers,
+        // An unknown price (cerebras, custom without openai.price) is null, not 0: the spend cap
+        // and stats tell "unknown" apart from "free".
+        usage: {
+          inTok,
+          outTok,
+          costUsd: price ? (inTok * price.inPerM + outTok * price.outPerM) / 1e6 : null
+        },
+        latencyMs: now() - start,
+        model: parsed.data.model ?? r.model ?? ""
+      };
+    },
+    async probe(o) {
+      const t0 = (deps.now ?? Date.now)();
+      try {
+        if (!baseUrl) throw new ProviderError("invalid", "no baseUrl");
+        const res = await getJson(joinUrl(baseUrl, "models"), {
+          deadlineMs: PROBE_TIMEOUT_MS,
+          signal: o.signal,
+          key: key(),
+          fetch: deps.fetch,
+          now: deps.now,
+          retry: false
+        });
+        const ids = Array.isArray(res.json?.data) ? res.json.data.flatMap((m) => m.id ? [m.id] : []) : [];
+        const detail = !r.model ? `reachable${ids[0] ? `, serving ${ids[0]}` : ""}` : ids.length === 0 || ids.includes(r.model) ? `${r.model} reachable` : `reachable, but ${r.model} is not listed`;
+        return { ok: true, latencyMs: res.latencyMs, detail };
+      } catch (err) {
+        return { ok: false, latencyMs: (deps.now ?? Date.now)() - t0, detail: probeDetail(err) };
+      }
+    }
+  };
+}
+function mapAnswers(reqs, items, raw, cat, askTool) {
+  const list = raw && typeof raw === "object" && Array.isArray(raw.items) ? raw.items : void 0;
+  if (!list) throw new ProviderError("invalid", "the answer has no items array");
+  const Item = itemSchema(cat, askTool);
+  const byId = /* @__PURE__ */ new Map();
+  for (const x of list) {
+    const p2 = Item.safeParse(x);
+    if (p2.success && !byId.has(p2.data.id)) byId.set(p2.data.id, p2.data);
+  }
+  const out = [];
+  reqs.forEach((req, i) => {
+    const id = items[i]?.id;
+    const x = id ? byId.get(id) : void 0;
+    if (!x) return;
+    const conf = x.confidence;
+    const a = {
+      key: req.key,
+      complexity: { value: Math.round(x.complexity), confidence: conf },
+      tier: { probs: { [x.tier]: 1 }, confidence: conf, calibrated: false },
+      role: { probs: { [x.role]: 1 }, confidence: conf, calibrated: false },
+      risky: x.risky ? 1 : 0
+    };
+    if (askTool && typeof x.tool === "string")
+      a.tool = { probs: { [x.tool]: 1 }, confidence: conf, calibrated: false };
+    out.push(a);
+  });
+  return out;
+}
+
+// src/adjudicator/providers/typesafe.ts
+init_esm_shims();
+var JEV_PINNED = "jev-1.14.0";
+var JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai/v1";
+var JEV_PRICE_IN = 0.042 / 1e6;
+var JEV_BATCH = 10;
+var JEV_MAX_REQUESTS = 2;
+function pinJevModel(model) {
+  if (!model || /^jev-(latest|preview)$/i.test(model.trim())) return JEV_PINNED;
+  return model.trim();
+}
+var Probabilities = external_exports.record(external_exports.string(), external_exports.number().min(0).max(1));
+var Answer = external_exports.union([
+  external_exports.object({
+    type: external_exports.literal("choice"),
+    choice: external_exports.string(),
+    confidence: external_exports.number().min(0).max(1).optional(),
+    probabilities: Probabilities.optional()
+  }),
+  external_exports.object({
+    type: external_exports.literal("score"),
+    // On the rubric's own levels (0..criteria-1), echoed in `legend`; not 0..1.
+    score: external_exports.number().min(0),
+    confidence: external_exports.number().min(0).max(1).optional(),
+    probabilities: Probabilities.optional(),
+    legend: external_exports.record(external_exports.string(), external_exports.string()).optional()
+  }),
+  external_exports.object({ type: external_exports.literal("noul"), noul: external_exports.number().min(0).max(1) })
+]);
+var JevResponse = external_exports.object({
+  model: external_exports.string().optional(),
+  answers: external_exports.record(external_exports.string(), external_exports.unknown()),
+  usage: external_exports.object({
+    input_tokens: external_exports.number().nonnegative().optional(),
+    output_tokens: external_exports.number().nonnegative().optional()
+  }).optional()
+});
+function createTypesafeProvider(r, cfg, deps = {}) {
+  const baseUrl = r.baseUrl ?? JEV_DEFAULT_BASE_URL;
+  const model = pinJevModel(r.model);
+  const askTool = (cfg.weights.features.toolProvider ?? 0) > 0;
+  const key = () => {
+    const k = keyFor({ ...r, keyId: r.keyId ?? "typesafe" }, deps.env)?.key;
+    if (!k) throw new ProviderError("no_key", "no key for typesafe");
+    return k;
+  };
+  async function one(reqs, offset, cat, o) {
+    const items = buildItems(reqs, cfg.privacy.maxChars, offset);
+    const k = key();
+    let pe;
+    const sink = o.capture;
+    const exchange = sink ? (x) => {
+      pe = {
+        http: x,
+        provider: "typesafe",
+        model,
+        batch: Math.floor(offset / JEV_BATCH),
+        itemKeys: reqs.map((r3) => r3.key),
+        tokensIn: null,
+        tokensOut: null,
+        costUsd: null
+      };
+      sink.push(pe);
+    } : void 0;
+    const invalid = (msg) => {
+      if (pe) {
+        pe.http.outcome = "invalid";
+        pe.http.error = msg;
+      }
+      return new ProviderError("invalid", msg);
+    };
+    const res = await postJson(
+      joinUrl(baseUrl, "systemone"),
+      { model, state: jevState(cat, items), questions: jevQuestions(items, cat, { askTool }) },
+      {
+        deadlineMs: o.deadlineMs,
+        signal: o.signal,
+        key: k,
+        fetch: deps.fetch,
+        now: deps.now,
+        log: deps.log,
+        exchange
+      }
+    );
+    const parsed = JevResponse.safeParse(res.json);
+    if (!parsed.success) throw invalid("the Jev response has an unexpected shape");
+    const answers = mapAnswers2(reqs, items, parsed.data.answers, cat);
+    if (answers.length === 0) throw invalid("the Jev response answered no item");
+    const inTok = parsed.data.usage?.input_tokens ?? 0;
+    if (pe) {
+      pe.tokensIn = inTok;
+      pe.tokensOut = parsed.data.usage?.output_tokens ?? 0;
+      pe.costUsd = inTok * JEV_PRICE_IN;
+    }
+    return {
+      answers,
+      inTok,
+      outTok: parsed.data.usage?.output_tokens ?? 0,
+      latencyMs: res.latencyMs,
+      model: parsed.data.model ?? model
+    };
+  }
+  return {
+    id: "typesafe",
+    remote: r.remote,
+    dims: askTool ? ["complexity", "tier", "role", "tool"] : ["complexity", "tier", "role"],
+    async adjudicate(reqs, o) {
+      if (reqs.length === 0)
+        return { answers: [], usage: { inTok: 0, outTok: 0, costUsd: 0 }, latencyMs: 0, model };
+      const cat = buildCatalogue(reqs, { tiers: cfg.tiers, tools: deps.tools });
+      const chunks = [];
+      for (let i = 0; i < reqs.length && chunks.length < JEV_MAX_REQUESTS; i += JEV_BATCH)
+        chunks.push({ reqs: reqs.slice(i, i + JEV_BATCH), offset: i });
+      const settled = await Promise.allSettled(chunks.map((c) => one(c.reqs, c.offset, cat, o)));
+      const ok = settled.flatMap((s) => s.status === "fulfilled" ? [s.value] : []);
+      if (ok.length === 0) {
+        const first = settled.find((s) => s.status === "rejected");
+        throw first && first.status === "rejected" ? first.reason : new ProviderError("invalid", "no answer");
+      }
+      const inTok = ok.reduce((n, x) => n + x.inTok, 0);
+      return {
+        answers: ok.flatMap((x) => x.answers),
+        usage: {
+          inTok,
+          outTok: ok.reduce((n, x) => n + x.outTok, 0),
+          costUsd: inTok * JEV_PRICE_IN
+        },
+        latencyMs: Math.max(...ok.map((x) => x.latencyMs)),
+        model: ok[0]?.model ?? model
+      };
+    },
+    async probe(o) {
+      const t0 = (deps.now ?? Date.now)();
+      try {
+        const res = await getJson(joinUrl(baseUrl, "models"), {
+          deadlineMs: PROBE_TIMEOUT_MS,
+          signal: o.signal,
+          key: key(),
+          fetch: deps.fetch,
+          now: deps.now,
+          retry: false
+        });
+        const ids = Array.isArray(res.json?.data) ? res.json.data.map((m) => m.id) : [];
+        const listed = ids.length === 0 || ids.includes(model);
+        return {
+          ok: true,
+          latencyMs: res.latencyMs,
+          detail: listed ? `typesafe ${model} reachable` : `typesafe reachable, but ${model} is not listed`
+        };
+      } catch (err) {
+        return { ok: false, latencyMs: (deps.now ?? Date.now)() - t0, detail: probeDetail(err) };
+      }
+    }
+  };
+}
+function mapAnswers2(reqs, items, raw, cat) {
+  const get = (id) => {
+    const p2 = Answer.safeParse(raw[id]);
+    return p2.success ? p2.data : void 0;
+  };
+  const out = [];
+  reqs.forEach((req, i) => {
+    const item = items[i];
+    if (!item) return;
+    const a = { key: req.key };
+    const c = complexityOf(get(jevQuestionId(item.id, "complexity")));
+    if (c) a.complexity = c;
+    const tier = choiceDist(
+      get(jevQuestionId(item.id, "tier")),
+      cat.tiers.map((t) => t.name)
+    );
+    if (tier) a.tier = tier;
+    const role = choiceDist(
+      get(jevQuestionId(item.id, "role")),
+      cat.roles.map((x) => x.name)
+    );
+    if (role) a.role = role;
+    const tool = choiceDist(
+      get(jevQuestionId(item.id, "tool")),
+      cat.tools.map((t) => t.name)
+    );
+    if (tool) a.tool = tool;
+    const risky = get(jevQuestionId(item.id, "risky"));
+    if (risky?.type === "noul") a.risky = risky.noul;
+    const plan = get(jevQuestionId(item.id, "needs_plan"));
+    if (plan?.type === "noul") a.needsPlan = plan.noul;
+    if (a.complexity || a.tier || a.role) out.push(a);
+  });
+  return out;
+}
+function complexityOf(a) {
+  if (a?.type !== "score") return void 0;
+  const levels = Object.keys(a.legend ?? {}).map(Number).filter(Number.isInteger);
+  const top = levels.length > 1 ? Math.max(...levels) : COMPLEXITY_CRITERIA.length - 1;
+  if (top <= 0 || a.score > top) return void 0;
+  return { value: a.score * 4 / top, confidence: a.confidence ?? 0.5 };
+}
+function choiceDist(a, options) {
+  if (a?.type !== "choice" || !options.includes(a.choice)) return void 0;
+  const probs = {};
+  let sum = 0;
+  for (const o of options) {
+    const p2 = a.probabilities?.[o];
+    if (p2 !== void 0 && p2 > 0) {
+      probs[o] = p2;
+      sum += p2;
+    }
+  }
+  if (sum <= 0)
+    return { probs: { [a.choice]: 1 }, confidence: a.confidence ?? 0.5, calibrated: true };
+  for (const o of Object.keys(probs)) probs[o] = (probs[o] ?? 0) / sum;
+  return { probs, confidence: a.confidence ?? probs[a.choice] ?? 0.5, calibrated: true };
+}
+
+// src/adjudicator/providers/index.ts
+var factories = /* @__PURE__ */ new Map([
+  ["typesafe", createTypesafeProvider],
+  ["openai-compatible", createOpenAIProvider]
+]);
+function createProvider(r, cfg, deps = {}) {
+  if (r.provider === "heuristic") return null;
+  const factory = factories.get(r.provider);
+  return factory ? factory(r, cfg, deps) : null;
+}
+
+// src/adjudicator/units.ts
+init_esm_shims();
+var UNIT_SURFACES = ["plan", "agent"];
+var UNIT_MAX = 40;
+var UNIT_CHARS = 4e3;
+var SATURATED_AT = 4;
+var UNITS_VERSION = "4";
+function unitScored(surface) {
+  return UNIT_SURFACES.includes(surface);
+}
+var FENCE2 = /```[\s\S]*?(?:```|$)/g;
+var TRACE_LINE = /^\s*(?:at\s.+:\d+(?::\d+)?\)?\s*$|at\s[\w$.<>[\] ]+\s\(.*\)\s*$|(?:[A-Z]\w*)?(?:Error|Exception)(?::|\s+\[)|File ".+", line \d+|Traceback \(most recent call last\)|(?:FAIL|PASS|ERR!|×|✗|✓|✔)\s|npm (?:ERR|WARN)|\[?\d{4}-\d\d-\d\d[T ]\d\d:\d\d)/;
+var MARKER = /^\s*(?:(?:[-*+•>]|#{1,6}|\d{1,3}[.)]|\[[ xX]\])\s+)*(?:\*\*|__)?/;
+var SENTENCE_END = /(?<=[.!?]|[.!?]["'”’)\]])\s+(?=\S)/;
+var ABBREV = /(?:^|[\s(])(?:e\.g|i\.e|vs|cf|approx|incl|esp|resp|viz|al|fig|eq|ref|sec|vol|ca)\.$/i;
+var WORDY = /[\p{L}\p{N}]/u;
+function statements(text) {
+  const s = text.slice(0, UNIT_CHARS);
+  const out = [];
+  let at = 0;
+  for (const m of s.matchAll(FENCE2)) {
+    const i = m.index ?? 0;
+    prose(s.slice(at, i), out);
+    pasted(m[0].trim(), out);
+    at = i + m[0].length;
+  }
+  prose(s.slice(at), out);
+  return out;
+}
+function pasted(block, out) {
+  if (!WORDY.test(block)) return;
+  const last = out.length - 1;
+  if (last >= 0) out[last] = `${out[last]}
+${block}`;
+  else out.push(block);
+}
+function prose(chunk, out) {
+  let trace = [];
+  const flush = () => {
+    if (trace.length) pasted(trace.join("\n"), out);
+    trace = [];
+  };
+  for (const line of chunk.split(/\r?\n/)) {
+    if (TRACE_LINE.test(line)) {
+      trace.push(line.trim());
+      continue;
+    }
+    flush();
+    const body = line.replace(MARKER, "").trim();
+    if (!WORDY.test(body)) continue;
+    let prev;
+    for (const piece of body.split(SENTENCE_END)) {
+      if (prev !== void 0 && ABBREV.test(prev)) {
+        prev = `${prev} ${piece}`;
+        continue;
+      }
+      if (prev !== void 0 && WORDY.test(prev)) out.push(prev);
+      prev = piece;
+    }
+    if (prev !== void 0 && WORDY.test(prev)) out.push(prev);
+  }
+  flush();
+}
+var CLAUSE = /;\s+|,?\s+(?:and\s+)?then\s+/;
+var CLAUSE_MAX = 400;
+var LEAD_IN = /^(?:(?:then|finally|also|and|afterwards|after that|next|lastly|last|please|always|first|at the end|once (?:done|finished|it passes|that passes)|when (?:you(?:'re| are) )?(?:done|finished)|before (?:you )?(?:report(?:ing)?|finish(?:ing)?|clos(?:e|ing)|commit(?:ting)?|hand(?:ing)? (?:it )?(?:back|off)))[\s,:;-]+)+/;
+var TOOL_CHECK = String.raw`(?:npm (?:run [\w:-]+|test|t|ci)|npx (?:tsc|vitest|biome|jest|eslint|prettier|mocha|playwright)(?: run)?|(?:pnpm|yarn)(?: run)? [\w:-]+|type-?check\w*|tsc|lint\w*|biome|eslint|prettier|vitest|jest|pytest|go (?:test|vet)|cargo (?:test|check|clippy))`;
+var CHECK = `(?:${TOOL_CHECK}|tests?|specs?|test ?suites?|suites?|build|ci)`;
+var CHECK_SUFFIX = String.raw`(?: (?:--?[\w-]+(?:=\S+)?|[\w@+-]*[./*:][\w./:@+*=-]*|only|again|too|first|alone|there|here|as well)){0,4}?`;
+var CHECK_ITEM = String.raw`(?:(?:the|all|all the) )?(?:(?!(?:add|write|create|update|fix|cover|extend|implement|change|remove|delete|rewrite|refactor|make|keep|test)\b)[\w./:@+*-]+ ){0,2}?${CHECK}${CHECK_SUFFIX}`;
+var ROUTINE_ITEM = `(?:(?:the|all|full|whole|entire) ){0,3}(?:${TOOL_CHECK}|test ?suites?|tests?|specs?|suites?|build|ci)`;
+var AT_PATH = String.raw`(?: (?:in|under) [\w@+-]*[./*][\w./:@+*=-]+)?`;
+var REPORT_NOUN = "generation|generator|rows?|pages?|builder|templates?|exports?|service|views?|endpoints?|api|jobs?|schema|module|component|card|tab|screen|quer(?:y|ies)|model|pdf|csv|ui|dashboard";
+var PASSES = "(?:pass(?:es)?|be green|stay green|succeed|exits? 0|exit cleanly|(?:is|are) clean)";
+var IS_GREEN = "(?:is|are) (?:all )?(?:clean|green)";
+var LIST_SEP2 = String.raw`\s*(?:,|\+|&&?|/|\band\b|\bor\b)\s*`;
+var checkList = (item, verdict, sep = LIST_SEP2) => new RegExp(
+  String.raw`^${item}(?:${sep}${item}){0,8}(?:\s+(?:must |should |all |still |both )*${verdict})?(?:\s+if [\w\s'-]{1,30})?\s*[.!]?$`
+);
+var CHECKS_ONLY = checkList(CHECK_ITEM, PASSES);
+var ROUTINE_CHECKS = checkList(
+  `${ROUTINE_ITEM}${AT_PATH}${CHECK_SUFFIX}`,
+  `(?:${PASSES}|${IS_GREEN})`,
+  String.raw`\s*(?:,\s*(?:and|or)\b|,|\+|&&?|/|\band\b|\bor\b)\s*`
+);
+var ROUTINE_GREEN = checkList(`${ROUTINE_ITEM}${CHECK_SUFFIX}`, IS_GREEN);
+var CHECK_LABEL = /^(?:(?:verification|verify|validation|validate|confirm|acceptance(?: criteria)?|checks?|gates?|definition of done|done when|tests?)\s*:\s*|(?:done (?:when|once|if)|finished when)\s+)/;
+var LABEL_ONLY = /^(?:verification|verify|validation|validate|confirm|acceptance(?: criteria)?|checks?|gates?|tests?|definition of done|done when|hand-?in|deliverables?)\s*:\s*$/;
+var PROTOCOL = [
+  // run the checks: "Run npm run typecheck, lint and the adjudicator tests"
+  new RegExp(
+    String.raw`^(?:re-?run|run|execute)\s+(?:(?:the|all|every|each|your|our|both|once|again|first|these|those|its|their)\s+)*(?:[\w./:@+*-]+\s+){0,3}?${CHECK}\b`
+  ),
+  // the checks must pass: "Make sure typecheck and lint still pass"
+  new RegExp(
+    String.raw`^(?:verify|check|confirm|ensure|make sure|double-check|keep)\b.{0,80}?\b${CHECK}\b.{0,60}?\b(?:pass(?:es|ing)?|green|succeed\w*|clean|still (?:pass|work)\w*)\b`
+  ),
+  // verify by the checks: "Verify with npm run build". The colon form ("Verify: npx tsc
+  // --noEmit") goes through CHECK_LABEL, where every item must be a routine check (review2 R2-3).
+  new RegExp(
+    String.raw`^(?:verify|check|confirm|validate|test)\s+(?:it |this |them |that |everything )?(?:with|using|by running|via)\s+(?:the |a )?${CHECK}\b`
+  ),
+  // reporting back: "Report the exact counts", "Report back (concise):"
+  new RegExp(String.raw`^report\b(?!\s+(?:${REPORT_NOUN})\b)`),
+  // closing the task: "Close the task with the counts", "End with a compact table"
+  /^(?:close|finish|complete|wrap up|end)\s+(?:(?:the|this|your|each|every)\s+)?(?:tasks?|it|them|each|with|up|run)\b/,
+  /^end (?:the |every |each |your |all )?(?:(?:pr|commit|reply|comment) )?(?:body|messages?|commits?|description|reply|comment|report)s? with\b/,
+  /^(?:co-authored-by|🤖 generated with)\b/,
+  // swarm protocol: "Claim it first: em_swarm {…}", "Mark it done with em_swarm update"; not a
+  // claim with the work after it ("Claim it, read …, review …", "Claim: the PR now returns …")
+  /^claim\b(?:[^:,]*|.*?[:(]\s*em_swarm\b.*)$/,
+  /^(?:mark|update|use)\b.{0,80}?\bem_swarm\s*(?:\{|update\b)/,
+  // handing results in: "Post the numbers to blackboard key X", "Put the counts in your update"
+  // (a short object, then where it goes: "Record baseline numbers for … and post them" is work)
+  /^(?:post|put|share|publish|include|give|state|list|record|log|leave|note|mention|summari[sz]e)\b(?:\s+\S+){0,12}?\s+(?:to|on|under|in|into|as|with|via|onto)\s+(?:the\s+|your\s+)?(?:blackboard|em_swarm|em_remember|(?:task\s+)?(?:update|result|results|report|final (?:message|report|answer)|reply|summary|hand-?off)\b|key\b)/,
+  // the shape of the answer: "Return: a verdict, then findings", "Lead with the outcome"
+  /^return(?:\s*:|\s+(?:in|as|only|at most|under|<=?)\s|\s+(?:(?:a|an|the|your)\s+)?(?:(?:dense|structured|short|concise|brief|compact|plain|one-line|final|markdown|json)\s+)*(?:report|summary|verdict|list|table|findings|results?|answer|overview)\b)/,
+  /^lead with\b/,
+  /^(?:test|check|lint|build|verify|verification) (?:commands?|steps?)\b/
+];
+var TAIL_LEAD = /(,?\s+and|\s+by|\s+after)\s+(?:then\s+)?([a-z][a-z-]*)\b/g;
+var WORK_VERBS = new Set(
+  "fix patch redesign rewrite refactor migrate implement reimplement repair resolve debug investigate diagnose port find add update upgrade downgrade convert replace remove delete rename move extract split merge introduce create write change modify wire integrate harden optimize optimise restructure rework swap adopt bump configure enable disable extend document deprecate encrypt sanitize secure address correct design".split(" ")
+);
+var REPAIR_VERB = new Set(
+  "fix fixing patch patching repair repairing resolve resolving debug debugging investigate investigating diagnose diagnosing find finding address addressing correct correcting".split(" ")
+);
+var NON_WORK_GERUND = /^(?:re-?running|running|executing|checking|re-?checking|verifying|confirming|ensuring|testing|re-?testing|linting|building|re-?building|type-?checking|reporting|posting|committing|pushing|claiming|closing|finishing|completing|marking|following|using|doing|making|keeping|passing|reading|looking|reviewing|editing|starting|getting|having|being|calling|invoking|merging|rebasing|pulling|fetching|installing|saving|switching)$/;
+var NOT_GERUND = /thing$|^(?:string|during|pending|morning|evening|ceiling|nothing|spring)$/;
+var ROUTINE_SUBJECT = "(?:it|they|you|tsc|eslint|biome|vitest|jest|lint|ci|the (?:linter|compiler|(?:type ?)?checker|tool|runner|build|ci|tsc|eslint|(?:(?:e2e|unit|integration|full|test) )?(?:tests?|specs?|suites?|test ?suites?)))";
+var REPORT_VERB = "(?:reports?|reported|finds?|found|prints?|shows?|says?|flags?|returns?|emits?|outputs?|surfaces?|raises?|raised|throws?|threw|fail(?:s|ed)?|breaks?)";
+var EMERGE = "(?:shows? up|comes? up|turns? up|pops? up|appears?|remains?|(?:is|are) (?:left|broken|failing|reported|flagged)|(?:get|gets|got) (?:reported|flagged)|(?:now|still) fail(?:s|ed)?|starts? failing|comes? back|you (?:see|find|hit)|needs? fixing|goes red|(?:doesn['\u2019]t|does not|don['\u2019]t|do not) pass)";
+var ROUTINE_OBJECT = new RegExp(
+  String.raw`^(?:\s+(?:up|out))?(?:\s+(?:any|all|the|every|each|those|these|its|their|your|whatever|remaining|new|resulting|reported|other))*(?:\s+(?:type|types|lint|linter|typecheck|tsc|eslint|compile|compiler|compilation|build|ci|test|unit|vitest|jest|failing|failed|broken|outstanding)){0,3}\s+(?:failures?|failing|fails|errors?|issues?|problems?|regressions?|breakages?|findings?|warnings?|complaints?|tests?|specs?|checks?|them|it|those|these|that|anything|everything|what(?:ever)?\s+(?:${ROUTINE_SUBJECT}\s+${REPORT_VERB}|fail(?:s|ed)?|breaks?|broke|errors?|${EMERGE}))(?:\s+(?:if any|as needed|as necessary|you find|found|reported|first|again|too|along the way|before (?:reporting|you report|finishing|you finish|handing in|you hand in|you are done|you're done|moving on)|(?:(?:that|which) (?:${ROUTINE_SUBJECT} )?|${ROUTINE_SUBJECT} )${REPORT_VERB}|(?:that|which) ${EMERGE}))?\s*[.!]?$`
+);
+var HANDIN_OBJECT = /\b(?:em_swarm|em_remember|blackboard)\b|\b(?:to|in|into|on|under)\s+(?:the\s+|your\s+)?(?:task\s+)?(?:update|result|results|report|final (?:message|report|answer)|reply|summary|hand-?off)\s*[.!]?$/;
+function workTail(clause) {
+  for (const m of clause.matchAll(TAIL_LEAD)) {
+    const verb = m[2];
+    const gerund = /^\w{3,}ing$/.test(verb) && !NON_WORK_GERUND.test(verb) && !NOT_GERUND.test(verb);
+    const work = m[1].endsWith("and") ? WORK_VERBS.has(verb) : gerund;
+    if (!work) continue;
+    const rest = clause.slice((m.index ?? 0) + m[0].length);
+    if (!/[\p{L}\p{N}]/u.test(rest)) continue;
+    if (HANDIN_OBJECT.test(rest)) continue;
+    if (REPAIR_VERB.has(verb) && ROUTINE_OBJECT.test(rest)) continue;
+    return true;
+  }
+  return false;
+}
+function boilerplateClause(clause) {
+  const lead = clause.toLowerCase().replace(/\*\*/g, "").replace(/^[\s("'“]+/, "").replace(LEAD_IN, "");
+  const c = lead.replace(/`/g, "").trim();
+  if (!c || c.length > CLAUSE_MAX) return false;
+  if (LABEL_ONLY.test(c)) return "step";
+  const rest = c.replace(CHECK_LABEL, "");
+  if (rest !== c) return ROUTINE_CHECKS.test(rest) ? "label" : false;
+  if (CHECKS_ONLY.test(c) || ROUTINE_GREEN.test(c)) return "step";
+  return !lead.startsWith("`") && PROTOCOL.some((re) => re.test(c)) && !workTail(c) ? "step" : false;
+}
+var CONTINUATION = /^\s*(?:(?:the|a|an|any|all|each|every|its|their|your|our|this|these|those|which|what|whether|how|findings|results|counts|numbers|verdict|summary|list|table)\b|(?:\S+\s+)?\S+\s*[.!]?\s*$)/i;
+function trimBoilerplate(statement) {
+  const clauses = statement.split(CLAUSE);
+  const drop = [];
+  let carry2 = false;
+  for (const c of clauses) {
+    const kind = boilerplateClause(c);
+    const continued = !kind && carry2 && CONTINUATION.test(c);
+    drop.push(!!kind || continued);
+    carry2 = kind === "step" || continued;
+  }
+  const kept = clauses.filter((_, i) => !drop[i]);
+  if (kept.length === clauses.length) return { kept: statement, removed: 0 };
+  return { kept: kept.join("; ").trim(), removed: clauses.length - kept.length };
+}
+function splitUnits(text) {
+  const units = [];
+  const seen = /* @__PURE__ */ new Set();
+  let dropped = 0;
+  for (const [i, s] of statements(text).entries()) {
+    const t = trimBoilerplate(s);
+    const unit = t.kept || (i === 0 ? s : "");
+    if (unit !== s) dropped += t.removed;
+    if (!unit) continue;
+    const key = unit.toLowerCase().replace(/\s+/g, " ");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    units.push(unit);
+  }
+  if (units.length <= UNIT_MAX) return { units, dropped, skipped: 0, tail: [] };
+  const tail = units.splice(UNIT_MAX - 1);
+  units.push(tail.join("\n"));
+  return { units, dropped, skipped: tail.length - 1, tail };
+}
+var EPS = 1e-9;
+var r23 = (n) => Math.round(n * 100) / 100;
+var sumOf = (reasons) => r23(reasons.reduce((s, r) => s + r.weight, 0));
+function scoreUnits(text, hints, weights = {}, catalogue = {}) {
+  const { units: parts, dropped, skipped, tail } = splitUnits(text);
+  if (parts.length <= 1 && dropped === 0 && statements(text).length <= 1) {
+    const features2 = extractFeatures(text.replace(MARKER, ""), hints);
+    const set2 = scoreHeuristic(features2, weights, catalogue);
+    const sum2 = sumOf(set2.complexityReasons);
+    return {
+      set: set2,
+      features: features2,
+      units: briefOf(parts.length, 0, skipped, 0, sum2, set2.role.confidence)
+    };
+  }
+  const features = extractFeatures(parts.join("\n"), hints);
+  const w = { ...DEFAULT_FEATURE_WEIGHTS, ...weights.features ?? {} };
+  const sum = sumOf(scoreComplexity(features, w).reasons);
+  const risks = [];
+  const score = (u) => {
+    const f = extractFeatures(u, hints);
+    risks.push(f.risk);
+    return scoreHeuristic(f, weights, catalogue);
+  };
+  const scoredParts = tail.length ? [...parts.slice(0, -1), ...tail] : parts;
+  const sets = scoredParts.map(score);
+  const win = hardest(sets, risks);
+  const top = sets[win];
+  const role = sets.length === 1 ? top.role : summed(
+    "role",
+    sets.map((s) => s.role),
+    roleOptions(catalogue),
+    top.role
+  );
+  const tool = sets.length === 1 ? top.tool : summed(
+    "tool",
+    sets.map((s) => s.tool),
+    toolOptions(catalogue),
+    top.tool
+  );
+  const set = {
+    complexity: top.complexity,
+    complexityReasons: top.complexityReasons,
+    tool,
+    tier: top.tier,
+    role,
+    effort: top.effort
+  };
+  return {
+    set,
+    features,
+    units: briefOf(sets.length, dropped, skipped, win, sum, role.confidence)
+  };
+}
+function hardest(sets, risks) {
+  let win = 0;
+  for (let i = 1; i < sets.length; i++) {
+    const c = sets[i].complexity;
+    const best = sets[win].complexity;
+    if (c > best + EPS || c > best - EPS && (risks[i] ?? 0) > (risks[win] ?? 0)) win = i;
+  }
+  return win;
+}
+function briefOf(scored, dropped, skipped, winner, sum, roleConfidence) {
+  return {
+    scored,
+    dropped,
+    skipped,
+    winner,
+    sum,
+    saturated: sum > SATURATED_AT,
+    roleConfidence: r23(roleConfidence)
+  };
+}
+function roleOptions(catalogue) {
+  return catalogue.roles?.length ? catalogue.roles.map((r) => r.name) : DEFAULT_ROLES;
+}
+function toolOptions(catalogue) {
+  const tools = catalogue.tools ?? TOOL_IDS;
+  return TOOL_IDS.filter((t) => tools.includes(t));
+}
+function summed(dimension, tables, options, fallback) {
+  const votes = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const t of tables)
+    for (const e of t.entries)
+      for (const r of e.reasons) {
+        if (r.feature === "fallback" || !(r.weight > 0)) continue;
+        total += r.weight;
+        let byReason = votes.get(e.option);
+        if (!byReason) {
+          byReason = /* @__PURE__ */ new Map();
+          votes.set(e.option, byReason);
+        }
+        const k = `${r.feature}
+${r.note}`;
+        const m = byReason.get(k);
+        if (m) {
+          m.weight += r.weight;
+          m.n++;
+        } else byReason.set(k, { ...r, n: 1 });
+      }
+  if (!(total > 0)) return fallback;
+  const raw = /* @__PURE__ */ new Map();
+  for (const [option, byReason] of votes) {
+    let s = 0;
+    const reasons = [];
+    for (const m of byReason.values()) {
+      s += m.weight;
+      reasons.push({
+        feature: m.feature,
+        weight: r23(m.weight),
+        note: m.n > 1 ? `${m.note} (${m.n} statements)` : m.note
+      });
+    }
+    reasons.sort((a, b) => b.weight - a.weight);
+    raw.set(option, { s, reasons });
+  }
+  return makeTable(dimension, options, raw, fallback.choice);
+}
+function briefUnitsOf(scores) {
+  if (!scores) return void 0;
+  try {
+    const u = JSON.parse(scores)?.units;
+    if (!u || typeof u !== "object") return void 0;
+    const o = u;
+    const n = (k) => {
+      const v = o[k];
+      return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+    };
+    const [scored, dropped, skipped, winner, sum, roleConfidence] = [
+      n("scored"),
+      n("dropped"),
+      n("skipped"),
+      n("winner"),
+      n("sum"),
+      n("roleConfidence")
+    ];
+    if (scored === void 0 || dropped === void 0 || winner === void 0 || sum === void 0 || roleConfidence === void 0 || typeof o.saturated !== "boolean")
+      return void 0;
+    return {
+      scored,
+      dropped,
+      skipped: skipped ?? 0,
+      winner,
+      sum,
+      saturated: o.saturated,
+      roleConfidence
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/adjudicator/engine.ts
+var PENDING_TTL_MS = 3e4;
+var CACHE_KEY_CHARS = 2e3;
+var PRUNE_EVERY = 100;
+var LOCK_WAIT_MAX_MS = 250;
+var LOCK_WAIT_FLOOR_MS = 25;
+function surfaceBudget(cfg, surface, local = false) {
+  const t = cfg.timeouts;
+  switch (surface) {
+    case "prompt":
+      return local ? t.localMs : t.promptMs;
+    case "agent":
+    case "tool":
+      return local ? t.localMs : t.agentMs;
+    default:
+      return t.planMs;
+  }
+}
+function byUnits(surface, units) {
+  return units !== false && unitScored(surface);
+}
+function stableJson(v) {
+  if (Array.isArray(v)) return `[${v.map(stableJson).join(",")}]`;
+  if (v && typeof v === "object") {
+    const o = v;
+    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${stableJson(o[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(v ?? null);
+}
+function cacheKeyFor(req, r, ctx = {}) {
+  const text = normalize(req.text).toLowerCase().replace(/\s+/g, " ").slice(0, CACHE_KEY_CHARS);
+  const h = req.hints;
+  const roles = h?.roles ?? ctx.roles;
+  const inputs = stableJson({
+    files: h?.files,
+    deps: h?.deps,
+    role: h?.role,
+    // Order does not change the scores; descriptions do (the heuristic matches on them).
+    roles: roles?.map((x) => ({ name: x.name, description: x.description ?? "" })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0),
+    // The docs names change the PKG rule (features.ts); a set, so order and repeats do not count.
+    libraries: h?.libraries ? [...new Set(h.libraries)].sort() : void 0,
+    tools: ctx.tools ? [...ctx.tools].sort() : void 0,
+    // The ladder is ordered, so its order stays.
+    tiers: ctx.config?.tiers,
+    weights: ctx.config?.weights,
+    // A brief scored per statement blends onto another heuristic than the same text scored whole.
+    units: byUnits(req.surface, ctx.units) ? UNITS_VERSION : void 0
+  });
+  return createHash3("sha256").update([SCORER_VERSION, r.configured, r.model ?? "", req.surface, inputs, text].join("|")).digest("hex");
+}
+function toolsOf(opts) {
+  return opts.tools ?? opts.deps?.tools;
+}
+function verdictColumns(v, o = {}) {
+  const u = v.usage;
+  const scores = {
+    complexity: v.complexity,
+    complexityReasons: v.complexityReasons,
+    tool: v.tool,
+    tier: v.tier,
+    role: v.role,
+    effort: v.effort,
+    features: o.features,
+    alpha: v.alpha,
+    bias: v.bias,
+    heuristicComplexity: v.heuristicComplexity,
+    units: o.units
+  };
+  return {
+    complexity: v.complexity,
+    tier: v.tier.choice,
+    effort: v.effort,
+    tool: v.tool.choice,
+    role: v.role.choice,
+    confidence: v.tier.confidence,
+    scores: JSON.stringify(scores),
+    source: v.source,
+    provider: v.provider,
+    providerModel: o.providerModel ?? null,
+    providerStatus: v.providerStatus,
+    latencyMs: Math.round(v.latencyMs),
+    providerLatencyMs: v.providerLatencyMs !== void 0 ? Math.round(v.providerLatencyMs) : null,
+    tokensIn: u ? u.inTok : null,
+    tokensOut: u ? u.outTok : null,
+    costUsd: u ? u.costUsd : null,
+    version: v.version
+  };
+}
+var statusOfDegraded = (r) => {
+  switch (r.degraded) {
+    case "no_key":
+      return "no_key";
+    case "no_consent":
+      return "no_consent";
+    case void 0:
+      return "n/a";
+    default:
+      return "skipped";
+  }
+};
+async function adjudicate(reqs, opts) {
+  const now = opts.now ?? Date.now;
+  const start = now();
+  const log = opts.log ?? (() => {
+  });
+  const items = [];
+  try {
+    const cfg = opts.config;
+    for (const [index, req] of reqs.entries()) items.push(prepare(req, index, opts));
+    if (!items.length) return [];
+    const enabled = cfg.enabled || opts.ignoreEnabled === true;
+    const r = opts.resolved ?? resolveAdjudicator(cfg, {
+      context: opts.context ?? "hook",
+      ...opts.env ? { env: opts.env } : {}
+    });
+    const store = opts.store;
+    const persist = !!store && (cfg.enabled ? opts.persist !== false : enabled && opts.persist === true);
+    const firstSurface = items[0]?.req.surface ?? "prompt";
+    const budgetMs = Math.max(0, opts.budgetMs ?? surfaceBudget(cfg, firstSurface, r.local));
+    const locks = new LockBudget(start + budgetMs, now);
+    const keyCtx = {
+      config: cfg,
+      tools: toolsOf(opts),
+      roles: opts.roles,
+      units: opts.units
+    };
+    for (const it of items) it.cacheKey = cacheKeyFor(it.req, r, keyCtx);
+    if (!enabled) {
+      for (const it of items) it.verdict = heuristicVerdict(it, "heuristic", "heuristic", "n/a");
+      return finish(items, opts, start, now, false, locks);
+    }
+    const useCache = r.configured !== "heuristic" && !!store;
+    if (useCache && store) {
+      const ttlMs = cfg.cache.ttlHours * 36e5;
+      for (const it of items) {
+        const hit = safe(
+          () => locks.run(store, 0, () => store.cacheGet(it.cacheKey, now(), ttlMs)),
+          log
+        );
+        if (!hit) continue;
+        if (hit.verdict) {
+          const { id: _id, usage: _usage, providerLatencyMs: _pl, ...cached2 } = hit.verdict;
+          it.verdict = { ...cached2, key: it.req.key, source: "cache" };
+        } else if (now() - hit.createdAt < PENDING_TTL_MS) {
+          it.pending = true;
+        }
+      }
+    }
+    const misses = items.filter((it) => !it.verdict);
+    if (!misses.length) return finish(items, opts, start, now, persist, locks);
+    const fallback = (status) => {
+      const source = r.configured === "heuristic" ? "heuristic" : "fallback";
+      for (const it of misses) it.verdict = heuristicVerdict(it, r.configured, source, status);
+      return finish(items, opts, start, now, persist, locks);
+    };
+    if (r.provider === "heuristic") return fallback(statusOfDegraded(r));
+    const call = opts.call ?? "inline";
+    if (call === "never") return fallback("skipped");
+    const provider = opts.provider !== void 0 ? opts.provider : safe(
+      () => createProvider(r, cfg, { log, env: opts.env, tools: opts.tools, ...opts.deps }),
+      log
+    );
+    if (!provider) return fallback("skipped");
+    const keyFp = safe(() => currentKeyFingerprint(r, opts.env), log) ?? null;
+    if (call === "async") {
+      const peek = store ? safe(() => peekGate(store, r, cfg, now(), keyFp), log) : void 0;
+      if (peek) return fallback(peek);
+      for (const it of misses) {
+        it.verdict = heuristicVerdict(it, r.configured, "fallback", "skipped");
+        if (it.pending) it.queued = true;
+        else it.job = buildJob(it, cfg, opts, budgetMs);
+      }
+      const out2 = finish(items, opts, start, now, persist, locks);
+      for (const [i, it] of items.entries()) {
+        if (!it.job) continue;
+        const a = out2[i];
+        if (a.rowId !== void 0) it.job.rowId = a.rowId;
+        const job = it.job;
+        const spawned = opts.spawn ? safe(() => opts.spawn?.(job), log) === true : false;
+        if (!opts.spawn) log("adjudicator: async call without a spawn function");
+        if (!spawned) continue;
+        a.queued = true;
+        if (store)
+          safe(
+            () => locks.run(store, 0, () => store.cachePut(it.cacheKey, null, r.configured, now())),
+            log
+          );
+      }
+      return out2;
+    }
+    let halfOpen = false;
+    if (store) {
+      const g = safe(
+        () => locks.guard(
+          () => gate(store, r.provider, cfg, {
+            now: now(),
+            remote: r.remote,
+            keyFingerprint: keyFp,
+            lockWaitMs: Math.floor(locks.wait() / 2)
+          })
+        ),
+        log
+      );
+      if (!g) {
+        log(`adjudicator: ${r.provider} gate unavailable; heuristic this call`);
+        return fallback("skipped");
+      }
+      if (!g.allow) return fallback(g.status);
+      halfOpen = g.halfOpen;
+    }
+    const remaining = budgetMs - (now() - start);
+    if (remaining <= 0) return fallback("timeout");
+    const sink = cfg.privacy.captureExchanges === true && r.provider === "typesafe" && store && (persist || !!opts.linkRowIds) && (opts.captureStillOn?.() ?? true) ? [] : void 0;
+    const callStart = now();
+    const outcome = await callWithin(
+      provider,
+      misses.map((it) => it.req),
+      remaining,
+      sink
+    );
+    const providerLatencyMs = now() - callStart;
+    const sample = !misses.some((it) => it.req.surface === "test");
+    if (!outcome.ok) {
+      const kind = outcome.kind;
+      log(`adjudicator: ${r.provider} ${kind}${outcome.status ? ` ${outcome.status}` : ""}`);
+      if (store)
+        record(
+          store,
+          r.provider,
+          now(),
+          log,
+          locks,
+          () => recordFailure(store, r.provider, cfg, {
+            now: now(),
+            kind,
+            status: outcome.status,
+            latencyMs: providerLatencyMs,
+            budgetMs,
+            halfOpen,
+            keyFingerprint: keyFp,
+            sample,
+            lockWaitMs: locks.wait(LOCK_WAIT_FLOOR_MS)
+          })
+        );
+      for (const it of misses) {
+        it.verdict = heuristicVerdict(it, r.provider, "fallback", kind);
+        it.verdict.providerLatencyMs = providerLatencyMs;
+      }
+      const failed = finish(items, opts, start, now, persist, locks);
+      if (sink && store) writeExchanges(store, sink, misses, failed, opts, start, budgetMs, locks);
+      return failed;
+    }
+    const res = outcome.result;
+    if (store)
+      record(
+        store,
+        r.provider,
+        now(),
+        log,
+        locks,
+        () => recordSuccess(store, r.provider, cfg, {
+          now: now(),
+          // The time this call measured, not what the provider reports: the budget governs
+          // the wall clock, and a provider cannot report itself slower or faster than it was.
+          latencyMs: providerLatencyMs,
+          costUsd: res.usage.costUsd,
+          budgetMs,
+          sample,
+          lockWaitMs: locks.wait(LOCK_WAIT_FLOOR_MS)
+        })
+      );
+    const byKey = /* @__PURE__ */ new Map();
+    for (const a of res.answers) if (!byKey.has(a.key)) byKey.set(a.key, a);
+    const answered = misses.filter((it) => byKey.has(it.req.key)).length;
+    const share = answered ? 1 / answered : 0;
+    const u = res.usage;
+    const usage = {
+      inTok: Math.round(u.inTok * share),
+      outTok: Math.round(u.outTok * share),
+      costUsd: u.costUsd === null ? null : u.costUsd * share
+    };
+    for (const it of misses) {
+      const answer = byKey.get(it.req.key);
+      if (!answer) {
+        it.verdict = heuristicVerdict(it, r.provider, "fallback", "skipped");
+        it.verdict.providerLatencyMs = providerLatencyMs;
+        continue;
+      }
+      it.verdict = blend(it.h, answer, it.bias, cfg.weights, {
+        key: it.req.key,
+        provider: r.provider,
+        providerStatus: "ok",
+        source: "blend",
+        tiers: cfg.tiers,
+        providerLatencyMs,
+        usage
+      });
+      it.providerModel = res.model || r.model;
+      if (store) {
+        const v = it.verdict;
+        safe(
+          () => locks.run(store, 0, () => store.cachePut(it.cacheKey, v, r.configured, now())),
+          log
+        );
+      }
+    }
+    if (store && answered && (opts.random ?? Math.random)() < answered / PRUNE_EVERY)
+      safe(
+        () => locks.run(
+          store,
+          0,
+          () => store.cachePrune(cfg.cache.maxEntries, cfg.cache.ttlHours * 36e5, now())
+        ),
+        log
+      );
+    const out = finish(items, opts, start, now, persist, locks);
+    if (sink && store) writeExchanges(store, sink, misses, out, opts, start, budgetMs, locks);
+    return out;
+  } catch (err) {
+    log(`adjudicator: engine error ${err?.message ?? String(err)}`);
+    for (const [index, req] of reqs.entries()) {
+      const it = items[index] ?? safePrepare(req, index, opts);
+      if (!it.verdict) it.verdict = heuristicVerdict(it, "heuristic", "heuristic", "n/a");
+      items[index] = it;
+    }
+    return items.map((it) => ({
+      request: it.req,
+      verdict: {
+        ...it.verdict,
+        latencyMs: now() - start,
+        heuristicComplexity: it.h.complexity
+      },
+      cacheKey: it.cacheKey,
+      features: it.features,
+      ...it.units ? { units: it.units } : {}
+    }));
+  }
+}
+async function adjudicateOne(req, opts) {
+  const [out] = await adjudicate([req], opts);
+  return out;
+}
+function prepare(req, index, opts) {
+  const cfg = opts.config;
+  const catalogue = { tiers: cfg.tiers };
+  const tools = toolsOf(opts);
+  if (tools) catalogue.tools = tools;
+  const roles = req.hints?.roles ?? opts.roles;
+  if (roles?.length) catalogue.roles = roles;
+  const weights = { tierCenters: cfg.weights.tierCenters, features: cfg.weights.features };
+  const brief = byUnits(req.surface, opts.units) ? scoreUnits(req.text, req.hints, weights, catalogue) : void 0;
+  const features = brief?.features ?? extractFeatures(req.text, req.hints);
+  const h = brief?.set ?? scoreHeuristic(features, weights, catalogue);
+  let bias = {};
+  if (cfg.learning.enabled && opts.bias)
+    bias = typeof opts.bias === "function" ? opts.bias(req, features, h) : opts.bias;
+  const it = { req, index, features, h, bias, cacheKey: "", cfg };
+  if (brief) it.units = brief.units;
+  return it;
+}
+function safePrepare(req, index, opts) {
+  try {
+    return prepare(req, index, { ...opts, bias: void 0 });
+  } catch {
+    const features = extractFeatures("", void 0);
+    const h = scoreHeuristic(features);
+    return { req, index, features, h, bias: {}, cacheKey: "" };
+  }
+}
+function heuristicVerdict(it, provider, source, status) {
+  return blend(it.h, void 0, it.bias, it.cfg?.weights ?? {}, {
+    tiers: it.cfg?.tiers ?? DEFAULT_TIERS,
+    key: it.req.key,
+    provider,
+    providerStatus: status,
+    source
+  });
+}
+function finish(items, opts, start, now, persist, locks) {
+  const log = opts.log ?? (() => {
+  });
+  const cfg = opts.config;
+  const latencyMs = now() - start;
+  return items.map((it) => {
+    const verdict = {
+      ...it.verdict,
+      latencyMs,
+      heuristicComplexity: it.h.complexity
+    };
+    const out = {
+      request: it.req,
+      verdict,
+      cacheKey: it.cacheKey,
+      features: it.features
+    };
+    if (it.queued) out.queued = true;
+    if (it.providerModel) out.providerModel = it.providerModel;
+    if (it.units) out.units = it.units;
+    if (persist && opts.store) {
+      const store = opts.store;
+      const cols = verdictColumns(verdict, {
+        features: it.features,
+        providerModel: it.providerModel,
+        units: it.units
+      });
+      const row = {
+        ...cols,
+        surface: it.req.surface,
+        inputHash: inputHash(it.req.text),
+        inputHead: cfg.privacy.storeHead ? head(it.req.text) : null,
+        inputChars: it.req.text.length,
+        ...opts.row,
+        ...opts.rows?.[it.index]
+      };
+      const id = safe(() => locks.run(store, LOCK_WAIT_FLOOR_MS, () => store.insert(row)), log);
+      if (id !== void 0) {
+        out.rowId = id;
+        verdict.id = id;
+      }
+    }
+    return out;
+  });
+}
+async function callWithin(provider, reqs, ms, capture) {
+  const ac = new AbortController();
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      ac.abort();
+      resolve({ ok: false, kind: "timeout" });
+    }, ms);
+    timer.unref?.();
+  });
+  const attempt = (async () => {
+    try {
+      const result = await provider.adjudicate(
+        reqs,
+        capture ? { signal: ac.signal, deadlineMs: ms, capture } : { signal: ac.signal, deadlineMs: ms }
+      );
+      return { ok: true, result };
+    } catch (err) {
+      if (err instanceof ProviderError) {
+        const o = { ok: false, kind: err.kind };
+        if (err.status !== void 0) o.status = err.status;
+        return o;
+      }
+      if (ac.signal.aborted || err?.name === "AbortError")
+        return { ok: false, kind: "timeout" };
+      return { ok: false, kind: "invalid" };
+    }
+  })();
+  try {
+    return await Promise.race([attempt, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function peekGate(store, r, cfg, now, keyFp) {
+  const s = store.providerState(r.provider);
+  if (!s) return void 0;
+  if (authLockout(s, now, keyFp)?.locked) return "auth_failed";
+  if ((s.state === "open" || s.state === "half_open") && s.retryAt !== null && now < s.retryAt)
+    return "breaker_open";
+  if (s.state === "slow" && s.retryAt !== null && now < s.retryAt) return "slow_guard";
+  if (r.remote && overBudget(s, cfg, now)) return "over_budget";
+  return void 0;
+}
+function buildJob(it, cfg, opts, budgetMs) {
+  const job = {
+    v: 1,
+    projectRoot: opts.projectRoot ?? process.cwd(),
+    request: it.req,
+    cacheKey: it.cacheKey,
+    config: cfg,
+    context: opts.context ?? "hook",
+    budgetMs: 2 * budgetMs,
+    bias: it.bias
+  };
+  const tools = toolsOf(opts);
+  if (tools) job.tools = [...tools];
+  if (opts.roles) job.roles = opts.roles.map((r) => ({ ...r }));
+  if (cfg.privacy.captureExchanges === true) job.queuedAt = (opts.now ?? Date.now)();
+  return job;
+}
+function writeExchanges(store, sink, misses, out, opts, start, budgetMs, locks) {
+  if (!sink.length) return;
+  const now = opts.now ?? Date.now;
+  const log = opts.log ?? (() => {
+  });
+  try {
+    if (opts.captureStillOn && !opts.captureStillOn()) return;
+    const rowsByKey = /* @__PURE__ */ new Map();
+    for (const it of misses) {
+      const id = out[it.index]?.rowId ?? opts.linkRowIds?.[it.index];
+      if (id === void 0) continue;
+      const ids = rowsByKey.get(it.req.key);
+      if (ids) ids.push(id);
+      else rowsByKey.set(it.req.key, [id]);
+    }
+    const callId = `${start.toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+    const t = now();
+    const xs = sink.map((pe) => {
+      const x = pe.http;
+      const pending = x.outcome === "pending";
+      const outcome = pending ? "timeout" : x.outcome;
+      const res = pending ? null : x.response;
+      return {
+        ts: x.sentAt,
+        callId,
+        batch: pe.batch,
+        provider: pe.provider,
+        model: pe.model,
+        surface: misses[0]?.req.surface ?? null,
+        context: opts.context ?? "hook",
+        method: x.method,
+        target: x.target,
+        rowIds: [...new Set(pe.itemKeys.flatMap((k) => rowsByKey.get(k) ?? []))],
+        items: pe.itemKeys.length,
+        outcome,
+        httpStatus: x.status,
+        timedOut: outcome === "timeout",
+        attempts: x.attempts,
+        waitMs: Math.max(0, x.sentAt - start),
+        jobWaitMs: opts.jobWaitMs ?? null,
+        ttfbMs: x.ttfbMs,
+        durationMs: pending ? Math.max(0, t - x.sentAt) : x.durationMs,
+        retryWaitMs: x.retryWaitMs,
+        deadlineMs: x.deadlineMs,
+        budgetMs,
+        tokensIn: pe.tokensIn,
+        tokensOut: pe.tokensOut,
+        costUsd: pe.costUsd,
+        requestBody: x.request.text,
+        requestBytes: x.request.bytes,
+        requestTruncated: x.request.truncated,
+        responseBody: res ? res.text : null,
+        responseBytes: res ? res.bytes : null,
+        responseTruncated: res ? res.truncated : false,
+        error: x.error
+      };
+    });
+    locks.run(store, 0, () => store.exchangeInsert(xs));
+  } catch (err) {
+    log(`adjudicator: exchange capture skipped (${err?.message ?? String(err)})`);
+  }
+}
+var LockBudget = class {
+  constructor(deadline, now) {
+    this.deadline = deadline;
+    this.now = now;
+  }
+  deadline;
+  now;
+  busy = false;
+  wait(floor = 0) {
+    if (this.busy) return floor;
+    return Math.max(floor, Math.min(LOCK_WAIT_MAX_MS, Math.floor(this.deadline - this.now())));
+  }
+  /** `fn`, noting a busy database before rethrowing its error. */
+  guard(fn) {
+    try {
+      return fn();
+    } catch (err) {
+      if (isBusy(err)) this.busy = true;
+      throw err;
+    }
+  }
+  /** `fn` with every lock wait capped at wait(floor). */
+  run(store, floor, fn) {
+    const ms = this.wait(floor);
+    return this.guard(() => bounded(store, ms, fn));
+  }
+};
+function isBusy(err) {
+  const code = err?.code;
+  if (typeof code === "string" && /^SQLITE_(BUSY|LOCKED)/.test(code)) return true;
+  return /database is (locked|busy)|SQLITE_BUSY/i.test(err?.message ?? "");
+}
+function bounded(store, ms, fn) {
+  return store.withLockWait ? store.withLockWait(ms, fn) : fn();
+}
+function record(store, provider, now, log, locks, fn) {
+  try {
+    locks.guard(fn);
+  } catch (err) {
+    const u = unrecorded(store, provider, now);
+    log(
+      `adjudicator: ${provider} breaker state not written (${err?.message ?? String(err)}); unrecorded today: ${u.calls} call(s), $${u.spendUsd.toFixed(6)}`
+    );
+  }
+}
+function safe(fn, log) {
+  try {
+    return fn();
+  } catch (err) {
+    log(`adjudicator: ${err?.message ?? String(err)}`);
+    return void 0;
+  }
+}
+
+// src/adjudicator/async.ts
+var ASYNC_JOB_MAX_MS = 3e4;
+function spawnAsyncJob(job, deps = {}) {
+  try {
+    const script = deps.script ?? process.argv[1];
+    if (!script) return false;
+    const child = (deps.spawn ?? nodeSpawn)(
+      deps.execPath ?? process.execPath,
+      [script, "--adjudicate"],
+      {
+        detached: true,
+        stdio: ["pipe", "ignore", "ignore"],
+        env: deps.env ?? process.env
+      }
+    );
+    child.on("error", () => {
+    });
+    child.stdin?.on("error", () => {
+    });
+    child.stdin?.end(JSON.stringify(job));
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseJob(raw) {
+  try {
+    const j = JSON.parse(raw);
+    const req = j?.request;
+    if (j?.v !== 1 || typeof j.projectRoot !== "string" || typeof j.cacheKey !== "string")
+      return void 0;
+    if (!req || typeof req.text !== "string" || typeof req.key !== "string") return void 0;
+    if (!SURFACES.includes(req.surface)) return void 0;
+    const config = AdjudicatorConfigSchema.safeParse(j.config);
+    if (!config.success) return void 0;
+    const budgetMs = typeof j.budgetMs === "number" && j.budgetMs > 0 ? j.budgetMs : 2400;
+    const context = j.context === "server" || j.context === "cli" ? j.context : "hook";
+    const job = {
+      v: 1,
+      projectRoot: j.projectRoot,
+      request: req,
+      cacheKey: j.cacheKey,
+      config: config.data,
+      context,
+      budgetMs: Math.min(budgetMs, ASYNC_JOB_MAX_MS - 1e3)
+    };
+    if (typeof j.rowId === "number") job.rowId = j.rowId;
+    if (j.bias && typeof j.bias === "object") job.bias = j.bias;
+    if (Array.isArray(j.tools)) job.tools = j.tools;
+    if (Array.isArray(j.roles)) job.roles = j.roles;
+    if (typeof j.queuedAt === "number" && Number.isFinite(j.queuedAt)) job.queuedAt = j.queuedAt;
+    return job;
+  } catch {
+    return void 0;
+  }
+}
+async function runAsyncJob(raw, deps = {}) {
+  const log = deps.log ?? (() => {
+  });
+  const childStart = (deps.now ?? Date.now)();
+  try {
+    const job = parseJob(raw);
+    if (!job) return { ok: false, reason: "invalid job" };
+    if (!job.config.enabled) return { ok: false, reason: "disabled" };
+    const store = deps.store ?? await openStore(job.projectRoot);
+    if (!store) return { ok: false, reason: "no store" };
+    const opts = {
+      config: job.config,
+      store,
+      context: job.context,
+      call: "inline",
+      budgetMs: job.budgetMs,
+      persist: false,
+      log
+    };
+    if (job.bias) opts.bias = job.bias;
+    if (job.tools) opts.tools = job.tools;
+    if (job.roles) opts.roles = job.roles;
+    if (deps.env) opts.env = deps.env;
+    if (deps.now) opts.now = deps.now;
+    if (deps.provider !== void 0) opts.provider = deps.provider;
+    if (deps.fetch) opts.deps = { fetch: deps.fetch };
+    if (job.rowId !== void 0) opts.linkRowIds = [job.rowId];
+    if (job.queuedAt !== void 0) opts.jobWaitMs = Math.max(0, childStart - job.queuedAt);
+    if (job.config.privacy.captureExchanges === true) {
+      opts.captureStillOn = () => captureStillOn(job.projectRoot);
+    }
+    const [out] = await adjudicate([job.request], opts);
+    if (!out) return { ok: false, reason: "no verdict" };
+    const v = out.verdict;
+    const res = { ok: true, source: v.source, providerStatus: v.providerStatus };
+    if (job.rowId !== void 0) {
+      try {
+        if (v.source === "blend" || v.source === "cache") {
+          const { latencyMs: _childLatency, ...cols } = verdictColumns(v, {
+            features: out.features,
+            providerModel: out.providerModel,
+            units: out.units
+          });
+          res.rowUpdated = store.update(job.rowId, cols);
+        } else {
+          res.rowUpdated = store.update(job.rowId, {
+            providerStatus: v.providerStatus,
+            providerLatencyMs: v.providerLatencyMs !== void 0 ? Math.round(v.providerLatencyMs) : null
+          });
+        }
+      } catch (err) {
+        log(`adjudicator: async row update failed: ${err.message}`);
+        res.rowUpdated = false;
+      }
+    }
+    return res;
+  } catch (err) {
+    log(`adjudicator: async job failed: ${err?.message ?? String(err)}`);
+    return { ok: false, reason: "error" };
+  }
+}
+function captureStillOn(projectRoot) {
+  try {
+    return loadConfig(projectRoot).adjudicator.privacy.captureExchanges === true;
+  } catch {
+    return false;
+  }
+}
+async function openStore(projectRoot) {
+  return getStorage(getContext(projectRoot), { vectors: false }).adjudicator;
+}
+
+export {
+  extractFeatures,
+  complexityBucket,
+  topIntent,
+  resolveAdjudicator,
+  briefUnitsOf,
+  cacheKeyFor,
+  adjudicateOne,
+  ASYNC_JOB_MAX_MS,
+  spawnAsyncJob,
+  parseJob,
+  runAsyncJob
+};
+//# sourceMappingURL=hook-chunk-RYZAFUTT.js.map