@chatpanel/events 0.102.0 → 0.103.1

package/recruit.js

@@ -1,457 +1,4 @@
-// Recruiting — applying and evaluating, the step between a posted job and a run (F8 §12.2.4,
-// architecture-pillars.md §13.4).
-//
-// Applications are COMPUTED, not asked for: every agent in the pool applies to every job at
-// once, scored by `fit` (scorecard.js) on its skills, tools, grants and its attested record —
-// the model-ADJUSTED rating when the engine rows say what its engines were worth. Recruiting
-// costs one model turn per job, not one per applicant, and that turn is optional.
-//
-// What is recruited is an (agent, engine) PAIR. An agent's engine may be fixed (`model`,
-// `harness`), the chat's (`assistant`), or `auto` with a policy; `routeFor` resolves it
-// against the ENGINE ROWS the host knows — every model or harness it can run, with reach,
-// capabilities, quality / latency / cost (the engine card's observed values over the router's
-// guess, `engineRow`) and whether it is available right now. Requirements eliminate first
-// (reach from the project's privacy setting — never learned, only typed; a work grant needs a
-// harness; tools need `tools`), the policy orders what survives over observed values, and the
-// agent's own record on each engine breaks ties. An agent whose engine does not clear is
-// still an applicant — a person should see it — but is not recruitable now.
-//
-// The EVALUATOR is one structured call (RECRUIT_SCHEMA) over the top applications: the pick
-// and why, or "none fits" with the agent that should exist. The call is the host's
-// (`runStructured` in a client; a gateway without a model skips it): `decide` takes its parsed
-// answer when there is one and falls back to the best fit above a floor when there is not, so
-// a job is recruited with or without a model. The decision lands on the project record as
-// events (`recruitEvents`) — the pick and the reasons on the job, a proposal as a decision a
-// person reads — never as a mutation.
-//
-// Pure, dependency-free; imports only what the gateway already vendors (scorecard.js,
-// model-ledger.js, engine.js, agent.js, job.js, team.js, structured.js, budget.js).
+import{fit as K,engineKey as j,normalizeEngine as E}from"./scorecard.js";import{cardOverride as G,DEFAULT_MIN_CALLS as J}from"./model-ledger.js";import{engineKeyOf as Y,describeEngine as T}from"./engine.js";import{engineOf as H,agentFromForm as X,normalizeAgent as Q,resolveTeam as V}from"./agent.js";import{applyAll as Z,jobToRole as ee}from"./job.js";import{WORK_GRANTS as A}from"./team.js";import{defineSchema as ne,describeSchema as te,coerce as se}from"./structured.js";import{normalizeBudget as ie}from"./budget.js";const q=.5,oe=5,ae=1500,I={device:0,trusted:1,any:2},B=e=>e!==null&&typeof e=="object"&&!Array.isArray(e),F=e=>e==null||!Number.isFinite(e)?null:Math.round(e*1e3)/1e3,k=(e,l)=>String(e||"").trim().slice(0,l),M=e=>(Array.isArray(e)?e:[]).map(l=>String(l).toLowerCase()),S=ne({name:"recruit",purpose:"which applicant gets the job, or that none fits and what agent should exist",fields:{pick:{type:"string",max:64,describe:'the id of the ONE applicant to recruit, or "" when none fits'},why:{type:"string",required:!0,max:400,describe:"one or two sentences a person reads on the job page"},confidence:{type:"number",describe:"0 to 1"},proposalName:{type:"string",max:60,describe:"when none fits: the agent that should exist"},proposalPurpose:{type:"string",max:300},proposalSkills:{type:"string[]",maxItems:12},proposalGrants:{type:"string[]",maxItems:8,describe:"from: data, web, history, mcp, shell, fs:write, scm:read, scm:push, scm:pr"}},nothing:{pick:"",why:"none fits"}});function _(e,{card:l=null,minCalls:t=J,jobKind:s=null}={}){if(!B(e))return null;const o=e;let a=o.engine?E(o.engine):null;if(!a){const d=String(o.model||o.id||"");if(!d)return null;if(o.kind==="bridge"||o.kind==="harness"||o.classUsed==="A"){const f=d.indexOf("/");a=f>0?{kind:"harness",id:d.slice(0,f),model:d.slice(f+1)}:{kind:"harness",id:d}}else a={kind:"model",id:d}}const r=j(a);if(!r)return null;const{override:i,observed:c}=G(l,{minCalls:t,jobKind:s}),n=new Set(l?.capabilities?.withdrawn||[]),h=[...new Set(M(o.capabilities))].filter(d=>!n.has(d));n.size&&M(o.capabilities).some(d=>n.has(d))&&c.push("capabilities");const p=d=>d==null||d===""||!Number.isFinite(Number(d))?null:Number(d),u=I[o.reach]!=null?o.reach:"any",g=i.costPer1k??p(o.costPer1k)??(u==="device"&&a.kind==="model"?0:null);return{key:r,engine:a,label:k(o.label||o.name||le(a),120),reach:u,capabilities:h,quality:i.quality??p(o.quality),latencyMs:i.latencyMs??p(o.latencyMs),costPer1k:g,costPerTask:p(l?.cost?.perTask),availability:p(l?.availability?.rate),available:i.available??(o.available!==!1&&o.usable!==!1),observed:c}}const le=e=>`${e.id}${e.model&&e.model!==e.id?`/${e.model}`:""}`;function Ne(e,{cards:l={},minCalls:t,jobKind:s}={}){const o=[],a=new Set;for(const r of Array.isArray(e)?e:[]){const i=_(r,{card:null,minCalls:t,jobKind:s});!i||a.has(i.key)||(a.add(i.key),o.push(l[i.key]?_(r,{card:l[i.key],minCalls:t,jobKind:s}):i))}return o}function L(e,{reach:l="any"}={}){const t=M(e?.needs?.grants).filter(c=>c!=="none"),s=M(e?.needs?.tools),o=t.some(c=>A.includes(c)),a=[],r=[];(s.length||t.length)&&(a.push("tools"),r.push("the job uses tools")),o&&r.push(`a work grant (${t.filter(c=>A.includes(c)).join(", ")}) needs an agent tool`);const i=I[l]!=null?l:"any";return i!=="any"&&r.push(`reach ≤ ${i} (the project's privacy setting)`),{capabilities:a,harness:o,reach:i,why:r}}const C=(e,l,t)=>{const s=[];e.available===!1&&s.push("unavailable right now"),I[e.reach]>I[l.reach]&&s.push(`reach ${e.reach} exceeds ${l.reach}`),l.harness&&e.engine.kind!=="harness"&&s.push("not an agent tool");const o=l.capabilities.filter(a=>!e.capabilities.includes(a));if(o.length&&!(e.engine.kind==="harness"&&o.every(a=>a==="tools"))&&s.push(`lacks ${o.join(", ")}`),t){const a=r=>(r||[]).some(i=>i===e.key||i===`${e.engine.kind}:${e.engine.id}`||i===e.engine.id||i===e.engine.model);t.allow?.length&&!a(t.allow)&&s.push("not on the policy's allow list"),t.deny?.length&&a(t.deny)&&s.push("on the policy's deny list"),t.floor?.quality!=null&&e.quality!=null&&e.quality<t.floor.quality&&s.push(`quality ${e.quality} under the floor ${t.floor.quality}`),t.floor?.availability!=null&&e.availability!=null&&e.availability<t.floor.availability&&s.push(`availability ${e.availability} under the floor ${t.floor.availability}`),t.ceiling?.costPerTask!=null&&e.costPerTask!=null&&e.costPerTask>t.ceiling.costPerTask&&s.push(`$${e.costPerTask}/task over the ceiling`),t.ceiling?.latencyMs!=null&&e.latencyMs!=null&&e.latencyMs>t.ceiling.latencyMs&&s.push(`${e.latencyMs} ms over the ceiling`)}return s},D=(e,l)=>(e?.byEngine||[]).find(t=>t.key===l)?.rating?.avg??null;function re(e,l,t){const s=n=>n.quality??.5,o=n=>n.costPerTask??n.costPer1k??null,a=Math.max(...e.map(n=>o(n)??0),0)||1,r=Math.max(...e.map(n=>n.latencyMs??0),0)||1,i=n=>{const h=D(t,n.key);return h==null?0:h-.5},c=n=>{switch(l){case"cheapest-that-clears":return-((o(n)??a)/a)+s(n)*.01;case"best-quality":return s(n)-(o(n)??a)/a*.01;case"fastest":return-((n.latencyMs??r)/r)+s(n)*.01;default:return s(n)*.5+(1-(o(n)??a)/a)*.25+(1-(n.latencyMs??r)/r)*.25}};return e.map(n=>({row:n,score:c(n)+i(n)*.05})).sort((n,h)=>h.score-n.score).map(n=>n.row)}const z=e=>`${e.key} (quality ${e.quality??"?"}${e.observed.includes("quality")?" observed":""}${e.costPerTask!=null?`, $${e.costPerTask}/task`:e.costPer1k!=null?`, $${e.costPer1k}/1k`:""}${e.latencyMs!=null?`, ${e.latencyMs} ms`:""})`;function ce(e,l,{rows:t=[],summary:s=null,need:o=null,reach:a="any",chatModel:r=null,explore:i=!1}={}){const c=o||L(l,{reach:a}),n=H(e,{chatModel:r}),h=Array.isArray(t)?t.filter(Boolean):[],p=m=>({engine:null,key:null,reasons:m,alternatives:[],exploration:!1,clears:!1});if(n.kind!=="auto"){const m=Y(n),v=h.find(x=>x.key===m)||h.find(x=>x.engine.kind===n.kind&&(n.kind==="harness"?x.engine.id===n.harnessId&&!n.model:(x.engine.id===n.model||x.engine.model===n.model)&&!n.providerId));if(!h.length)return{engine:E({kind:n.kind,id:n.kind==="harness"?n.harnessId:n.providerId||n.model,model:n.model}),key:m,reasons:[`${T(n)} — pinned by the agent; no roster to check it against`],alternatives:[],exploration:!1,clears:!0};if(!v)return p([`${T(n)} is pinned by the agent but is not installed or configured here`]);const R=C(v,c,null);return R.length?p([`${T(n)} is pinned by the agent but ${R.join("; ")}`]):{engine:v.engine,key:v.key,reasons:["pinned by the agent",...c.why],alternatives:[],exploration:!1,clears:!0}}if(!h.length)return p(["engine is auto and the roster is empty"]);const u=n.policy||{},g=[],d=h.filter(m=>{const $=C(m,c,u);return $.length&&g.push(`${m.key}: ${$.join("; ")}`),!$.length});if(!d.length)return p([`no engine clears ${c.harness?"an agent tool with ":""}${c.capabilities.join(", ")||"the requirements"}${c.reach!=="any"?` within reach ${c.reach}`:""}${u.prefer?` under ${u.prefer}`:""}`,...g.slice(0,4)]);const f=re(d,u.prefer||"balanced",s);let y=f[0],b=!1;const w=m=>m.costPerTask??m.costPer1k??null;if(i&&y.engine.kind!=="harness"){const m=f.filter($=>$.engine.kind!=="harness"&&w($)!=null&&w(y)!=null&&w($)<w(y)).sort(($,v)=>w(v)-w($));m.length&&(b=!0,y=m[0])}const N=[b?`exploration: one tier cheaper than the policy's pick (${f[0].key})`:`${(u.prefer||"balanced").replace(/-/g," ")}: ${z(y)}`,...c.why],O=D(s,y.key);return O!=null&&N.push(`this agent rated ${Math.round(O*100)}% on it before`),(u.floor?.quality!=null||u.ceiling?.costPerTask!=null||u.ceiling?.latencyMs!=null)&&N.push(`${d.length} of ${h.length} engines clear the policy`),{engine:y.engine,key:y.key,reasons:N,alternatives:f.filter(m=>m!==y).slice(0,4).map(m=>m.engine),exploration:b,clears:!0}}function ue(e){const l=new Map((e||[]).filter(Boolean).map(t=>[t.key,t]));return{qualityOf:t=>l.get(t)?.quality??null,costOf:t=>{const s=l.get(t);return s?s.costPerTask??null:null}}}function pe(e,l,{summaries:t={},rows:s=[],reach:o="any",chatModel:a=null,adjust:r=!0,now:i=Date.now()}={}){const c=L(e,{reach:o}),n=ue(s),h=(u,g,d)=>{const f=K(u,{...g,tools:g.tools||g.grants},d,r?n:{adjust:!1}),y=ce(g,u,{rows:s,summary:d,need:c,chatModel:a});return{score:f.score,reasons:[...f.reasons,...y.reasons].slice(0,8),...y.clears?{engine:y.engine}:{},covers:U(u,g)}},p=new Map((l||[]).map(u=>[u?.id,U(e,u)]));return Z(e,l,h,{cards:t,now:i}).map(u=>({...u,covers:p.get(u.agentId)!==!1}))}function U(e,l){const t=M(e?.needs?.skills);if(!t.length)return!0;const s=new Set(M(l?.skills));return t.some(o=>s.has(o))}function de(e,l,t=[],{rows:s=[],top:o=oe}={}){const a=new Map((t||[]).map(n=>[n.id,n])),r=new Map((s||[]).filter(Boolean).map(n=>[n.key,n])),i=e?.needs||{},c=(l||[]).slice(0,o).map(n=>{const h=a.get(n.agentId)||{},p=n.engine?j(n.engine):null,u=p?r.get(p):null;return`- ${n.agentId} (fit ${Math.round((n.fit||0)*100)}%)${h.purpose?` — ${k(h.purpose,160)}`:""}; skills: ${(h.skills||[]).join(", ")||"none"}; grants: ${(h.grants||[]).join(", ")||"none"}; ${p?`engine: ${u?z(u):p}`:"NOT RECRUITABLE NOW — no engine clears"}; ${(n.reasons||[]).slice(0,4).join("; ")}`});return[`You are the evaluator for the job "${k(e?.title,200)}" on project ${e?.projectId||"?"}. Recruit ONE applicant, or say none fits.`,`Brief: ${k(e?.brief,ae)}`,`Needs — skills: ${(i.skills||[]).join(", ")||"none named"}; tools: ${(i.tools||[]).join(", ")||"none named"}; grants: ${(i.grants||[]).join(", ")||"none"}${e?.budget?`; budget: ${Object.entries(e.budget).map(([n,h])=>`${h} ${n}`).join(", ")}`:""}.`,"","Applicants, best computed fit first (fit = the skills, tools and grants the job names, then the attested record, then size):",...c.length?c:["- (no one applied)"],"",'Rules: prefer the applicant that has what the job names and a record of clearing work like it on the engine shown; never pick one marked NOT RECRUITABLE NOW; a lower fit is right only when its reasons show the higher one lacks something the brief needs. When no applicant has the skills the job names, answer pick "" and propose the agent that should exist.',"",te(S)].join(`
+`)}function W(e,l=[]){const t=se(e,S);if(!t)return null;const s=t.value,o=String(s.pick||"").trim(),a=o?(l||[]).find(i=>i.agentId===o):null,r=s.proposalName?{name:k(s.proposalName,60),purpose:k(s.proposalPurpose,300),skills:(s.proposalSkills||[]).map(i=>k(i,80)).filter(Boolean),grants:(s.proposalGrants||[]).map(i=>k(i,64)).filter(Boolean)}:null;return a&&a.engine?{pick:o,why:k(s.why,400)||"the evaluator's pick",confidence:F(s.confidence),proposal:null}:{pick:"",why:a?`the evaluator picked ${o}, which no engine can run right now`:k(s.why,400)||"none fits",confidence:F(s.confidence),proposal:r}}function he(e,l,{evaluation:t=null,minFit:s=q}={}){const o=l||[];if(t&&t.pick){const i=o.find(c=>c.agentId===t.pick&&c.engine);if(i)return{kind:"recruit",agentId:i.agentId,engine:i.engine,fit:i.fit,why:t.why,by:"evaluator"}}if(t&&!t.pick)return{kind:"none",why:t.why,proposal:t.proposal||P(e),by:"evaluator"};const a=o.find(i=>i.engine&&i.covers!==!1);return a&&a.fit>=s?{kind:"recruit",agentId:a.agentId,engine:a.engine,fit:a.fit,why:`best fit (${Math.round(a.fit*100)}%): ${(a.reasons||[])[0]||"meets the needs"}`,by:"fit"}:{kind:"none",why:o.length?a?`the best fit is ${Math.round(a.fit*100)}%, under the ${Math.round(s*100)}% floor: ${(a.reasons||[]).find(i=>/missing/.test(i))||a.reasons?.[0]||""}`:o.some(i=>i.engine)?`no applicant has a skill the job names (${(e?.needs?.skills||[]).join(", ")})`:`${o.length} applied but no engine clears for any of them: ${(o[0].reasons||[]).find(i=>/engine|pinned|roster/.test(i))||"see the applications"}`:"no one in the pool applies to jobs",proposal:P(e),by:"fit"}}function P(e){const l=e?.needs||{};return{name:k(e?.title,60)||"New agent",purpose:`Does jobs like "${k(e?.title,80)}".`,skills:[...l.skills||[]],grants:(l.grants||[]).length?[...l.grants]:["none"]}}function ge(e,l,{by:t="evaluator"}={}){const s=e||P(l),o=new Set(["data","web","history","mcp",...A]),a=(s.grants||[]).map(r=>String(r).toLowerCase()).filter(r=>o.has(r)||/^mcp:/.test(r));return X({name:s.name,purpose:s.purpose,skills:s.skills,prompt:`You are ${s.name}. ${s.purpose||""}
 
-import { fit, engineKey, normalizeEngine } from './scorecard.js';
-import { cardOverride, DEFAULT_MIN_CALLS } from './model-ledger.js';
-import { normalizeEngineSpec, engineKeyOf, describeEngine } from './engine.js';
-import { engineOf, agentFromForm, normalizeAgent, resolveTeam } from './agent.js';
-import { applyAll, jobToRole } from './job.js';
-import { WORK_GRANTS } from './team.js';
-import { defineSchema, describeSchema, coerce } from './structured.js';
-import { normalizeBudget } from './budget.js';
-
-export const MIN_FIT = 0.5;
-export const TOP_APPLICANTS = 5;
-export const MAX_BRIEF_IN_PROMPT = 1500;
-const REACH_RANK = { device: 0, trusted: 1, any: 2 };
-
-const isRecord = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-const r3 = (v) => (v == null || !Number.isFinite(v) ? null : Math.round(v * 1000) / 1000);
-const clip = (s, n) => String(s || '').trim().slice(0, n);
-const lower = (xs) => (Array.isArray(xs) ? xs : []).map((x) => String(x).toLowerCase());
-
-// ── The evaluator's answer ────────────────────────────────────────────────────────────────
-
-export const RECRUIT_SCHEMA = defineSchema({
-  name: 'recruit',
-  purpose: 'which applicant gets the job, or that none fits and what agent should exist',
-  fields: {
-    // Not `required`: an emptied required field reads as "nothing" and would drop the proposal that rides beside it.
-    pick: { type: 'string', max: 64, describe: 'the id of the ONE applicant to recruit, or "" when none fits' },
-    why: { type: 'string', required: true, max: 400, describe: 'one or two sentences a person reads on the job page' },
-    confidence: { type: 'number', describe: '0 to 1' },
-    proposalName: { type: 'string', max: 60, describe: 'when none fits: the agent that should exist' },
-    proposalPurpose: { type: 'string', max: 300 },
-    proposalSkills: { type: 'string[]', maxItems: 12 },
-    proposalGrants: { type: 'string[]', maxItems: 8, describe: 'from: data, web, history, mcp, shell, fs:write, scm:read, scm:push, scm:pr' },
-  },
-  nothing: { pick: '', why: 'none fits' },
-});
-
-// ── Engine rows: what the host can run, as the recruiter reads it ─────────────────────────
-
-/**
- * One row from a host's candidate (a router model — `inferCandidate`'s shape: `id`, `model`,
- * `reach`, `capabilities`, `quality`, `latencyMs`, `costPer1k`, `available`, `classUsed`;
- * or anything carrying an `engine` ref) with its engine CARD applied: observed quality,
- * latency, cost and availability replace the guess where there is enough history, and a
- * withdrawn capability is gone. A bridge agent (`classUsed 'A'` / `kind 'bridge'`) is a
- * harness — `claude/opus` is the harness `claude` asked to run `opus` — keyed the way the
- * desktop's appointer and the engine ledger key it.
- */
-export function engineRow(candidate, { card = null, minCalls = DEFAULT_MIN_CALLS, jobKind = null } = {}) {
-  if (!isRecord(candidate)) return null;
-  const c = candidate;
-  let engine = c.engine ? normalizeEngine(c.engine) : null;
-  if (!engine) {
-    const name = String(c.model || c.id || '');
-    if (!name) return null;
-    if (c.kind === 'bridge' || c.kind === 'harness' || c.classUsed === 'A') {
-      const slash = name.indexOf('/');
-      engine = slash > 0 ? { kind: 'harness', id: name.slice(0, slash), model: name.slice(slash + 1) } : { kind: 'harness', id: name };
-    } else engine = { kind: 'model', id: name };
-  }
-  const key = engineKey(engine);
-  if (!key) return null;
-  const { override, observed } = cardOverride(card, { minCalls, jobKind });
-  const withdrawn = new Set(card?.capabilities?.withdrawn || []);
-  const capabilities = [...new Set(lower(c.capabilities))].filter((x) => !withdrawn.has(x));
-  if (withdrawn.size && lower(c.capabilities).some((x) => withdrawn.has(x))) observed.push('capabilities');
-  const num = (v) => (v == null || v === '' || !Number.isFinite(Number(v)) ? null : Number(v));
-  const reach = REACH_RANK[c.reach] != null ? c.reach : 'any';
-  // A model on this machine costs nothing per token — the router's own rule (`costOf`), kept
-  // here for a host that has no guess to offer; an unknown cost anywhere else stays unknown
-  // and orders as the dearest, so "we did not price it" never reads as "free".
-  const costPer1k = override.costPer1k ?? num(c.costPer1k) ?? (reach === 'device' && engine.kind === 'model' ? 0 : null);
-  return {
-    key,
-    engine,
-    label: clip(c.label || c.name || engineName(engine), 120),
-    reach,
-    capabilities,
-    quality: override.quality ?? num(c.quality),
-    latencyMs: override.latencyMs ?? num(c.latencyMs),
-    costPer1k,
-    costPerTask: num(card?.cost?.perTask),
-    availability: num(card?.availability?.rate),
-    available: override.available ?? (c.available !== false && c.usable !== false),
-    observed,
-  };
-}
-const engineName = (e) => `${e.id}${e.model && e.model !== e.id ? `/${e.model}` : ''}`;
-
-/** Rows from a host's candidates and the cards it holds (by key). */
-export function engineRows(candidates, { cards = {}, minCalls, jobKind } = {}) {
-  const out = []; const seen = new Set();
-  for (const c of Array.isArray(candidates) ? candidates : []) {
-    const row = engineRow(c, { card: null, minCalls, jobKind });
-    if (!row || seen.has(row.key)) continue;
-    seen.add(row.key);
-    out.push(cards[row.key] ? engineRow(c, { card: cards[row.key], minCalls, jobKind }) : row);
-  }
-  return out;
-}
-
-// ── What the job needs of an engine ───────────────────────────────────────────────────────
-
-/**
- * Requirements eliminate; they are never traded for cost or speed. A work grant (`shell`,
- * `fs:write`, `scm:*`) can only be exercised by a harness — a chat model has no shell. Tools
- * or any grant beyond `none` mean the turn may call tools. Reach is the project's privacy
- * ceiling, typed, never learned.
- */
-export function needForJob(job, { reach = 'any' } = {}) {
-  const grants = lower(job?.needs?.grants).filter((g) => g !== 'none');
-  const tools = lower(job?.needs?.tools);
-  const harness = grants.some((g) => WORK_GRANTS.includes(g));
-  const capabilities = [];
-  const why = [];
-  if (tools.length || grants.length) { capabilities.push('tools'); why.push('the job uses tools'); }
-  if (harness) why.push(`a work grant (${grants.filter((g) => WORK_GRANTS.includes(g)).join(', ')}) needs an agent tool`);
-  const r = REACH_RANK[reach] != null ? reach : 'any';
-  if (r !== 'any') why.push(`reach ≤ ${r} (the project's privacy setting)`);
-  return { capabilities, harness, reach: r, why };
-}
-
-// ── Routing: the engine for this agent on this job ────────────────────────────────────────
-
-const meets = (row, need, policy) => {
-  const why = [];
-  if (row.available === false) why.push('unavailable right now');
-  if (REACH_RANK[row.reach] > REACH_RANK[need.reach]) why.push(`reach ${row.reach} exceeds ${need.reach}`);
-  if (need.harness && row.engine.kind !== 'harness') why.push('not an agent tool');
-  const missing = need.capabilities.filter((c) => !row.capabilities.includes(c));
-  // A harness brings its own tools; the capability list of a bridge agent is the host's guess.
-  if (missing.length && !(row.engine.kind === 'harness' && missing.every((c) => c === 'tools'))) why.push(`lacks ${missing.join(', ')}`);
-  if (policy) {
-    const matches = (refs) => (refs || []).some((k) => k === row.key || k === `${row.engine.kind}:${row.engine.id}` || k === row.engine.id || k === row.engine.model);
-    if (policy.allow?.length && !matches(policy.allow)) why.push('not on the policy\'s allow list');
-    if (policy.deny?.length && matches(policy.deny)) why.push('on the policy\'s deny list');
-    if (policy.floor?.quality != null && row.quality != null && row.quality < policy.floor.quality) why.push(`quality ${row.quality} under the floor ${policy.floor.quality}`);
-    if (policy.floor?.availability != null && row.availability != null && row.availability < policy.floor.availability) why.push(`availability ${row.availability} under the floor ${policy.floor.availability}`);
-    if (policy.ceiling?.costPerTask != null && row.costPerTask != null && row.costPerTask > policy.ceiling.costPerTask) why.push(`$${row.costPerTask}/task over the ceiling`);
-    if (policy.ceiling?.latencyMs != null && row.latencyMs != null && row.latencyMs > policy.ceiling.latencyMs) why.push(`${row.latencyMs} ms over the ceiling`);
-  }
-  return why;
-};
-
-const ownRating = (summary, key) => (summary?.byEngine || []).find((r) => r.key === key)?.rating?.avg ?? null;
-
-/** Order the rows that clear by the policy's preference; the agent's own record on an engine breaks ties. */
-function orderByPolicy(rows, prefer, summary) {
-  const q = (r) => r.quality ?? 0.5;
-  const cost = (r) => r.costPerTask ?? r.costPer1k ?? null;
-  const maxCost = Math.max(...rows.map((r) => cost(r) ?? 0), 0) || 1;
-  const maxLat = Math.max(...rows.map((r) => r.latencyMs ?? 0), 0) || 1;
-  const own = (r) => { const v = ownRating(summary, r.key); return v == null ? 0 : v - 0.5; };
-  const score = (r) => {
-    switch (prefer) {
-      case 'cheapest-that-clears': return -((cost(r) ?? maxCost) / maxCost) + q(r) * 0.01;
-      case 'best-quality': return q(r) - ((cost(r) ?? maxCost) / maxCost) * 0.01;
-      case 'fastest': return -((r.latencyMs ?? maxLat) / maxLat) + q(r) * 0.01;
-      default: return q(r) * 0.5 + (1 - (cost(r) ?? maxCost) / maxCost) * 0.25 + (1 - (r.latencyMs ?? maxLat) / maxLat) * 0.25;
-    }
-  };
-  return rows.map((r) => ({ row: r, score: score(r) + own(r) * 0.05 })).sort((a, b) => b.score - a.score).map((x) => x.row);
-}
-
-const rowLine = (r) => `${r.key} (quality ${r.quality ?? '?'}${r.observed.includes('quality') ? ' observed' : ''}${r.costPerTask != null ? `, $${r.costPerTask}/task` : r.costPer1k != null ? `, $${r.costPer1k}/1k` : ''}${r.latencyMs != null ? `, ${r.latencyMs} ms` : ''})`;
-
-/**
- * The engine this agent would run this job on, and why — `{ engine, key, reasons,
- * alternatives, exploration, clears }`; `clears: false` (engine null) when nothing does, with
- * the reasons. `rows` are the host's `engineRows`; an empty roster trusts a fixed spec and
- * refuses `auto` (nothing to pick from). `explore` takes one tier cheaper than the policy's
- * pick when a cheaper row clears — the project loop's bounded exploration (§13.4); never for
- * a harness.
- */
-export function routeFor(agent, job, { rows = [], summary = null, need = null, reach = 'any', chatModel = null, explore = false } = {}) {
-  const n = need || needForJob(job, { reach });
-  const spec = engineOf(agent, { chatModel });
-  const list = Array.isArray(rows) ? rows.filter(Boolean) : [];
-  const none = (reasons) => ({ engine: null, key: null, reasons, alternatives: [], exploration: false, clears: false });
-  if (spec.kind !== 'auto') {
-    const key = engineKeyOf(spec);
-    const exact = list.find((r) => r.key === key);
-    // A harness card without a model matches any row of that harness; a model spec without a
-    // provider matches the row that runs that model anywhere.
-    const near = exact || list.find((r) => r.engine.kind === spec.kind && (spec.kind === 'harness' ? r.engine.id === spec.harnessId && !spec.model : (r.engine.id === spec.model || r.engine.model === spec.model) && !spec.providerId));
-    if (!list.length) return { engine: normalizeEngine({ kind: spec.kind, id: spec.kind === 'harness' ? spec.harnessId : (spec.providerId || spec.model), model: spec.model }), key, reasons: [`${describeEngine(spec)} — pinned by the agent; no roster to check it against`], alternatives: [], exploration: false, clears: true };
-    if (!near) return none([`${describeEngine(spec)} is pinned by the agent but is not installed or configured here`]);
-    const why = meets(near, n, null);
-    if (why.length) return none([`${describeEngine(spec)} is pinned by the agent but ${why.join('; ')}`]);
-    return { engine: near.engine, key: near.key, reasons: ['pinned by the agent', ...n.why], alternatives: [], exploration: false, clears: true };
-  }
-  if (!list.length) return none(['engine is auto and the roster is empty']);
-  const policy = spec.policy || {};
-  const rejected = [];
-  const cleared = list.filter((r) => { const why = meets(r, n, policy); if (why.length) rejected.push(`${r.key}: ${why.join('; ')}`); return !why.length; });
-  if (!cleared.length) return none([`no engine clears ${n.harness ? 'an agent tool with ' : ''}${n.capabilities.join(', ') || 'the requirements'}${n.reach !== 'any' ? ` within reach ${n.reach}` : ''}${policy.prefer ? ` under ${policy.prefer}` : ''}`, ...rejected.slice(0, 4)]);
-  const ordered = orderByPolicy(cleared, policy.prefer || 'balanced', summary);
-  let pick = ordered[0];
-  let exploration = false;
-  const cost = (r) => r.costPerTask ?? r.costPer1k ?? null;
-  if (explore && pick.engine.kind !== 'harness') {
-    const cheaper = ordered.filter((r) => r.engine.kind !== 'harness' && cost(r) != null && cost(pick) != null && cost(r) < cost(pick)).sort((a, b) => cost(b) - cost(a));
-    if (cheaper.length) { exploration = true; pick = cheaper[0]; }
-  }
-  const reasons = [
-    exploration ? `exploration: one tier cheaper than the policy's pick (${ordered[0].key})` : `${(policy.prefer || 'balanced').replace(/-/g, ' ')}: ${rowLine(pick)}`,
-    ...n.why,
-  ];
-  const own = ownRating(summary, pick.key);
-  if (own != null) reasons.push(`this agent rated ${Math.round(own * 100)}% on it before`);
-  if (policy.floor?.quality != null || policy.ceiling?.costPerTask != null || policy.ceiling?.latencyMs != null) reasons.push(`${cleared.length} of ${list.length} engines clear the policy`);
-  return { engine: pick.engine, key: pick.key, reasons, alternatives: ordered.filter((r) => r !== pick).slice(0, 4).map((r) => r.engine), exploration, clears: true };
-}
-
-// ── Applying: the whole pool at once ──────────────────────────────────────────────────────
-
-/** `qualityOf` / `costOf` for `adjustSummary`, read from the rows: what each engine is worth. */
-export function engineWorth(rows) {
-  const byKey = new Map((rows || []).filter(Boolean).map((r) => [r.key, r]));
-  return {
-    qualityOf: (key) => byKey.get(key)?.quality ?? null,
-    costOf: (key) => { const r = byKey.get(key); return r ? (r.costPerTask ?? null) : null; },
-  };
-}
-
-/**
- * Every eligible agent applies: `fit` (needs → adjusted record → size) plus the engine it
- * would run on. `summaries` are scorecard cards by agent id (`summarize()`); `rows` are
- * `engineRows`. Best first, recruitable (an engine clears) before not. Each application is
- * `{ agentId, engine?, fit, reasons, pitch, at, covers }` — job.js's shape, the record's, plus
- * `covers` (has a skill the job names) for `decide`; the record drops it.
- */
-export function applications(job, pool, { summaries = {}, rows = [], reach = 'any', chatModel = null, adjust = true, now = Date.now() } = {}) {
-  const need = needForJob(job, { reach });
-  const worth = engineWorth(rows);
-  const fitFn = (j, agent, summary) => {
-    const f = fit(j, { ...agent, tools: agent.tools || agent.grants }, summary, adjust ? worth : { adjust: false });
-    const route = routeFor(agent, j, { rows, summary, need, chatModel });
-    return { score: f.score, reasons: [...f.reasons, ...route.reasons].slice(0, 8), ...(route.clears ? { engine: route.engine } : {}), covers: coversSkills(j, agent) };
-  };
-  // `covers` — has at least one skill the job names (or the job names none) — rides on the
-  // live application for `decide`; the record keeps job.js's shape and drops it.
-  const covered = new Map((pool || []).map((a) => [a?.id, coversSkills(job, a)]));
-  return applyAll(job, pool, fitFn, { cards: summaries, now }).map((a) => ({ ...a, covers: covered.get(a.agentId) !== false }));
-}
-
-/** A job that names skills is not given to an agent with none of them on fit alone: tools and grants it never asked for count for nothing. */
-function coversSkills(job, agent) {
-  const want = lower(job?.needs?.skills);
-  if (!want.length) return true;
-  const has = new Set(lower(agent?.skills));
-  return want.some((s) => has.has(s));
-}
-
-// ── Evaluating: one structured call, or none ──────────────────────────────────────────────
-
-/** The evaluator's instruction: the job, the top applicants with their fit, engine and reasons, the shape to answer in. */
-export function evaluatorPrompt(job, apps, pool = [], { rows = [], top = TOP_APPLICANTS } = {}) {
-  const byId = new Map((pool || []).map((a) => [a.id, a]));
-  const rowOf = new Map((rows || []).filter(Boolean).map((r) => [r.key, r]));
-  const needs = job?.needs || {};
-  const lines = (apps || []).slice(0, top).map((a) => {
-    const agent = byId.get(a.agentId) || {};
-    const key = a.engine ? engineKey(a.engine) : null;
-    const row = key ? rowOf.get(key) : null;
-    return `- ${a.agentId} (fit ${Math.round((a.fit || 0) * 100)}%)${agent.purpose ? ` — ${clip(agent.purpose, 160)}` : ''}; skills: ${(agent.skills || []).join(', ') || 'none'}; grants: ${(agent.grants || []).join(', ') || 'none'}; ${key ? `engine: ${row ? rowLine(row) : key}` : 'NOT RECRUITABLE NOW — no engine clears'}; ${(a.reasons || []).slice(0, 4).join('; ')}`;
-  });
-  return [
-    `You are the evaluator for the job "${clip(job?.title, 200)}" on project ${job?.projectId || '?'}. Recruit ONE applicant, or say none fits.`,
-    `Brief: ${clip(job?.brief, MAX_BRIEF_IN_PROMPT)}`,
-    `Needs — skills: ${(needs.skills || []).join(', ') || 'none named'}; tools: ${(needs.tools || []).join(', ') || 'none named'}; grants: ${(needs.grants || []).join(', ') || 'none'}${job?.budget ? `; budget: ${Object.entries(job.budget).map(([k, v]) => `${v} ${k}`).join(', ')}` : ''}.`,
-    '',
-    'Applicants, best computed fit first (fit = the skills, tools and grants the job names, then the attested record, then size):',
-    ...(lines.length ? lines : ['- (no one applied)']),
-    '',
-    'Rules: prefer the applicant that has what the job names and a record of clearing work like it on the engine shown; never pick one marked NOT RECRUITABLE NOW; a lower fit is right only when its reasons show the higher one lacks something the brief needs. When no applicant has the skills the job names, answer pick "" and propose the agent that should exist.',
-    '',
-    describeSchema(RECRUIT_SCHEMA),
-  ].join('\n');
-}
-
-/**
- * The evaluator's answer, read through the schema and checked against the applications: a
- * pick must be a recruitable applicant, else it is "none". Returns `{ pick, why, confidence,
- * proposal }` or null when the text is unreadable.
- */
-export function parseEvaluation(text, apps = []) {
-  const got = coerce(text, RECRUIT_SCHEMA);
-  if (!got) return null;
-  const v = got.value;
-  const pick = String(v.pick || '').trim();
-  const app = pick ? (apps || []).find((a) => a.agentId === pick) : null;
-  const proposal = v.proposalName ? { name: clip(v.proposalName, 60), purpose: clip(v.proposalPurpose, 300), skills: (v.proposalSkills || []).map((s) => clip(s, 80)).filter(Boolean), grants: (v.proposalGrants || []).map((g) => clip(g, 64)).filter(Boolean) } : null;
-  if (app && app.engine) return { pick, why: clip(v.why, 400) || 'the evaluator\'s pick', confidence: r3(v.confidence), proposal: null };
-  return { pick: '', why: app ? `the evaluator picked ${pick}, which no engine can run right now` : clip(v.why, 400) || 'none fits', confidence: r3(v.confidence), proposal };
-}
-
-/**
- * The decision: the evaluator's when one was made; else the best recruitable fit at or above
- * `minFit`; else none, with the agent the job's needs describe as the proposal. Returns
- * `{ kind: 'recruit', agentId, engine, fit, why, by }` or `{ kind: 'none', why, proposal, by }`.
- */
-export function decide(job, apps, { evaluation = null, minFit = MIN_FIT } = {}) {
-  const list = apps || [];
-  if (evaluation && evaluation.pick) {
-    const app = list.find((a) => a.agentId === evaluation.pick && a.engine);
-    if (app) return { kind: 'recruit', agentId: app.agentId, engine: app.engine, fit: app.fit, why: evaluation.why, by: 'evaluator' };
-  }
-  if (evaluation && !evaluation.pick) return { kind: 'none', why: evaluation.why, proposal: evaluation.proposal || proposalFromNeeds(job), by: 'evaluator' };
-  const best = list.find((a) => a.engine && a.covers !== false);
-  if (best && best.fit >= minFit) return { kind: 'recruit', agentId: best.agentId, engine: best.engine, fit: best.fit, why: `best fit (${Math.round(best.fit * 100)}%): ${(best.reasons || [])[0] || 'meets the needs'}`, by: 'fit' };
-  const why = !list.length ? 'no one in the pool applies to jobs'
-    : !best ? (list.some((a) => a.engine) ? `no applicant has a skill the job names (${(job?.needs?.skills || []).join(', ')})` : `${list.length} applied but no engine clears for any of them: ${(list[0].reasons || []).find((r) => /engine|pinned|roster/.test(r)) || 'see the applications'}`)
-      : `the best fit is ${Math.round(best.fit * 100)}%, under the ${Math.round(minFit * 100)}% floor: ${(best.reasons || []).find((r) => /missing/.test(r)) || best.reasons?.[0] || ''}`;
-  return { kind: 'none', why, proposal: proposalFromNeeds(job), by: 'fit' };
-}
-
-/** The agent a job's needs describe — what to propose when no one fits. */
-export function proposalFromNeeds(job) {
-  const needs = job?.needs || {};
-  return { name: clip(job?.title, 60) || 'New agent', purpose: `Does jobs like "${clip(job?.title, 80)}".`, skills: [...(needs.skills || [])], grants: (needs.grants || []).length ? [...needs.grants] : ['none'] };
-}
-
-/**
- * A proposal as an agent card for a person to approve — validated by the pool's own form
- * (agentFromForm), engine `auto`, `createdBy: 'evaluator'`, its origin the job. Nothing
- * joins the pool without a decision (D-A2): this returns the card, it does not store it.
- */
-export function proposalToAgent(proposal, job, { by = 'evaluator' } = {}) {
-  const p = proposal || proposalFromNeeds(job);
-  const known = new Set(['data', 'web', 'history', 'mcp', ...WORK_GRANTS]);
-  const grants = (p.grants || []).map((g) => String(g).toLowerCase()).filter((g) => known.has(g) || /^mcp:/.test(g));
-  return agentFromForm({
-    name: p.name, purpose: p.purpose, skills: p.skills,
-    prompt: `You are ${p.name}. ${p.purpose || ''}\n\nYou were proposed for the job "${clip(job?.title, 200)}" because no agent in the pool fit it. Do work like it well; ask on the thread when the brief is unclear.`,
-    grants: grants.length ? grants : ['none'], engine: { kind: 'auto', prefer: 'balanced' }, appliesTo: ['jobs'], createdBy: by,
-    origin: { kind: 'proposal', projectId: job?.projectId, jobId: job?.id },
-  });
-}
-
-// ── Landing it on the record ──────────────────────────────────────────────────────────────
-
-/**
- * The budget a recruit gets: the job's own when it has one, else an equal share of what the
- * project has left (its budget minus its spend) across the jobs still to be recruited — so
- * one unbudgeted job cannot take the whole project. `record` is the project record
- * (project.js `foldProject`).
- */
-export function carveBudget(job, record = null) {
-  if (job?.budget && Object.keys(job.budget).length) return normalizeBudget(job.budget);
-  const cap = record?.page?.budget || {};
-  const spent = record?.spend || {};
-  const waiting = Math.max(1, (record?.jobs || []).filter((j) => ['open', 'evaluating'].includes(j.status)).length);
-  const out = {};
-  for (const k of ['tokens', 'calls', 'ms', 'usd']) {
-    if (!(Number(cap[k]) > 0)) continue;
-    const left = Math.max(0, Number(cap[k]) - (Number(spent[k]) || 0));
-    if (left > 0) out[k] = k === 'usd' ? Math.round((left / waiting) * 100) / 100 : Math.max(1, Math.floor(left / waiting));
-  }
-  return Object.keys(out).length ? out : null;
-}
-
-/**
- * The events that record a recruiting pass on the project (project.js fold): the job moves
- * to `evaluating` with its applications, then to `recruited` with the pair, the budget and
- * the why — or back to `open`, with the proposal as a decision a person reads.
- */
-export function recruitEvents(job, apps, decision, { by = 'evaluator', at = Date.now(), record = null } = {}) {
-  const events = [{ type: 'job.updated', at, job: { id: job.id, status: 'evaluating', applications: (apps || []).map(({ covers: _c, ...a }) => a) }, by }];
-  if (decision?.kind === 'recruit') {
-    const budget = carveBudget(job, record);
-    events.push({ type: 'job.updated', at, job: { id: job.id, status: 'recruited', recruited: { agentId: decision.agentId, engine: decision.engine, ...(budget ? { budget } : {}), by: decision.by || by, at, why: clip(decision.why, 600) } }, by });
-  } else {
-    events.push({ type: 'job.updated', at, job: { id: job.id, status: 'open' }, by });
-    const p = decision?.proposal;
-    events.push({ type: 'project.decision', at, by, kind: 'proposal', text: `No one in the pool fits "${clip(job.title, 120)}": ${clip(decision?.why, 400)}${p ? ` Proposed: ${p.name}${p.skills?.length ? ` — skills ${p.skills.join(', ')}` : ''}${p.grants?.length ? `; grants ${p.grants.join(', ')}` : ''}.` : ''}`, refs: [`job:${job.id}`] });
-  }
-  return events;
-}
-
-/**
- * One pass, end to end: apply → (evaluate) → decide → the events. `ask(prompt) → text |
- * null` is the host's structured call; absent or failing, the fit decides. Returns
- * `{ applications, evaluation, decision, events, prompt }`.
- */
-export async function recruitJob(job, pool, { summaries = {}, rows = [], reach = 'any', chatModel = null, record = null, ask = null, minFit = MIN_FIT, by = 'evaluator', now = Date.now() } = {}) {
-  const apps = applications(job, pool, { summaries, rows, reach, chatModel, now });
-  const prompt = evaluatorPrompt(job, apps, pool, { rows });
-  let evaluation = null;
-  if (ask && apps.some((a) => a.engine)) {
-    try { const text = await ask(prompt, RECRUIT_SCHEMA); evaluation = text == null ? null : (typeof text === 'string' ? parseEvaluation(text, apps) : parseEvaluation(JSON.stringify(text), apps)); } catch { evaluation = null; }
-  }
-  const decision = decide(job, apps, { evaluation, minFit });
-  return { applications: apps, evaluation, decision, events: recruitEvents(job, apps, decision, { by: decision.by === 'evaluator' ? by : 'fit', at: now, record }), prompt };
-}
-
-// ── A run's job board (§15.2): the host's `recruit` hook, shared ─────────────────────────
-
-/**
- * What a host hands the runner as `recruit`: one pass over the pool for a sub-task's job,
- * the pick made into a ROLE the run can appoint (job.js `jobToRole`, resolved through the
- * pool so it carries the agent's prompt, grants, skills and a model target — agent.js
- * `resolveTeam`). Returns `{ role, agentId, engine, why, fit, applications, events }` or,
- * when no one is recruited, `{ why, proposal, applications, events }` with `proposal` the
- * agent card a person may approve (the runner posts it). `create` is that card once
- * approved — the host has persisted it to its pool before calling — and it applies with
- * the rest. `events` are the project-record events of the pass (recruit.js `recruitEvents`)
- * for a host that has a project to land them on; the run's own record has its own.
- */
-export async function recruitForRun(job, pool, { rows = [], summaries = {}, reach = 'any', chatModel = null, targetFor = null, ask = null, minFit = MIN_FIT, create = null, now = Date.now() } = {}) {
-  const list = (Array.isArray(pool) ? pool : []).filter((a) => a && a.id);
-  if (create && isRecord(create)) {
-    try { const made = normalizeAgent(create); if (!list.some((a) => a.id === made.id)) list.push(made); } catch { /* an unusable card applies as nothing */ }
-  }
-  const pass = await recruitJob(job, list, { summaries, rows, reach, chatModel, ask, minFit, now });
-  const d = pass.decision;
-  if (d.kind !== 'recruit') {
-    const card = proposalToAgent(d.proposal || proposalFromNeeds(job), job, { by: d.by || 'evaluator' });
-    return { why: d.why, proposal: card?.ok === false ? null : (card?.agent || card), applications: pass.applications, events: pass.events };
-  }
-  const agent = list.find((a) => a.id === d.agentId);
-  const base = jobToRole(job, agent);
-  let role = { ...base, agent: agent.id, engine: d.engine };
-  try {
-    role = resolveTeam({ name: 'recruit', roles: [role], budget: { tokens: 1 } }, list, { chatModel, targetFor }).roles[0];
-  } catch { /* unresolved: the runner's appointer decides from the engine */ }
-  return { role, agentId: d.agentId, engine: d.engine, why: d.why, fit: d.fit ?? null, applications: pass.applications, events: pass.events };
-}
+You were proposed for the job "${k(l?.title,200)}" because no agent in the pool fit it. Do work like it well; ask on the thread when the brief is unclear.`,grants:a.length?a:["none"],engine:{kind:"auto",prefer:"balanced"},appliesTo:["jobs"],createdBy:t,origin:{kind:"proposal",projectId:l?.projectId,jobId:l?.id}})}function fe(e,l=null){if(e?.budget&&Object.keys(e.budget).length)return ie(e.budget);const t=l?.page?.budget||{},s=l?.spend||{},o=Math.max(1,(l?.jobs||[]).filter(r=>["open","evaluating"].includes(r.status)).length),a={};for(const r of["tokens","calls","ms","usd"]){if(!(Number(t[r])>0))continue;const i=Math.max(0,Number(t[r])-(Number(s[r])||0));i>0&&(a[r]=r==="usd"?Math.round(i/o*100)/100:Math.max(1,Math.floor(i/o)))}return Object.keys(a).length?a:null}function ye(e,l,t,{by:s="evaluator",at:o=Date.now(),record:a=null}={}){const r=[{type:"job.updated",at:o,job:{id:e.id,status:"evaluating",applications:(l||[]).map(({covers:i,...c})=>c)},by:s}];if(t?.kind==="recruit"){const i=fe(e,a);r.push({type:"job.updated",at:o,job:{id:e.id,status:"recruited",recruited:{agentId:t.agentId,engine:t.engine,...i?{budget:i}:{},by:t.by||s,at:o,why:k(t.why,600)}},by:s})}else{r.push({type:"job.updated",at:o,job:{id:e.id,status:"open"},by:s});const i=t?.proposal;r.push({type:"project.decision",at:o,by:s,kind:"proposal",text:`No one in the pool fits "${k(e.title,120)}": ${k(t?.why,400)}${i?` Proposed: ${i.name}${i.skills?.length?` — skills ${i.skills.join(", ")}`:""}${i.grants?.length?`; grants ${i.grants.join(", ")}`:""}.`:""}`,refs:[`job:${e.id}`]})}return r}async function me(e,l,{summaries:t={},rows:s=[],reach:o="any",chatModel:a=null,record:r=null,ask:i=null,minFit:c=q,by:n="evaluator",now:h=Date.now()}={}){const p=pe(e,l,{summaries:t,rows:s,reach:o,chatModel:a,now:h}),u=de(e,p,l,{rows:s});let g=null;if(i&&p.some(f=>f.engine))try{const f=await i(u,S);g=f==null?null:W(typeof f=="string"?f:JSON.stringify(f),p)}catch{g=null}const d=he(e,p,{evaluation:g,minFit:c});return{applications:p,evaluation:g,decision:d,events:ye(e,p,d,{by:d.by==="evaluator"?n:"fit",at:h,record:r}),prompt:u}}async function Te(e,l,{rows:t=[],summaries:s={},reach:o="any",chatModel:a=null,targetFor:r=null,ask:i=null,minFit:c=q,create:n=null,now:h=Date.now()}={}){const p=(Array.isArray(l)?l:[]).filter(b=>b&&b.id);if(n&&B(n))try{const b=Q(n);p.some(w=>w.id===b.id)||p.push(b)}catch{}const u=await me(e,p,{summaries:s,rows:t,reach:o,chatModel:a,ask:i,minFit:c,now:h}),g=u.decision;if(g.kind!=="recruit"){const b=ge(g.proposal||P(e),e,{by:g.by||"evaluator"});return{why:g.why,proposal:b?.ok===!1?null:b?.agent||b,applications:u.applications,events:u.events}}const d=p.find(b=>b.id===g.agentId);let y={...ee(e,d),agent:d.id,engine:g.engine};try{y=V({name:"recruit",roles:[y],budget:{tokens:1}},p,{chatModel:a,targetFor:r}).roles[0]}catch{}return{role:y,agentId:g.agentId,engine:g.engine,why:g.why,fit:g.fit??null,applications:u.applications,events:u.events}}export{ae as MAX_BRIEF_IN_PROMPT,q as MIN_FIT,S as RECRUIT_SCHEMA,oe as TOP_APPLICANTS,pe as applications,fe as carveBudget,he as decide,_ as engineRow,Ne as engineRows,ue as engineWorth,de as evaluatorPrompt,L as needForJob,W as parseEvaluation,P as proposalFromNeeds,ge as proposalToAgent,ye as recruitEvents,Te as recruitForRun,me as recruitJob,ce as routeFor};

package/redaction-tokens.js

@@ -1,61 +1 @@
-// Recognising a redaction placeholder — one predicate, and nothing else in the module.
-//
-// It is its own file for the reason `distance.js` is: three unrelated places need this
-// question answered — the subject resolver, the wikilink parser, and the extension's note
-// index — and the first two live in `entity.js`, which has since grown entity resolution,
-// merge suggestions and a Levenshtein dependency. Importing 25 KB of that into a notes page
-// to ask "is this string a placeholder" is the same 120 KB mistake in a smaller coat.
-
-/**
- * A REDACTION PLACEHOLDER IS NOT A SUBJECT — and this is the sharpest edge in the module.
- *
- * `@chatpanel/pii` writes `[[PERSON_1]]`, `[[EMAIL_2]]`, `[[LOCATION_1]]`, which is
- * character-for-character the `[[wikilink]]` grammar. So a redacted transcript reads as a
- * document full of links to pages that do not exist, and every one of them earned a "wanted
- * page" brief. The name of a person we deliberately did not learn was being filed as a thing
- * we know about.
- *
- * The tempting fix is to treat the token as a pseudonymous identity — it IS stable, and
- * within one conversation `PERSON_1` really does mean one person. It must not become a
- * subject anyway, because **the vault is scoped to a conversation**: `PERSON_1` in Monday's
- * chat and `PERSON_1` in Friday's are different people, and a global subject would merge
- * strangers under one page and attribute one person's decisions to another. That is the same
- * reason `aliasMap` refuses a bare token two people could claim — here it is guaranteed
- * rather than possible.
- *
- * So the placeholder is dropped from subject candidacy, and `curate.js` counts what was
- * dropped so the loss is REPORTED rather than silent. Never resolved against a vault into
- * anything derived and persisted, either: that would put the PII back on disk in a second
- * place, which is the one thing redaction exists to prevent.
- *
- * The pattern is duplicated from `@chatpanel/pii` rather than imported — this package ships
- * zero dependencies so the bridge can vendor it file by file, the same constraint that makes
- * the entitlement JWK live in two clients. `CLAUDE.md` lists `[[TYPE_n]]` as a wire contract
- * that only changes additively, and the extension (which vendors both) carries the drift
- * guard that fails when these two stop agreeing.
- */
-export const REDACTION_TOKEN_TYPES = Object.freeze([
-  'PERSON', 'ORG', 'LOCATION', 'ADDRESS', 'EMAIL', 'PHONE', 'ID', 'SSN', 'IBAN',
-  'CREDITCARD', 'CARD', 'POST', 'FAC', 'GROUP', 'NRP', 'ENTITY', 'KEY', 'SECRET',
-  'TERM', 'PII', 'OTHER',
-]);
-
-const BARE_TOKEN_RE = /^([A-Z][A-Z0-9]*)_\d+$/;
-const unwrap = (v) => String(v ?? '').trim().replace(/^\[{1,2}|\]{1,2}$/g, '');
-
-/**
- * Is this BARE string one of the redaction placeholders?
- *
- * Matched against the type vocabulary rather than the `[A-Z]+_\d+` shape, and everywhere —
- * inside brackets too. The shape alone eats real subjects: `[[Q3_2026]]` and `[[PHASE_2]]`
- * are links people genuinely write, and silently dropping them would trade one invisible bug
- * for another. A custom dictionary type is the accepted gap: it is user-chosen, so filing it
- * is a name the user picked, not a stranger's identity.
- *
- * Bracket-tolerant, because a wikilink parser has already stripped them by the time we ask,
- * and a model echoing a placeholder into JSON routinely mangles them.
- */
-export function isRedactionToken(value) {
-  const m = BARE_TOKEN_RE.exec(unwrap(value));
-  return !!m && REDACTION_TOKEN_TYPES.includes(m[1]);
-}
+const e=Object.freeze(["PERSON","ORG","LOCATION","ADDRESS","EMAIL","PHONE","ID","SSN","IBAN","CREDITCARD","CARD","POST","FAC","GROUP","NRP","ENTITY","KEY","SECRET","TERM","PII","OTHER"]),T=/^([A-Z][A-Z0-9]*)_\d+$/,n=E=>String(E??"").trim().replace(/^\[{1,2}|\]{1,2}$/g,"");function t(E){const R=T.exec(n(E));return!!R&&e.includes(R[1])}export{e as REDACTION_TOKEN_TYPES,t as isRedactionToken};

package/ref.js

@@ -1,55 +1 @@
-// References — how the log addresses content WITHOUT copying it.
-//
-// An event records "note n_88, lines 10-40, hash H" and never the text. Content that
-// actually entered a model request is written once into a content-addressed blob store
-// keyed by hash, so the same excerpt across a hundred turns costs one copy.
-//
-// Replay resolves a Ref by hash: match => exact reconstruction; blob absent or
-// crypto-shredded => VERIFIED_BUT_UNAVAILABLE. It never silently substitutes today's
-// version of the note, because that would make replay quietly wrong instead of loudly
-// incomplete.
-
-// `memory` and `brief` joined when the derived layer landed: a brief's claim cites the
-// record it came from, and a claim the USER stated cites the memory they stated it in.
-// Additive — no existing ref changes meaning.
-export const REF_KINDS = Object.freeze(['note', 'meeting', 'chat', 'page', 'result', 'blob', 'memory', 'brief']);
-
-export const RESOLUTION = Object.freeze({
-  EXACT: 'exact',                              // blob present, hash matches
-  UNAVAILABLE: 'verified-but-unavailable',     // we know what it was; we no longer hold it
-  DRIFTED: 'drifted',                          // source still exists but its hash changed
-});
-
-/** Build a Ref. `hash` is the content hash AT CAPTURE TIME — that is the whole point. */
-export function makeRef({ kind, id, hash, range = null, stored = false }) {
-  if (!REF_KINDS.includes(kind)) throw new TypeError(`ref: unknown kind ${kind}`);
-  if (typeof id !== 'string' || !id) throw new TypeError('ref: id required');
-  if (typeof hash !== 'string' || !hash) throw new TypeError('ref: hash required');
-  const ref = { kind, id, hash };
-  if (range) {
-    if (!Number.isInteger(range.from) || !Number.isInteger(range.to) || range.to < range.from) {
-      throw new TypeError('ref: range must be {from,to} integers with to >= from');
-    }
-    ref.range = { from: range.from, to: range.to };
-  }
-  if (stored) ref.stored = true;
-  return Object.freeze(ref);
-}
-
-export function isRef(v) {
-  return !!v && typeof v === 'object'
-    && REF_KINDS.includes(v.kind)
-    && typeof v.id === 'string' && v.id.length > 0
-    && typeof v.hash === 'string' && v.hash.length > 0;
-}
-
-/**
- * Classify what a replay can say about a Ref, given what the blob store holds now.
- * `lookup(ref) -> { hash } | null`. Pure: the caller owns the store.
- */
-export function resolveRef(ref, lookup) {
-  const got = lookup(ref);
-  if (!got) return { resolution: RESOLUTION.UNAVAILABLE, ref };
-  if (got.hash !== ref.hash) return { resolution: RESOLUTION.DRIFTED, ref, actualHash: got.hash };
-  return { resolution: RESOLUTION.EXACT, ref, value: got.value };
-}
+const f=Object.freeze(["note","meeting","chat","page","result","blob","memory","brief"]),i=Object.freeze({EXACT:"exact",UNAVAILABLE:"verified-but-unavailable",DRIFTED:"drifted"});function u({kind:e,id:o,hash:r,range:t=null,stored:s=!1}){if(!f.includes(e))throw new TypeError(`ref: unknown kind ${e}`);if(typeof o!="string"||!o)throw new TypeError("ref: id required");if(typeof r!="string"||!r)throw new TypeError("ref: hash required");const n={kind:e,id:o,hash:r};if(t){if(!Number.isInteger(t.from)||!Number.isInteger(t.to)||t.to<t.from)throw new TypeError("ref: range must be {from,to} integers with to >= from");n.range={from:t.from,to:t.to}}return s&&(n.stored=!0),Object.freeze(n)}function l(e){return!!e&&typeof e=="object"&&f.includes(e.kind)&&typeof e.id=="string"&&e.id.length>0&&typeof e.hash=="string"&&e.hash.length>0}function h(e,o){const r=o(e);return r?r.hash!==e.hash?{resolution:i.DRIFTED,ref:e,actualHash:r.hash}:{resolution:i.EXACT,ref:e,value:r.value}:{resolution:i.UNAVAILABLE,ref:e}}export{f as REF_KINDS,i as RESOLUTION,l as isRef,u as makeRef,h as resolveRef};