@chatpanel/events 0.101.0 → 0.103.1

package/invariants.js

@@ -1,174 +1 @@
-// The six invariants the replay harness asserts.
-//
-// These are what make the claims CHECKABLE rather than aspirational. An unverified
-// invariant decays silently, so each of these becomes a CI assertion the way the
-// `sync:pii --check` drift guard and the CSP assertion in build-editor.mjs already are.
-//
-//   I1  every model request is preceded by a context.assembled that reconstructs it
-//   I2  every byte leaving the device has a privacy.egress (controlled:false for agents)
-//   I3  every non-pure capability.invoked carries an idempotency key
-//   I4  every capability.revoked names its activated in causes
-//   I5  no durable event exists for a per-item ephemeral stream
-//   I6  replay under the linearization rule is stable across runs and across hosts
-//   I7  no assistant event carries content — only a Ref to it
-//
-// checkInvariants() returns violations rather than throwing, so a harness can report
-// every problem in one pass instead of one per run.
-
-import { linearize } from './order.js';
-import { isRef } from './ref.js';
-
-const v = (id, event, message) => ({ invariant: id, eventId: event ? event.id : null, message });
-
-/** I1 — a turn that ran must have assembled its context, and every resident Ref is hashed. */
-/**
- * I7 — an assistant event names its content, it never contains it.
- *
- * The temptation is obvious: inlining the text makes the trajectory view trivial. It also
- * makes the log a second copy of every conversation, so exporting the log exports the
- * user's data, and shredding a message leaves it readable in an append-only file forever.
- * Structural, not advisory: the checker fails on any payload field holding a long string,
- * because the failure it prevents is silent — everything keeps working, and privacy is
- * quietly gone.
- */
-function checkI7(events) {
-  const out = [];
-  const MAX = 200; // a model, a stop reason, a hash — never a message
-  for (const e of events) {
-    if (!String(e.type).startsWith('assistant.')) continue;
-    if (!isRef(e.payload?.ref)) out.push(v('I7', e, 'assistant event has no content Ref'));
-    for (const [k, val] of Object.entries(e.payload || {})) {
-      if (k !== 'ref' && typeof val === 'string' && val.length > MAX) {
-        out.push(v('I7', e, `payload.${k} carries ${val.length} chars of content — assistant events must reference, never contain`));
-      }
-    }
-  }
-  return out;
-}
-
-function checkI1(events) {
-  const out = [];
-  const assembledByTurn = new Set();
-  for (const e of events) {
-    if (e.type === 'context.assembled') {
-      if (e.payload.turnId) assembledByTurn.add(e.payload.turnId);
-      for (const r of e.payload.resident) {
-        if (!isRef(r)) out.push(v('I1', e, 'resident entry is not a valid Ref'));
-      }
-    }
-  }
-  for (const e of events) {
-    if (e.type === 'turn.ended' && e.payload.stepped !== false && !assembledByTurn.has(e.payload.turnId)) {
-      out.push(v('I1', e, `turn ${e.payload.turnId} ended with no context.assembled — model-visible input is not reconstructable`));
-    }
-  }
-  return out;
-}
-
-/** I2 — an invocation that egresses must produce a privacy.egress caused by it. */
-function checkI2(events) {
-  const out = [];
-  const egressCauses = new Set();
-  for (const e of events) {
-    if (e.type === 'privacy.egress') for (const c of e.causes) egressCauses.add(c);
-  }
-  for (const e of events) {
-    if (e.type === 'capability.invoked' && e.payload.egress && e.payload.egress !== 'none') {
-      if (!egressCauses.has(e.id)) {
-        out.push(v('I2', e, `invocation declares egress '${e.payload.egress}' but no privacy.egress references it`));
-      }
-    }
-  }
-  return out;
-}
-
-/** I3 — non-pure invocations carry an idempotency key. (Also enforced by validateEvent.) */
-function checkI3(events) {
-  return events
-    .filter((e) => e.type === 'capability.invoked'
-      && e.payload.effects !== 'pure'
-      && !e.payload.idempotencyKey)
-    .map((e) => v('I3', e, `'${e.payload.effects}' invocation without an idempotencyKey — a retry would repeat the side effect`));
-}
-
-/** I4 — a revoke names the activation it undoes. */
-function checkI4(events) {
-  const activated = new Map();
-  for (const e of events) if (e.type === 'capability.activated') activated.set(e.id, e);
-  return events
-    .filter((e) => e.type === 'capability.revoked' && !e.causes.some((c) => activated.has(c)))
-    .map((e) => v('I4', e, 'revoked does not name its activated in causes — the effect has no recorded inverse'));
-}
-
-/** I5 — ephemeral stream items never become durable facts. */
-function checkI5(events, { ephemeralBudget = 200 } = {}) {
-  const out = [];
-  const perTypePerHost = new Map();
-  for (const e of events) {
-    const k = `${e.host}:${e.type}:${e.payload.streamId || ''}`;
-    perTypePerHost.set(k, (perTypePerHost.get(k) || 0) + 1);
-  }
-  for (const [k, n] of perTypePerHost) {
-    if (k.split(':')[2] && n > ephemeralBudget) {
-      out.push(v('I5', null, `${n} durable events for stream ${k} — per-item stream data must be windowed, not logged`));
-    }
-  }
-  return out;
-}
-
-/** I6 — linearization is a function of the event SET, not of the input array's order. */
-function checkI6(events, { shuffles = 8, rng = mulberry32(0x5EED) } = {}) {
-  if (events.length < 2) return [];
-  const base = linearize(events).map((e) => e.id).join(',');
-  for (let i = 0; i < shuffles; i++) {
-    const shuffled = shuffle(events, rng);
-    if (linearize(shuffled).map((e) => e.id).join(',') !== base) {
-      return [v('I6', null, 'linearize() is order-dependent — replay is not deterministic')];
-    }
-  }
-  return [];
-}
-
-/** Run every invariant over an event set. Returns [] when the log is sound. */
-export function checkInvariants(events, opts = {}) {
-  return [
-    ...checkI7(events),
-    ...checkI1(events),
-    ...checkI2(events),
-    ...checkI3(events),
-    ...checkI4(events),
-    ...checkI5(events, opts),
-    ...checkI6(events, opts),
-  ];
-}
-
-export const INVARIANTS = Object.freeze({
-  I1: 'model-visible input is reconstructable from the log',
-  I2: 'every egress is recorded',
-  I3: 'non-pure invocations are idempotent',
-  I4: 'every activation has a recorded inverse',
-  I5: 'ephemeral streams never become durable facts',
-  I6: 'replay is deterministic',
-  I7: 'assistant events reference content, never contain it',
-});
-
-// Seeded PRNG so a failing I6 reproduces exactly — the package holds no ambient
-// dependency on Math.random.
-function mulberry32(seed) {
-  let a = seed >>> 0;
-  return () => {
-    a = (a + 0x6D2B79F5) >>> 0;
-    let t = Math.imul(a ^ (a >>> 15), 1 | a);
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-function shuffle(list, rng) {
-  const a = [...list];
-  for (let i = a.length - 1; i > 0; i--) {
-    const j = Math.floor(rng() * (i + 1));
-    [a[i], a[j]] = [a[j], a[i]];
-  }
-  return a;
-}
+import{linearize as i}from"./order.js";import{isRef as c}from"./ref.js";const s=(o,t,n)=>({invariant:o,eventId:t?t.id:null,message:n});function d(o){const t=[];for(const e of o)if(String(e.type).startsWith("assistant.")){c(e.payload?.ref)||t.push(s("I7",e,"assistant event has no content Ref"));for(const[r,a]of Object.entries(e.payload||{}))r!=="ref"&&typeof a=="string"&&a.length>200&&t.push(s("I7",e,`payload.${r} carries ${a.length} chars of content — assistant events must reference, never contain`))}return t}function l(o){const t=[],n=new Set;for(const e of o)if(e.type==="context.assembled"){e.payload.turnId&&n.add(e.payload.turnId);for(const r of e.payload.resident)c(r)||t.push(s("I1",e,"resident entry is not a valid Ref"))}for(const e of o)e.type==="turn.ended"&&e.payload.stepped!==!1&&!n.has(e.payload.turnId)&&t.push(s("I1",e,`turn ${e.payload.turnId} ended with no context.assembled — model-visible input is not reconstructable`));return t}function u(o){const t=[],n=new Set;for(const e of o)if(e.type==="privacy.egress")for(const r of e.causes)n.add(r);for(const e of o)e.type==="capability.invoked"&&e.payload.egress&&e.payload.egress!=="none"&&(n.has(e.id)||t.push(s("I2",e,`invocation declares egress '${e.payload.egress}' but no privacy.egress references it`)));return t}function p(o){return o.filter(t=>t.type==="capability.invoked"&&t.payload.effects!=="pure"&&!t.payload.idempotencyKey).map(t=>s("I3",t,`'${t.payload.effects}' invocation without an idempotencyKey — a retry would repeat the side effect`))}function y(o){const t=new Map;for(const n of o)n.type==="capability.activated"&&t.set(n.id,n);return o.filter(n=>n.type==="capability.revoked"&&!n.causes.some(e=>t.has(e))).map(n=>s("I4",n,"revoked does not name its activated in causes — the effect has no recorded inverse"))}function h(o,{ephemeralBudget:t=200}={}){const n=[],e=new Map;for(const r of o){const a=`${r.host}:${r.type}:${r.payload.streamId||""}`;e.set(a,(e.get(a)||0)+1)}for(const[r,a]of e)r.split(":")[2]&&a>t&&n.push(s("I5",null,`${a} durable events for stream ${r} — per-item stream data must be windowed, not logged`));return n}function m(o,{shuffles:t=8,rng:n=I(24301)}={}){if(o.length<2)return[];const e=i(o).map(r=>r.id).join(",");for(let r=0;r<t;r++){const a=b(o,n);if(i(a).map(f=>f.id).join(",")!==e)return[s("I6",null,"linearize() is order-dependent — replay is not deterministic")]}return[]}function k(o,t={}){return[...d(o),...l(o),...u(o),...p(o),...y(o),...h(o,t),...m(o,t)]}const $=Object.freeze({I1:"model-visible input is reconstructable from the log",I2:"every egress is recorded",I3:"non-pure invocations are idempotent",I4:"every activation has a recorded inverse",I5:"ephemeral streams never become durable facts",I6:"replay is deterministic",I7:"assistant events reference content, never contain it"});function I(o){let t=o>>>0;return()=>{t=t+1831565813>>>0;let n=Math.imul(t^t>>>15,1|t);return n=n+Math.imul(n^n>>>7,61|n)^n,((n^n>>>14)>>>0)/4294967296}}function b(o,t){const n=[...o];for(let e=n.length-1;e>0;e--){const r=Math.floor(t()*(e+1));[n[e],n[r]]=[n[r],n[e]]}return n}export{$ as INVARIANTS,k as checkInvariants};

package/job.js

@@ -1,149 +1,5 @@
-// A job — a posting on a project's board that the pool applies to.
-//
-// The executive posts the first jobs; a recruited agent posts more when the work needs more
-// hands, a skill or a tool it does not have; a person posts one by hand. A job says what it
-// needs (skills, tools, grants), what it may cost (carved from the project's budget), and
-// where the work happens (a repo and a base branch — the bridge gives it a worktree). Agents
-// in the pool APPLY by construction (recruit.js scores every type at once); an evaluator
-// picks; the pick is recruited with a budget and the job becomes a role on a run.
-//
-// A job's status is a machine: open → evaluating → recruited → in-progress → done | failed,
-// with withdrawn from any of the first three. Every move is an event on the project's
-// record (project.js foldProject: `job.posted`, `job.updated`).
+import{validateBudget as k,normalizeBudget as c}from"./budget.js";import{GRANT_RE as g}from"./team.js";const b=/^[a-z][a-z0-9_-]{0,63}$/i,l=Object.freeze(["open","evaluating","recruited","in-progress","done","failed","withdrawn"]),y=Object.freeze({open:["evaluating","recruited","withdrawn"],evaluating:["recruited","open","withdrawn"],recruited:["in-progress","open","withdrawn"],"in-progress":["done","failed","open"],done:[],failed:["open"],withdrawn:["open"]}),u=24,f=64;class m extends Error{constructor(t,n){super(n),this.name="JobError",this.code=t}}const a=e=>e!==null&&typeof e=="object"&&!Array.isArray(e),r=(e,t)=>String(e||"").trim().slice(0,t),p=(e,t,n)=>[...new Set((Array.isArray(e)?e:typeof e=="string"?e.split(/[,\s]+/):[]).map(i=>r(i,t)).filter(Boolean))].slice(0,n);function h(e){const t=[];if(!a(e))return{ok:!1,errors:["job must be an object"]};if(b.test(String(e.id||""))||t.push("id: a short identifier (letters, digits, _ -)"),b.test(String(e.projectId||""))||t.push("projectId: the project this job belongs to"),r(e.title,200)||t.push("title: what the job is"),r(e.brief,8e3)||t.push("brief: what to do, what done looks like"),e.needs!==void 0)if(!a(e.needs))t.push("needs: { skills[], tools[], grants[] }");else{const n=(Array.isArray(e.needs.grants)?e.needs.grants:[]).filter(i=>!g.test(String(i)));n.length&&t.push(`needs.grants: not grantable: ${n.join(", ")}`)}if(e.budget!==void 0){const n=k(e.budget);n.ok||t.push(...n.errors.map(i=>`budget: ${i}`))}return e.status!==void 0&&!l.includes(e.status)&&t.push(`status: one of ${l.join(", ")}`),e.dependsOn!==void 0&&!Array.isArray(e.dependsOn)&&t.push("dependsOn: a list of job ids"),e.workspace!==void 0&&e.workspace!==null&&!a(e.workspace)&&t.push("workspace: { repoId, base, branch? }"),e.deadline!==void 0&&e.deadline!==null&&!Number.isFinite(Number(e.deadline))&&t.push("deadline: a time"),{ok:t.length===0,errors:t}}function w(e){const t=h(e);if(!t.ok)throw new m("INVALID",t.errors.join("; "));return{id:String(e.id),projectId:String(e.projectId),title:r(e.title,200),brief:r(e.brief,8e3),needs:{skills:p(e.needs?.skills,80,u),tools:p(e.needs?.tools,120,u),grants:p(e.needs?.grants,64,u).filter(n=>g.test(n))},...e.budget?{budget:c(e.budget)}:{},size:{steps:Math.max(0,Math.round(Number(e.size?.steps)||0))},status:l.includes(e.status)?e.status:"open",postedBy:r(e.postedBy,80)||"person",postedAt:Number(e.postedAt)||Date.now(),...e.deadline?{deadline:Number(e.deadline)}:{},dependsOn:p(e.dependsOn,64,32).filter(n=>n!==e.id),...e.workspace?{workspace:{repoId:r(e.workspace.repoId,120),base:r(e.workspace.base,120)||"main",...e.workspace.branch?{branch:r(e.workspace.branch,200)}:{},...e.workspace.worktreePath?{worktreePath:r(e.workspace.worktreePath,400)}:{}}}:{},applications:Array.isArray(e.applications)?e.applications.slice(0,f).map(A).filter(Boolean):[],...e.recruited?{recruited:I(e.recruited)}:{},...e.runId?{runId:String(e.runId)}:{},...e.result?{result:{text:r(e.result.text,8e3),by:r(e.result.by,80),at:Number(e.result.at)||Date.now(),...Array.isArray(e.result.refs)?{refs:e.result.refs.slice(0,12)}:{}}}:{},...e.origin&&a(e.origin)?{origin:{...e.origin}}:{}}}function A(e){return!a(e)||!e.agentId?null:{agentId:String(e.agentId),...e.engine?{engine:e.engine}:{},fit:Math.max(0,Math.min(1,Number(e.fit)||0)),reasons:Array.isArray(e.reasons)?e.reasons.map(t=>r(t,200)).slice(0,8):[],pitch:r(e.pitch,600),at:Number(e.at)||Date.now()}}function I(e){return{agentId:String(e.agentId),...e.engine?{engine:e.engine}:{},...e.budget?{budget:c(e.budget)}:{},by:r(e.by,80)||"evaluator",at:Number(e.at)||Date.now(),...e.why?{why:r(e.why,600)}:{}}}function N(e){return Object.freeze(w(e))}function S(e,t){return(y[e]||[]).includes(t)}function x(e,t,n,{cards:i={},now:d=Date.now()}={}){return(t||[]).filter(s=>s&&s.enabled!==!1&&(s.appliesTo||["jobs"]).includes("jobs")).map(s=>{const o=n(e,s,i[s.id]||null);return{agentId:s.id,...o.engine?{engine:o.engine}:{},fit:o.score,reasons:o.reasons,pitch:"",at:d}}).sort((s,o)=>!!o.engine-!!s.engine||o.fit-s.fit).slice(0,f)}function B(e,t){return{id:t?.id||e.id,agent:t?.id,name:t?.name||e.title,prompt:[t?.prompt,`Job: ${e.title}
 
-import { validateBudget, normalizeBudget } from './budget.js';
-import { GRANT_RE } from './team.js';
+${e.brief}`].filter(Boolean).join(`
 
-export const JOB_ID_RE = /^[a-z][a-z0-9_-]{0,63}$/i;
-export const JOB_STATUSES = Object.freeze(['open', 'evaluating', 'recruited', 'in-progress', 'done', 'failed', 'withdrawn']);
-const NEXT = Object.freeze({
-  open: ['evaluating', 'recruited', 'withdrawn'], evaluating: ['recruited', 'open', 'withdrawn'], recruited: ['in-progress', 'open', 'withdrawn'],
-  'in-progress': ['done', 'failed', 'open'], done: [], failed: ['open'], withdrawn: ['open'],
-});
-export const MAX_NEEDS = 24;
-export const MAX_APPLICATIONS = 64;
-
-export class JobError extends Error {
-  constructor(code, message) { super(message); this.name = 'JobError'; this.code = code; }
-}
-
-const isRecord = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-const clip = (s, n) => String(s || '').trim().slice(0, n);
-const list = (xs, n, max) => [...new Set((Array.isArray(xs) ? xs : typeof xs === 'string' ? xs.split(/[,\s]+/) : []).map((x) => clip(x, n)).filter(Boolean))].slice(0, max);
-
-export function validateJob(j) {
-  const errors = [];
-  if (!isRecord(j)) return { ok: false, errors: ['job must be an object'] };
-  if (!JOB_ID_RE.test(String(j.id || ''))) errors.push('id: a short identifier (letters, digits, _ -)');
-  if (!JOB_ID_RE.test(String(j.projectId || ''))) errors.push('projectId: the project this job belongs to');
-  if (!clip(j.title, 200)) errors.push('title: what the job is');
-  if (!clip(j.brief, 8000)) errors.push('brief: what to do, what done looks like');
-  if (j.needs !== undefined) {
-    if (!isRecord(j.needs)) errors.push('needs: { skills[], tools[], grants[] }');
-    else {
-      const badGrants = (Array.isArray(j.needs.grants) ? j.needs.grants : []).filter((g) => !GRANT_RE.test(String(g)));
-      if (badGrants.length) errors.push(`needs.grants: not grantable: ${badGrants.join(', ')}`);
-    }
-  }
-  if (j.budget !== undefined) { const b = validateBudget(j.budget); if (!b.ok) errors.push(...b.errors.map((e) => `budget: ${e}`)); }
-  if (j.status !== undefined && !JOB_STATUSES.includes(j.status)) errors.push(`status: one of ${JOB_STATUSES.join(', ')}`);
-  if (j.dependsOn !== undefined && !Array.isArray(j.dependsOn)) errors.push('dependsOn: a list of job ids');
-  if (j.workspace !== undefined && j.workspace !== null && !isRecord(j.workspace)) errors.push('workspace: { repoId, base, branch? }');
-  if (j.deadline !== undefined && j.deadline !== null && !Number.isFinite(Number(j.deadline))) errors.push('deadline: a time');
-  return { ok: errors.length === 0, errors };
-}
-
-export function normalizeJob(j) {
-  const v = validateJob(j);
-  if (!v.ok) throw new JobError('INVALID', v.errors.join('; '));
-  return {
-    id: String(j.id),
-    projectId: String(j.projectId),
-    title: clip(j.title, 200),
-    brief: clip(j.brief, 8000),
-    needs: {
-      skills: list(j.needs?.skills, 80, MAX_NEEDS),
-      tools: list(j.needs?.tools, 120, MAX_NEEDS),
-      grants: list(j.needs?.grants, 64, MAX_NEEDS).filter((g) => GRANT_RE.test(g)),
-    },
-    ...(j.budget ? { budget: normalizeBudget(j.budget) } : {}),
-    size: { steps: Math.max(0, Math.round(Number(j.size?.steps) || 0)) },
-    status: JOB_STATUSES.includes(j.status) ? j.status : 'open',
-    postedBy: clip(j.postedBy, 80) || 'person',
-    postedAt: Number(j.postedAt) || Date.now(),
-    ...(j.deadline ? { deadline: Number(j.deadline) } : {}),
-    dependsOn: list(j.dependsOn, 64, 32).filter((d) => d !== j.id),
-    ...(j.workspace ? { workspace: { repoId: clip(j.workspace.repoId, 120), base: clip(j.workspace.base, 120) || 'main', ...(j.workspace.branch ? { branch: clip(j.workspace.branch, 200) } : {}), ...(j.workspace.worktreePath ? { worktreePath: clip(j.workspace.worktreePath, 400) } : {}) } } : {}),
-    applications: Array.isArray(j.applications) ? j.applications.slice(0, MAX_APPLICATIONS).map(normalizeApplication).filter(Boolean) : [],
-    ...(j.recruited ? { recruited: normalizeRecruit(j.recruited) } : {}),
-    ...(j.runId ? { runId: String(j.runId) } : {}),
-    ...(j.result ? { result: { text: clip(j.result.text, 8000), by: clip(j.result.by, 80), at: Number(j.result.at) || Date.now(), ...(Array.isArray(j.result.refs) ? { refs: j.result.refs.slice(0, 12) } : {}) } } : {}),
-    ...(j.origin && isRecord(j.origin) ? { origin: { ...j.origin } } : {}),
-  };
-}
-
-function normalizeApplication(a) {
-  if (!isRecord(a) || !a.agentId) return null;
-  return { agentId: String(a.agentId), ...(a.engine ? { engine: a.engine } : {}), fit: Math.max(0, Math.min(1, Number(a.fit) || 0)), reasons: Array.isArray(a.reasons) ? a.reasons.map((r) => clip(r, 200)).slice(0, 8) : [], pitch: clip(a.pitch, 600), at: Number(a.at) || Date.now() };
-}
-function normalizeRecruit(r) {
-  return { agentId: String(r.agentId), ...(r.engine ? { engine: r.engine } : {}), ...(r.budget ? { budget: normalizeBudget(r.budget) } : {}), by: clip(r.by, 80) || 'evaluator', at: Number(r.at) || Date.now(), ...(r.why ? { why: clip(r.why, 600) } : {}) };
-}
-
-export function defineJob(j) { return Object.freeze(normalizeJob(j)); }
-
-/** May the job move from `from` to `to`? */
-export function canTransition(from, to) { return (NEXT[from] || []).includes(to); }
-
-/** Applications are computed, not asked for: every eligible type in the pool applies at once. */
-export function applyAll(job, pool, fitFn, { cards = {}, now = Date.now() } = {}) {
-  // A fit function may also say which ENGINE the agent would run on (recruit.js does); an
-  // application without one is not recruitable right now and sorts after those that are.
-  return (pool || [])
-    .filter((a) => a && a.enabled !== false && (a.appliesTo || ['jobs']).includes('jobs'))
-    .map((a) => { const f = fitFn(job, a, cards[a.id] || null); return { agentId: a.id, ...(f.engine ? { engine: f.engine } : {}), fit: f.score, reasons: f.reasons, pitch: '', at: now }; })
-    .sort((x, y) => (!!y.engine - !!x.engine) || (y.fit - x.fit))
-    .slice(0, MAX_APPLICATIONS);
-}
-
-/** A recruited job as the role a run gives the agent: the brief is the prompt, the needs are the grants. */
-export function jobToRole(job, agent) {
-  return {
-    id: agent?.id || job.id,
-    agent: agent?.id,
-    name: agent?.name || job.title,
-    prompt: [agent?.prompt, `Job: ${job.title}\n\n${job.brief}`].filter(Boolean).join('\n\n'),
-    grants: (job.needs?.grants?.length ? job.needs.grants : agent?.grants) || ['none'],
-    ...(job.dependsOn?.length ? { dependsOn: job.dependsOn } : {}),
-    ...(job.workspace ? { workspace: job.workspace } : {}),
-  };
-}
-
-/** The jobs that may run now: every dependency done, and not already taken. */
-export function readyJobs(jobs) {
-  const byId = new Map((jobs || []).map((j) => [j.id, j]));
-  return (jobs || []).filter((j) => j.status === 'open' && (j.dependsOn || []).every((d) => byId.get(d)?.status === 'done'));
-}
-
-/** A blank posting for the form. */
-export function blankJob(projectId = '') {
-  return { id: '', projectId, title: '', brief: '', needs: { skills: [], tools: [], grants: [] }, budget: { tokens: 40000, ms: 900000 }, status: 'open', dependsOn: [] };
-}
-
-export function jobFromForm(form) {
-  const budget = {};
-  for (const k of ['tokens', 'calls', 'ms', 'usd']) {
-    const v = Number(form?.budget?.[k]);
-    if (form?.budget?.[k] !== '' && form?.budget?.[k] != null && Number.isFinite(v) && v > 0) budget[k] = v;
-  }
-  const j = {
-    id: String(form?.id || '').trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^[^a-z]+/, '').replace(/-+$/, '').slice(0, 64),
-    projectId: form?.projectId, title: form?.title, brief: form?.brief,
-    needs: { skills: form?.needs?.skills, tools: form?.needs?.tools, grants: form?.needs?.grants },
-    ...(Object.keys(budget).length ? { budget } : {}),
-    status: form?.status || 'open', postedBy: form?.postedBy || 'person', dependsOn: form?.dependsOn,
-    ...(form?.workspace?.repoId ? { workspace: form.workspace } : {}), ...(form?.size ? { size: form.size } : {}),
-  };
-  const v = validateJob(j);
-  return v.ok ? { ok: true, job: normalizeJob(j) } : { ok: false, errors: v.errors };
-}
+`),grants:(e.needs?.grants?.length?e.needs.grants:t?.grants)||["none"],...e.dependsOn?.length?{dependsOn:e.dependsOn}:{},...e.workspace?{workspace:e.workspace}:{}}}function J(e){const t=new Map((e||[]).map(n=>[n.id,n]));return(e||[]).filter(n=>n.status==="open"&&(n.dependsOn||[]).every(i=>t.get(i)?.status==="done"))}function E(e=""){return{id:"",projectId:e,title:"",brief:"",needs:{skills:[],tools:[],grants:[]},budget:{tokens:4e4,ms:9e5},status:"open",dependsOn:[]}}function _(e){const t={};for(const d of["tokens","calls","ms","usd"]){const s=Number(e?.budget?.[d]);e?.budget?.[d]!==""&&e?.budget?.[d]!=null&&Number.isFinite(s)&&s>0&&(t[d]=s)}const n={id:String(e?.id||"").trim().toLowerCase().replace(/[^a-z0-9_-]+/g,"-").replace(/^[^a-z]+/,"").replace(/-+$/,"").slice(0,64),projectId:e?.projectId,title:e?.title,brief:e?.brief,needs:{skills:e?.needs?.skills,tools:e?.needs?.tools,grants:e?.needs?.grants},...Object.keys(t).length?{budget:t}:{},status:e?.status||"open",postedBy:e?.postedBy||"person",dependsOn:e?.dependsOn,...e?.workspace?.repoId?{workspace:e.workspace}:{},...e?.size?{size:e.size}:{}},i=h(n);return i.ok?{ok:!0,job:w(n)}:{ok:!1,errors:i.errors}}export{b as JOB_ID_RE,l as JOB_STATUSES,m as JobError,f as MAX_APPLICATIONS,u as MAX_NEEDS,x as applyAll,E as blankJob,S as canTransition,N as defineJob,_ as jobFromForm,B as jobToRole,w as normalizeJob,J as readyJobs,h as validateJob};

package/kernel.js

@@ -1,255 +1 @@
-// The plugin kernel — the part that cannot itself be a plugin.
-//
-// Everything in ChatPanel is a plugin: the loop, tools, skills, storage, renderers, UI
-// slots, sources, model providers, presets, redaction POLICY. This file is what makes
-// that safe to say.
-//
-// "Security is a mandatory plugin" is only meaningful if something that is NOT a plugin
-// enforces the mandate — otherwise mandatory is a config value, and a config value is
-// disableable. So the kernel SHRINKS rather than grows. It does three things, none of
-// them extensible, and deliberately nothing else:
-//
-//   1. load plugins (delegated to the registry — revertible effects, reactive availability);
-//   2. refuse to run when a required plugin is absent or failed;
-//   3. enforce guard monotonicity — a guard may reduce permission, never widen it.
-//
-// POLICY VS MECHANISM. Redaction policy (what counts as sensitive, which dial the user
-// picked, whether an org gets visibility) is a plugin. The redaction mechanism and the
-// egress guard are not. That is what lets privacy be a real on/off dial without ever
-// creating a path where bytes leave unguarded: security is not a dial, privacy is.
-//
-// NO DEPENDENCY ON THE EVENT LOG, matching registry.js — `onEvent` is a plain hook the
-// host maps to schema events if it wants them. That keeps the kernel runnable in the
-// extension, the gateway and the bridge unchanged.
-
-import { createRegistry } from './registry.js';
-
-export class KernelError extends Error {
-  constructor(code, message, detail = null) {
-    super(message);
-    this.name = 'KernelError';
-    this.code = code;
-    this.detail = detail;
-  }
-}
-
-/** The default non-negotiables. A host may require more; it may not require fewer. */
-export const REQUIRED_PLUGINS = Object.freeze(['security']);
-
-/**
- * A decision is a permission, not a boolean: `allow` plus the scopes it covers.
- * Kept deliberately small — anything richer invites a lattice we cannot check.
- */
-export const ALLOW_ALL = Object.freeze({ allow: true, scopes: null, reasons: [] });
-
-const asScopeSet = (s) => (s == null ? null : new Set(s));
-
-/**
- * The MEET of two decisions — the heart of the monotonicity guarantee.
- *
- * A guard cannot widen because widening is never constructed, not because we inspect the
- * result and complain. Detect-and-reject would leave a window in which the widened value
- * existed and could be read by whatever ran next; a meet has no such window.
- *
- * `scopes: null` means "unscoped / all", so it is the top of the lattice and intersecting
- * with it is identity — that keeps a guard that does not care about scopes from
- * accidentally narrowing to nothing.
- */
-export function meetDecisions(a, b) {
-  const as = asScopeSet(a.scopes);
-  const bs = asScopeSet(b.scopes);
-  let scopes = null;
-  if (as && bs) scopes = [...as].filter((s) => bs.has(s));
-  else if (as) scopes = [...as];
-  else if (bs) scopes = [...bs];
-  return {
-    allow: !!a.allow && !!b.allow,
-    scopes,
-    reasons: [...(a.reasons || []), ...(b.reasons || [])],
-  };
-}
-
-/** True when `out` asked for more than `input` allowed — a misbehaving or hostile plugin. */
-function widened(input, out) {
-  if (!input.allow && out.allow) return true;
-  const is = asScopeSet(input.scopes);
-  const os = asScopeSet(out.scopes);
-  if (!is) return false;              // input was unscoped: nothing to widen past
-  if (!os) return true;               // guard tried to drop scoping entirely
-  return [...os].some((s) => !is.has(s));
-}
-
-/**
- * @param required plugin ids that must be active before `start()` resolves. Callers may
- *        add to REQUIRED_PLUGINS; they cannot remove from it.
- * @param onEvent `{ event, ...detail }` — 'plugin:activated' | 'plugin:failed' |
- *        'guard:widened' | 'started' | 'stopped'.
- */
-export function createKernel({ required = [], onEvent = null } = {}) {
-  const requiredIds = [...new Set([...REQUIRED_PLUGINS, ...required])];
-  const registry = createRegistry({
-    onEvent: (d) => emit(`registry:${d.event}`, d),
-  });
-
-  const declared = new Map();   // id -> declaration
-  const handles = new Map();    // id -> registry handle
-  const guards = new Map();     // name -> [{ pluginId, fn }]
-  let started = false;
-
-  const emit = (event, detail = {}) => { if (onEvent) onEvent({ event, ...detail }); };
-
-  /**
-   * Declare a plugin. Declaration is NOT activation: manifests are static so the kernel
-   * can answer "what is installed" without executing anything, and `activate` is where a
-   * host does its `await import()`. A kernel that had to load every plugin to know what
-   * it had would put the whole graph on first paint, and first paint is a release gate.
-   */
-  function define(plugin) {
-    const { id, requires = [], activate, load } = plugin || {};
-    if (!id || typeof id !== 'string') throw new KernelError('BAD_PLUGIN', 'plugin.id required');
-    if (typeof activate !== 'function' && typeof load !== 'function') {
-      throw new KernelError('BAD_PLUGIN', `plugin '${id}': activate or load required`);
-    }
-    if (declared.has(id)) throw new KernelError('DUPLICATE', `plugin '${id}' is already defined`);
-    declared.set(id, { ...plugin, requires: [...requires] });
-    return () => remove(id);
-  }
-
-  function remove(id) {
-    if (requiredIds.includes(id)) {
-      // Not a permission check that could be satisfied — there is no argument that makes
-      // removing the security plugin acceptable, so it is not expressible.
-      throw new KernelError('REQUIRED', `plugin '${id}' is required and cannot be removed`);
-    }
-    declared.delete(id);
-    const h = handles.get(id);
-    handles.delete(id);
-    for (const [name, list] of guards) {
-      const kept = list.filter((g) => g.pluginId !== id);
-      if (kept.length) guards.set(name, kept); else guards.delete(name);
-    }
-    return h ? h.dispose() : Promise.resolve();
-  }
-
-  /** The scope a plugin's `activate` receives — the registry's, plus guard registration. */
-  function scopeFor(id, inner) {
-    return {
-      ...inner,
-      /**
-       * Register a guard. It receives `(request, decision)` and returns a decision; the
-       * kernel meets its answer with what came in, so it can only ever narrow.
-       */
-      guard(name, fn) {
-        if (typeof fn !== 'function') throw new KernelError('BAD_GUARD', `guard '${name}' must be a function`);
-        const list = guards.get(name) || [];
-        list.push({ pluginId: id, fn });
-        guards.set(name, list);
-        return () => {
-          const cur = (guards.get(name) || []).filter((g) => g.fn !== fn);
-          if (cur.length) guards.set(name, cur); else guards.delete(name);
-        };
-      },
-    };
-  }
-
-  /**
-   * Run every guard for `name` and return the narrowest decision any of them permits.
-   * Order-independent by construction: meet is associative and commutative, so guards
-   * cannot race each other into a different answer — which is what lets them be plugins.
-   */
-  function decide(name, request, initial = ALLOW_ALL) {
-    let decision = { allow: !!initial.allow, scopes: initial.scopes ?? null, reasons: [...(initial.reasons || [])] };
-    for (const { pluginId, fn } of guards.get(name) || []) {
-      let out;
-      try {
-        out = fn(request, decision);
-      } catch (err) {
-        // A guard that throws is a guard that did not permit. Fail closed: the
-        // alternative is that crashing a guard becomes a way to bypass it.
-        decision = meetDecisions(decision, { allow: false, scopes: null, reasons: [`${pluginId}: guard threw (${err.message})`] });
-        continue;
-      }
-      if (out == null) continue;                       // abstained
-      if (out === true) continue;                      // permitted, unchanged
-      if (out === false) out = { allow: false, scopes: null, reasons: [`${pluginId}: denied`] };
-      const norm = { allow: out.allow !== false, scopes: out.scopes ?? null, reasons: out.reasons || [] };
-      if (widened(decision, norm)) emit('guard:widened', { guard: name, pluginId });
-      decision = meetDecisions(decision, norm);
-    }
-    return decision;
-  }
-
-  /**
-   * Activate everything declared, then verify the required set is genuinely ACTIVE —
-   * not merely declared. A required plugin that failed to activate is the same problem
-   * as one that was never installed, and the kernel must not be the component that
-   * papers over the difference.
-   */
-  async function start() {
-    if (started) return kernel;
-    const missing = requiredIds.filter((id) => !declared.has(id));
-    if (missing.length) {
-      throw new KernelError('MISSING_REQUIRED', `kernel will not start: required plugin(s) not defined: ${missing.join(', ')}`, missing);
-    }
-    // Required plugins first, so a dependent that reaches for security during its own
-    // activation finds it — the same ordering rule the registry applies to teardown.
-    const ordered = [...declared.values()].sort(
-      (a, b) => (requiredIds.includes(b.id) ? 1 : 0) - (requiredIds.includes(a.id) ? 1 : 0),
-    );
-    // Resolve `load` BEFORE registering. Registry activation is synchronous — an effect
-    // registered after activation returned would not be in the disposer stack, so the
-    // inverse would not run. Awaiting the import here is what keeps a manifest static
-    // (the kernel knows what is installed without executing it) while the module itself
-    // still only costs anything when it activates.
-    for (const p of ordered) {
-      if (handles.has(p.id)) continue;
-      let activate = p.activate;
-      if (!activate) {
-        try {
-          const mod = await p.load();
-          activate = mod?.activate || mod?.default;
-        } catch (err) {
-          throw new KernelError('LOAD_FAILED', `plugin '${p.id}' failed to load: ${err.message}`, p.id);
-        }
-        if (typeof activate !== 'function') {
-          throw new KernelError('BAD_PLUGIN', `plugin '${p.id}': loaded module exports no activate`, p.id);
-        }
-      }
-      handles.set(p.id, registry.register({
-        name: p.id,
-        requires: p.requires,
-        apply: (inner) => activate(scopeFor(p.id, inner)),
-      }));
-    }
-    const notActive = requiredIds.filter((id) => handles.get(id)?.state !== 'active');
-    if (notActive.length) {
-      const detail = notActive.map((id) => ({ id, error: handles.get(id)?.error?.message || 'inactive', waitingFor: registry.pending().find((p) => p.name === id)?.waitingFor || [] }));
-      await registry.dispose();
-      throw new KernelError('REQUIRED_INACTIVE', `kernel will not start: required plugin(s) not active: ${notActive.join(', ')}`, detail);
-    }
-    started = true;
-    emit('started', { plugins: registry.active() });
-    return kernel;
-  }
-
-  const kernel = {
-    define,
-    remove,
-    decide,
-    start,
-    get started() { return started; },
-    /** What is installed, whether or not it activated — a manifest question. */
-    list: () => [...declared.keys()].sort(),
-    active: () => registry.active(),
-    pending: () => registry.pending(),
-    required: () => [...requiredIds],
-    guards: () => [...guards.keys()].sort(),
-    registry,
-    async stop() {
-      started = false;
-      await registry.dispose();
-      emit('stopped', {});
-    },
-  };
-  return kernel;
-}
+import{createRegistry as R}from"./registry.js";class p extends Error{constructor(u,i,r=null){super(i),this.name="KernelError",this.code=u,this.detail=r}}const U=Object.freeze(["security"]),_=Object.freeze({allow:!0,scopes:null,reasons:[]}),v=c=>c==null?null:new Set(c);function E(c,u){const i=v(c.scopes),r=v(u.scopes);let a=null;return i&&r?a=[...i].filter(w=>r.has(w)):i?a=[...i]:r&&(a=[...r]),{allow:!!c.allow&&!!u.allow,scopes:a,reasons:[...c.reasons||[],...u.reasons||[]]}}function x(c,u){if(!c.allow&&u.allow)return!0;const i=v(c.scopes),r=v(u.scopes);return i?r?[...r].some(a=>!i.has(a)):!0:!1}function k({required:c=[],onEvent:u=null}={}){const i=[...new Set([...U,...c])],r=R({onEvent:t=>h(`registry:${t.event}`,t)}),a=new Map,w=new Map,d=new Map;let g=!1;const h=(t,o={})=>{u&&u({event:t,...o})};function D(t){const{id:o,requires:n=[],activate:e,load:s}=t||{};if(!o||typeof o!="string")throw new p("BAD_PLUGIN","plugin.id required");if(typeof e!="function"&&typeof s!="function")throw new p("BAD_PLUGIN",`plugin '${o}': activate or load required`);if(a.has(o))throw new p("DUPLICATE",`plugin '${o}' is already defined`);return a.set(o,{...t,requires:[...n]}),()=>y(o)}function y(t){if(i.includes(t))throw new p("REQUIRED",`plugin '${t}' is required and cannot be removed`);a.delete(t);const o=w.get(t);w.delete(t);for(const[n,e]of d){const s=e.filter(l=>l.pluginId!==t);s.length?d.set(n,s):d.delete(n)}return o?o.dispose():Promise.resolve()}function $(t,o){return{...o,guard(n,e){if(typeof e!="function")throw new p("BAD_GUARD",`guard '${n}' must be a function`);const s=d.get(n)||[];return s.push({pluginId:t,fn:e}),d.set(n,s),()=>{const l=(d.get(n)||[]).filter(f=>f.fn!==e);l.length?d.set(n,l):d.delete(n)}}}}function A(t,o,n=_){let e={allow:!!n.allow,scopes:n.scopes??null,reasons:[...n.reasons||[]]};for(const{pluginId:s,fn:l}of d.get(t)||[]){let f;try{f=l(o,e)}catch(L){e=E(e,{allow:!1,scopes:null,reasons:[`${s}: guard threw (${L.message})`]});continue}if(f==null||f===!0)continue;f===!1&&(f={allow:!1,scopes:null,reasons:[`${s}: denied`]});const m={allow:f.allow!==!1,scopes:f.scopes??null,reasons:f.reasons||[]};x(e,m)&&h("guard:widened",{guard:t,pluginId:s}),e=E(e,m)}return e}async function q(){if(g)return I;const t=i.filter(e=>!a.has(e));if(t.length)throw new p("MISSING_REQUIRED",`kernel will not start: required plugin(s) not defined: ${t.join(", ")}`,t);const o=[...a.values()].sort((e,s)=>(i.includes(s.id)?1:0)-(i.includes(e.id)?1:0));for(const e of o){if(w.has(e.id))continue;let s=e.activate;if(!s){try{const l=await e.load();s=l?.activate||l?.default}catch(l){throw new p("LOAD_FAILED",`plugin '${e.id}' failed to load: ${l.message}`,e.id)}if(typeof s!="function")throw new p("BAD_PLUGIN",`plugin '${e.id}': loaded module exports no activate`,e.id)}w.set(e.id,r.register({name:e.id,requires:e.requires,apply:l=>s($(e.id,l))}))}const n=i.filter(e=>w.get(e)?.state!=="active");if(n.length){const e=n.map(s=>({id:s,error:w.get(s)?.error?.message||"inactive",waitingFor:r.pending().find(l=>l.name===s)?.waitingFor||[]}));throw await r.dispose(),new p("REQUIRED_INACTIVE",`kernel will not start: required plugin(s) not active: ${n.join(", ")}`,e)}return g=!0,h("started",{plugins:r.active()}),I}const I={define:D,remove:y,decide:A,start:q,get started(){return g},list:()=>[...a.keys()].sort(),active:()=>r.active(),pending:()=>r.pending(),required:()=>[...i],guards:()=>[...d.keys()].sort(),registry:r,async stop(){g=!1,await r.dispose(),h("stopped",{})}};return I}export{_ as ALLOW_ALL,p as KernelError,U as REQUIRED_PLUGINS,k as createKernel,E as meetDecisions};