@chatpanel/events 0.101.0 → 0.103.1

package/project.js

@@ -1,170 +1 @@
-// A project — the page a goal starts on, and the record that folds everything done for it.
-//
-// Every job or goal starts here (F8 §12): the goal, defined by its stakeholder — the *chief
-// executive*: a person by default, an agent from the pool when the person delegates it —
-// with a done-when a run can be checked against, a budget the jobs are carved from, the
-// repos the work happens in, and the gate that says how far a team may go without a person.
-// A project is data (a `projects` prefs section, both clients) and a gateway record that
-// folds its jobs, runs and spend from events, the way a run folds (team-record.js).
-//
-// A project's status is a small machine: draft (a goal being written) → open (jobs may be
-// posted) → active (a job was recruited) → done (done-when held, a person closed it) or
-// closed (abandoned). Nothing here runs anything: project-run.js is the executive loop.
-
-import { validateBudget, normalizeBudget } from './budget.js';
-import { normalizeGate, validateGate } from './gate.js';
-
-export const PROJECT_ID_RE = /^[a-z][a-z0-9_-]{0,63}$/i;
-export const PROJECT_STATUSES = Object.freeze(['draft', 'open', 'active', 'done', 'closed']);
-const NEXT = Object.freeze({ draft: ['open', 'closed'], open: ['active', 'closed', 'draft'], active: ['done', 'closed', 'open'], done: ['closed', 'open'], closed: ['open'] });
-export const MAX_REPOS = 16;
-
-export class ProjectError extends Error {
-  constructor(code, message) { super(message); this.name = 'ProjectError'; this.code = code; }
-}
-
-const isRecord = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-const clip = (s, n) => String(s || '').trim().slice(0, n);
-
-export function validateProject(p) {
-  const errors = [];
-  if (!isRecord(p)) return { ok: false, errors: ['project must be an object'] };
-  if (!PROJECT_ID_RE.test(String(p.id || ''))) errors.push('id: a short identifier (letters, digits, _ -)');
-  if (!clip(p.title, 200)) errors.push('title: what the project is called');
-  if (!clip(p.goal, 4000)) errors.push('goal: what done looks like, in the stakeholder\'s words');
-  if (p.doneWhen !== undefined && !clip(p.doneWhen, 2000)) errors.push('doneWhen: a check a run can be held to, or leave it out');
-  if (p.stakeholder !== undefined && p.stakeholder !== 'person' && !/^[a-z][a-z0-9_-]{0,63}$/i.test(String(p.stakeholder))) errors.push('stakeholder: "person" or an agent id');
-  if (p.status !== undefined && !PROJECT_STATUSES.includes(p.status)) errors.push(`status: one of ${PROJECT_STATUSES.join(', ')}`);
-  const b = validateBudget(p.budget);
-  if (!b.ok) errors.push(...b.errors.map((e) => `budget: ${e}`));
-  if (p.repos !== undefined) {
-    if (!Array.isArray(p.repos)) errors.push('repos: a list of repo ids');
-    else if (p.repos.length > MAX_REPOS) errors.push(`repos: at most ${MAX_REPOS}`);
-  }
-  if (p.gate !== undefined && p.gate !== null) errors.push(...validateGate(p.gate, { partial: true }).errors.map((e) => `gate: ${e}`));
-  return { ok: errors.length === 0, errors };
-}
-
-/** The stored form: defaults filled, the budget normalised, the gate (if any) normalised. */
-export function normalizeProject(p) {
-  const v = validateProject(p);
-  if (!v.ok) throw new ProjectError('INVALID', v.errors.join('; '));
-  return {
-    id: String(p.id),
-    title: clip(p.title, 200),
-    goal: clip(p.goal, 4000),
-    doneWhen: clip(p.doneWhen, 2000),
-    stakeholder: p.stakeholder ? String(p.stakeholder) : 'person',
-    budget: normalizeBudget(p.budget),
-    status: PROJECT_STATUSES.includes(p.status) ? p.status : 'draft',
-    repos: Array.isArray(p.repos) ? [...new Set(p.repos.map((r) => clip(r, 120)).filter(Boolean))].slice(0, MAX_REPOS) : [],
-    ...(p.gate ? { gate: normalizeGate(p.gate, { partial: true }) } : {}),
-    tags: Array.isArray(p.tags) ? [...new Set(p.tags.map((t) => clip(t, 40)).filter(Boolean))].slice(0, 12) : [],
-    createdBy: clip(p.createdBy, 80) || 'person',
-    createdAt: Number(p.createdAt) || Date.now(),
-    ...(p.updatedAt ? { updatedAt: Number(p.updatedAt) } : {}),
-  };
-}
-
-export function defineProject(p) { return Object.freeze(normalizeProject(p)); }
-
-/** May the project move from `from` to `to`? The machine above; a person's close is always allowed. */
-export function canTransition(from, to) {
-  return (NEXT[from] || []).includes(to);
-}
-
-/** A blank page for the form. */
-export function blankProject() {
-  return { id: '', title: '', goal: '', doneWhen: '', stakeholder: 'person', budget: { tokens: 200000, ms: 3600000 }, status: 'draft', repos: [], tags: [] };
-}
-
-/** The form → a project, or the errors (the same shaping both clients use). */
-export function projectFromForm(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 p = {
-    id: String(form?.id || '').trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^[^a-z]+/, '').replace(/-+$/, '').slice(0, 64),
-    title: form?.title, goal: form?.goal, doneWhen: form?.doneWhen, stakeholder: form?.stakeholder || 'person',
-    budget, status: form?.status || 'draft',
-    repos: String(Array.isArray(form?.repos) ? form.repos.join(',') : form?.repos || '').split(/[,\s]+/).filter(Boolean),
-    tags: String(Array.isArray(form?.tags) ? form.tags.join(',') : form?.tags || '').split(/[,\s]+/).filter(Boolean),
-    ...(form?.gate ? { gate: form.gate } : {}), ...(form?.createdAt ? { createdAt: form.createdAt } : {}),
-  };
-  const v = validateProject(p);
-  return v.ok ? { ok: true, project: normalizeProject(p) } : { ok: false, errors: v.errors };
-}
-
-// ── the record: a project folded from its events ────────────────────────────────────────
-
-/** The empty record — what the gateway holds per project and both clients read. */
-export function emptyProjectRecord({ id, now = Date.now() } = {}) {
-  return { id, page: null, status: 'draft', jobs: [], runs: [], spend: { tokens: 0, calls: 0, usd: 0, ms: 0 }, decisions: [], report: null, createdAt: now, lastEventAt: now };
-}
-
-/**
- * Fold one event into the record. Events: `project.created` `{ project }` · `project.updated`
- * `{ project }` · `project.status` `{ status, by, note }` · `job.posted` `{ job }` ·
- * `job.updated` `{ job }` (any field: applications, recruited, status) · `run.linked`
- * `{ runId, jobId }` · `run.spent` `{ runId, spent }` · `project.decision` `{ by, kind, text,
- * refs }` · `project.report` `{ text, by }`. Idempotent by job id and run id.
- */
-export function foldProject(rec, ev) {
-  const type = String(ev?.type || '');
-  const p = ev?.payload && typeof ev.payload === 'object' ? ev.payload : (ev || {});
-  const at = Number(ev?.at) || Date.now();
-  rec.lastEventAt = at;
-  switch (type) {
-    case 'project.created':
-    case 'project.updated':
-      if (p.project && typeof p.project === 'object') { rec.page = { ...p.project, updatedAt: at }; rec.status = p.project.status || rec.status; }
-      break;
-    case 'project.status':
-      if (PROJECT_STATUSES.includes(p.status)) { rec.status = p.status; if (rec.page) rec.page.status = p.status; rec.decisions.push({ at, by: p.by || 'person', kind: 'status', text: `${p.status}${p.note ? ` — ${p.note}` : ''}` }); }
-      break;
-    case 'job.posted':
-      if (p.job?.id && !rec.jobs.some((j) => j.id === p.job.id)) rec.jobs.push({ ...p.job, postedAt: at });
-      if (rec.status === 'draft') rec.status = 'open';
-      break;
-    case 'job.updated': {
-      const i = rec.jobs.findIndex((j) => j.id === p.job?.id);
-      if (i >= 0) rec.jobs[i] = { ...rec.jobs[i], ...p.job, updatedAt: at };
-      if (p.job?.status === 'recruited' || p.job?.status === 'in-progress') { if (rec.status === 'open' || rec.status === 'draft') rec.status = 'active'; }
-      break;
-    }
-    case 'run.linked':
-      if (p.runId && !rec.runs.some((r) => r.runId === p.runId)) rec.runs.push({ runId: p.runId, jobId: p.jobId || null, at });
-      break;
-    case 'run.spent': {
-      const r = rec.runs.find((x) => x.runId === p.runId);
-      const prev = r?.spent || { tokens: 0, calls: 0, usd: 0, ms: 0 };
-      const next = { tokens: Number(p.spent?.tokens) || 0, calls: Number(p.spent?.calls) || 0, usd: Number(p.spent?.usd) || 0, ms: Number(p.spent?.ms) || 0 };
-      // A run reports its running total; the project's spend is the sum of every run's latest.
-      for (const k of Object.keys(next)) rec.spend[k] = Math.max(0, (rec.spend[k] || 0) - (prev[k] || 0) + next[k]);
-      if (r) r.spent = next; else rec.runs.push({ runId: p.runId, jobId: null, at, spent: next });
-      break;
-    }
-    case 'project.decision':
-      rec.decisions.push({ at, by: p.by || 'person', kind: p.kind || 'note', text: String(p.text || '').slice(0, 2000), refs: Array.isArray(p.refs) ? p.refs.slice(0, 8) : [] });
-      break;
-    case 'project.report':
-      rec.report = { text: String(p.text || ''), by: p.by || 'runner', at };
-      break;
-    default: break;
-  }
-  return rec;
-}
-
-/** How far along: jobs by status, spend against the budget, whether done-when is claimed. */
-export function projectProgress(rec) {
-  const by = {};
-  for (const j of rec?.jobs || []) by[j.status] = (by[j.status] || 0) + 1;
-  const cap = rec?.page?.budget || {};
-  const spend = rec?.spend || {};
-  const pct = cap.tokens ? Math.min(1, (spend.tokens || 0) / cap.tokens) : cap.usd ? Math.min(1, (spend.usd || 0) / cap.usd) : cap.ms ? Math.min(1, (spend.ms || 0) / cap.ms) : null;
-  const total = (rec?.jobs || []).length;
-  const done = by.done || 0;
-  return { jobs: { total, by }, done, open: (by.open || 0) + (by.evaluating || 0) + (by.recruited || 0) + (by['in-progress'] || 0), spend, cap, budgetUsed: pct, hasReport: !!rec?.report, status: rec?.status || 'draft' };
-}
+import{validateBudget as g,normalizeBudget as f}from"./budget.js";import{normalizeGate as j,validateGate as h}from"./gate.js";const k=/^[a-z][a-z0-9_-]{0,63}$/i,l=Object.freeze(["draft","open","active","done","closed"]),y=Object.freeze({draft:["open","closed"],open:["active","closed","draft"],active:["done","closed","open"],done:["closed","open"],closed:["open"]}),c=16;class A extends Error{constructor(s,o){super(o),this.name="ProjectError",this.code=s}}const m=t=>t!==null&&typeof t=="object"&&!Array.isArray(t),a=(t,s)=>String(t||"").trim().slice(0,s);function p(t){const s=[];if(!m(t))return{ok:!1,errors:["project must be an object"]};k.test(String(t.id||""))||s.push("id: a short identifier (letters, digits, _ -)"),a(t.title,200)||s.push("title: what the project is called"),a(t.goal,4e3)||s.push("goal: what done looks like, in the stakeholder's words"),t.doneWhen!==void 0&&!a(t.doneWhen,2e3)&&s.push("doneWhen: a check a run can be held to, or leave it out"),t.stakeholder!==void 0&&t.stakeholder!=="person"&&!/^[a-z][a-z0-9_-]{0,63}$/i.test(String(t.stakeholder))&&s.push('stakeholder: "person" or an agent id'),t.status!==void 0&&!l.includes(t.status)&&s.push(`status: one of ${l.join(", ")}`);const o=g(t.budget);return o.ok||s.push(...o.errors.map(e=>`budget: ${e}`)),t.repos!==void 0&&(Array.isArray(t.repos)?t.repos.length>c&&s.push(`repos: at most ${c}`):s.push("repos: a list of repo ids")),t.gate!==void 0&&t.gate!==null&&s.push(...h(t.gate,{partial:!0}).errors.map(e=>`gate: ${e}`)),{ok:s.length===0,errors:s}}function b(t){const s=p(t);if(!s.ok)throw new A("INVALID",s.errors.join("; "));return{id:String(t.id),title:a(t.title,200),goal:a(t.goal,4e3),doneWhen:a(t.doneWhen,2e3),stakeholder:t.stakeholder?String(t.stakeholder):"person",budget:f(t.budget),status:l.includes(t.status)?t.status:"draft",repos:Array.isArray(t.repos)?[...new Set(t.repos.map(o=>a(o,120)).filter(Boolean))].slice(0,c):[],...t.gate?{gate:j(t.gate,{partial:!0})}:{},tags:Array.isArray(t.tags)?[...new Set(t.tags.map(o=>a(o,40)).filter(Boolean))].slice(0,12):[],createdBy:a(t.createdBy,80)||"person",createdAt:Number(t.createdAt)||Date.now(),...t.updatedAt?{updatedAt:Number(t.updatedAt)}:{}}}function I(t){return Object.freeze(b(t))}function z(t,s){return(y[t]||[]).includes(s)}function P(){return{id:"",title:"",goal:"",doneWhen:"",stakeholder:"person",budget:{tokens:2e5,ms:36e5},status:"draft",repos:[],tags:[]}}function w(t){const s={};for(const n of["tokens","calls","ms","usd"]){const r=Number(t?.budget?.[n]);t?.budget?.[n]!==""&&t?.budget?.[n]!=null&&Number.isFinite(r)&&r>0&&(s[n]=r)}const o={id:String(t?.id||"").trim().toLowerCase().replace(/[^a-z0-9_-]+/g,"-").replace(/^[^a-z]+/,"").replace(/-+$/,"").slice(0,64),title:t?.title,goal:t?.goal,doneWhen:t?.doneWhen,stakeholder:t?.stakeholder||"person",budget:s,status:t?.status||"draft",repos:String(Array.isArray(t?.repos)?t.repos.join(","):t?.repos||"").split(/[,\s]+/).filter(Boolean),tags:String(Array.isArray(t?.tags)?t.tags.join(","):t?.tags||"").split(/[,\s]+/).filter(Boolean),...t?.gate?{gate:t.gate}:{},...t?.createdAt?{createdAt:t.createdAt}:{}},e=p(o);return e.ok?{ok:!0,project:b(o)}:{ok:!1,errors:e.errors}}function E({id:t,now:s=Date.now()}={}){return{id:t,page:null,status:"draft",jobs:[],runs:[],spend:{tokens:0,calls:0,usd:0,ms:0},decisions:[],report:null,createdAt:s,lastEventAt:s}}function N(t,s){const o=String(s?.type||""),e=s?.payload&&typeof s.payload=="object"?s.payload:s||{},n=Number(s?.at)||Date.now();switch(t.lastEventAt=n,o){case"project.created":case"project.updated":e.project&&typeof e.project=="object"&&(t.page={...e.project,updatedAt:n},t.status=e.project.status||t.status);break;case"project.status":l.includes(e.status)&&(t.status=e.status,t.page&&(t.page.status=e.status),t.decisions.push({at:n,by:e.by||"person",kind:"status",text:`${e.status}${e.note?` — ${e.note}`:""}`}));break;case"job.posted":e.job?.id&&!t.jobs.some(r=>r.id===e.job.id)&&t.jobs.push({...e.job,postedAt:n}),t.status==="draft"&&(t.status="open");break;case"job.updated":{const r=t.jobs.findIndex(u=>u.id===e.job?.id);r>=0&&(t.jobs[r]={...t.jobs[r],...e.job,updatedAt:n}),(e.job?.status==="recruited"||e.job?.status==="in-progress")&&(t.status==="open"||t.status==="draft")&&(t.status="active");break}case"run.linked":e.runId&&!t.runs.some(r=>r.runId===e.runId)&&t.runs.push({runId:e.runId,jobId:e.jobId||null,at:n});break;case"run.spent":{const r=t.runs.find(i=>i.runId===e.runId),u=r?.spent||{tokens:0,calls:0,usd:0,ms:0},d={tokens:Number(e.spent?.tokens)||0,calls:Number(e.spent?.calls)||0,usd:Number(e.spent?.usd)||0,ms:Number(e.spent?.ms)||0};for(const i of Object.keys(d))t.spend[i]=Math.max(0,(t.spend[i]||0)-(u[i]||0)+d[i]);r?r.spent=d:t.runs.push({runId:e.runId,jobId:null,at:n,spent:d});break}case"project.decision":t.decisions.push({at:n,by:e.by||"person",kind:e.kind||"note",text:String(e.text||"").slice(0,2e3),refs:Array.isArray(e.refs)?e.refs.slice(0,8):[]});break;case"project.report":t.report={text:String(e.text||""),by:e.by||"runner",at:n};break;default:break}return t}function $(t){const s={};for(const d of t?.jobs||[])s[d.status]=(s[d.status]||0)+1;const o=t?.page?.budget||{},e=t?.spend||{},n=o.tokens?Math.min(1,(e.tokens||0)/o.tokens):o.usd?Math.min(1,(e.usd||0)/o.usd):o.ms?Math.min(1,(e.ms||0)/o.ms):null,r=(t?.jobs||[]).length,u=s.done||0;return{jobs:{total:r,by:s},done:u,open:(s.open||0)+(s.evaluating||0)+(s.recruited||0)+(s["in-progress"]||0),spend:e,cap:o,budgetUsed:n,hasReport:!!t?.report,status:t?.status||"draft"}}export{c as MAX_REPOS,k as PROJECT_ID_RE,l as PROJECT_STATUSES,A as ProjectError,P as blankProject,z as canTransition,I as defineProject,E as emptyProjectRecord,N as foldProject,b as normalizeProject,w as projectFromForm,$ as projectProgress,p as validateProject};

package/promotion.js

@@ -1,171 +1 @@
-// PROMOTION — the gate between "a model wrote this" and "the brief says this".
-//
-// The single most repeated finding in the community threads was that unreviewed agent
-// writing compounds into confident nonsense (C2), and the convergent answer was to separate
-// CAPTURE from PROMOTION: agents draft freely, promotion needs review. This module is that
-// separation as code. Class-R claims never pass through it — a backlink is not an opinion —
-// and class-C claims never get around it.
-//
-//   proposed  →  promoted   only via accept()
-//   proposed  →  rejected   via reject()
-//
-// A proposal is its own object rather than a mutation of the brief, so the queue survives a
-// rebuild (I-K2 throws briefs away; it must not throw away the user's pending decisions),
-// and so accepting shows a DIFF against what the brief said before rather than a fait
-// accompli.
-//
-// `converge()` is W7's rule written before W7 exists: N independent drafts agree on a claim
-// ⇒ it may be auto-proposed; disagreement ⇒ the human queue. The reviewer is a different
-// appointment from the drafters or convergence measures nothing.
-
-import { contentHash } from './knowledge.js';
-import { normalizeSubject } from './subject-name.js';
-
-export const PROPOSAL_STATES = Object.freeze(['proposed', 'accepted', 'rejected']);
-
-/** A new claim replaces an old one when this much of its vocabulary overlaps. */
-export const SUPERSEDE_OVERLAP = 0.5;
-
-/**
- * BACKLINKS — the deterministic post-pass that turns cited prose into a linked wiki.
- *
- * A synthesised claim cites RECORDS, never another brief, so an accepted "Jordan Blake owns
- * the Atlas rollback plan" told a reader nothing about where Jordan's page was. This finds
- * every other subject named in a claim's text — whole-word, by canonical name or alias — and
- * adds a `brief:` ref beside the record refs. No model: the names are known and the text is
- * in front of us, which is exactly the kind of work the design says must stay class R.
- *
- * `subjects` is the brief index: `[{ id, name, aliases?, kind? }]`. The claim's own brief is
- * never linked to itself. Refs already present are kept and not duplicated.
- */
-export function linkClaims(claims = [], subjects = [], { selfId = '' } = {}) {
-  const targets = [];
-  for (const s of subjects) {
-    if (!s?.id || s.id === selfId) continue;
-    const names = [s.name, ...(s.aliases || [])].map(normalizeSubject).filter((n) => n && n.length >= 3);
-    if (names.length) targets.push({ id: s.id, names });
-  }
-  if (!targets.length) return claims;
-  return claims.map((c) => {
-    const hay = ` ${normalizeSubject(c.text)} `;
-    const have = new Set((c.refs || []).map((r) => `${r.kind}:${r.id}`));
-    const added = [];
-    for (const t of targets) {
-      if (have.has(`brief:${t.id}`)) continue;
-      if (t.names.some((n) => hay.includes(` ${n} `))) {
-        added.push({ kind: 'brief', id: t.id, hash: contentHash(t.id) });
-        have.add(`brief:${t.id}`);
-      }
-    }
-    return added.length ? { ...c, refs: [...(c.refs || []), ...added] } : c;
-  });
-}
-
-/** A pending synthesis for one brief. Never carries `promoted`. */
-export function propose({ briefId, claims = [], summary = '', by = 'model', now = 0, newId = null } = {}) {
-  if (!briefId) throw new TypeError('propose: briefId required');
-  const bad = claims.find((c) => c?.cls !== 'C' || !c?.refs?.length);
-  if (bad) throw new TypeError('propose: only class-C claims with refs may be proposed');
-  return {
-    id: newId ? newId() : `p-${briefId}-${now}`,
-    briefId,
-    by: String(by),
-    at: now,
-    state: 'proposed',
-    claims: claims.map((c) => ({ ...c, state: 'proposed' })),
-    summary: String(summary || ''),
-  };
-}
-
-/**
- * Accept: the proposal's claims join the brief as promoted class-C claims. The ONLY path.
- * Returns a new brief and the settled proposal; mutates neither input.
- */
-export function accept(brief, proposal, { now = 0, subjects = [] } = {}) {
-  if (!brief || !proposal || proposal.briefId !== brief.id) throw new TypeError('accept: proposal does not belong to this brief');
-  if (proposal.state !== 'proposed') throw new TypeError(`accept: proposal is ${proposal.state}`);
-  let promoted = proposal.claims.map((c) => ({ ...c, state: 'promoted', lastConfirmed: now }));
-  // Backlinks, at the moment of acceptance — the one point where the claim is final and the
-  // set of other pages is known.
-  promoted = linkClaims(promoted, subjects, { selfId: brief.id });
-
-  // SUPERSESSION. "Cutover is planned for Q3" and "Cutover moved to Q4" must not sit on one
-  // page as two contradicting lines. The old claim is not deleted — that would lose "when did
-  // this change" — it is marked superseded by the new one, and keeps its refs, so the brief
-  // reads as a history rather than an argument with itself. The rule is the same overlap
-  // diffProposal shows the reviewer, so what they accepted is what happens.
-  const diff = diffProposal(brief, proposal);
-  const superseded = new Map(); // old text -> new claim id
-  diff.forEach((d, i) => { if (d.replaces && promoted[i]) superseded.set(d.replaces, promoted[i].id); });
-  const kept = brief.claims.map((c) => (superseded.has(c.text) && !c.supersededBy
-    ? { ...c, supersededBy: superseded.get(c.text), supersededAt: now }
-    : c));
-  promoted = promoted.map((c, i) => (diff[i]?.replaces ? { ...c, supersedes: brief.claims.find((o) => o.text === diff[i].replaces)?.id || null } : c));
-
-  const next = {
-    ...brief,
-    claims: [...kept, ...promoted],
-    summary: proposal.summary || brief.summary || '',
-    updatedAt: now,
-  };
-  return { brief: next, proposal: { ...proposal, state: 'accepted', settledAt: now, claims: promoted } };
-}
-
-export function reject(proposal, { now = 0, why = '' } = {}) {
-  if (!proposal || proposal.state !== 'proposed') throw new TypeError('reject: not a pending proposal');
-  return { ...proposal, state: 'rejected', settledAt: now, why: String(why || '') };
-}
-
-/**
- * The diff a reviewer sees: what is new against the brief, and what a new claim
- * contradicts or supersedes. Deterministic and cheap — same-subject, same-`when`-or-later
- * claims that share enough words are shown as "replaces", which is a suggestion the
- * reviewer confirms, never an edit.
- */
-export function diffProposal(brief, proposal) {
-  const existing = (brief?.claims || []).map((c) => c.text);
-  const tokens = (t) => new Set(String(t).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w.length > 3));
-  return proposal.claims.map((c) => {
-    const mine = tokens(c.text);
-    let best = null; let bestScore = 0;
-    for (const e of existing) {
-      const theirs = tokens(e);
-      let hit = 0; for (const w of mine) if (theirs.has(w)) hit += 1;
-      const score = mine.size ? hit / mine.size : 0;
-      if (score > bestScore) { bestScore = score; best = e; }
-    }
-    return { claim: c, replaces: bestScore >= SUPERSEDE_OVERLAP ? best : null, overlap: bestScore };
-  });
-}
-
-/**
- * W7's rule. Given several INDEPENDENT drafts of the same subject, the claims that at least
- * `minAgree` drafts made (by near-identical text) may be proposed automatically; the rest go
- * to the human queue. "Agree" is a text-overlap test, not equality — two models never phrase
- * a thing identically, and requiring it would make convergence measure nothing.
- */
-export function converge(drafts = [], { minAgree = 2, threshold = 0.6 } = {}) {
-  const tokens = (t) => new Set(String(t).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w.length > 3));
-  const all = drafts.flatMap((d, i) => (d?.claims || []).map((c) => ({ c, draft: i, t: tokens(c.text) })));
-  const agreed = [];
-  const disputed = [];
-  const used = new Set();
-  for (let i = 0; i < all.length; i += 1) {
-    if (used.has(i)) continue;
-    const group = [i];
-    for (let j = i + 1; j < all.length; j += 1) {
-      if (used.has(j) || all[j].draft === all[i].draft) continue;
-      let hit = 0; for (const w of all[i].t) if (all[j].t.has(w)) hit += 1;
-      const score = all[i].t.size ? hit / all[i].t.size : 0;
-      if (score >= threshold) group.push(j);
-    }
-    const drafters = new Set(group.map((g) => all[g].draft));
-    for (const g of group) used.add(g);
-    // The union of refs across agreeing drafts: agreement on the claim is evidence, and so
-    // is every record any of them cited for it.
-    const refs = [...new Map(group.flatMap((g) => all[g].c.refs || []).map((r) => [`${r.kind}:${r.id}`, r])).values()];
-    const merged = { ...all[i].c, refs, agreedBy: drafters.size };
-    (drafters.size >= minAgree ? agreed : disputed).push(merged);
-  }
-  return { agreed, disputed };
-}
+import{contentHash as w}from"./knowledge.js";import{normalizeSubject as h}from"./subject-name.js";const b=Object.freeze(["proposed","accepted","rejected"]),x=.5;function y(r=[],n=[],{selfId:c=""}={}){const f=[];for(const e of n){if(!e?.id||e.id===c)continue;const o=[e.name,...e.aliases||[]].map(h).filter(a=>a&&a.length>=3);o.length&&f.push({id:e.id,names:o})}return f.length?r.map(e=>{const o=` ${h(e.text)} `,a=new Set((e.refs||[]).map(t=>`${t.kind}:${t.id}`)),i=[];for(const t of f)a.has(`brief:${t.id}`)||t.names.some(s=>o.includes(` ${s} `))&&(i.push({kind:"brief",id:t.id,hash:w(t.id)}),a.add(`brief:${t.id}`));return i.length?{...e,refs:[...e.refs||[],...i]}:e}):r}function j({briefId:r,claims:n=[],summary:c="",by:f="model",now:e=0,newId:o=null}={}){if(!r)throw new TypeError("propose: briefId required");if(n.find(i=>i?.cls!=="C"||!i?.refs?.length))throw new TypeError("propose: only class-C claims with refs may be proposed");return{id:o?o():`p-${r}-${e}`,briefId:r,by:String(f),at:e,state:"proposed",claims:n.map(i=>({...i,state:"proposed"})),summary:String(c||"")}}function k(r,n,{now:c=0,subjects:f=[]}={}){if(!r||!n||n.briefId!==r.id)throw new TypeError("accept: proposal does not belong to this brief");if(n.state!=="proposed")throw new TypeError(`accept: proposal is ${n.state}`);let e=n.claims.map(s=>({...s,state:"promoted",lastConfirmed:c}));e=y(e,f,{selfId:r.id});const o=S(r,n),a=new Map;o.forEach((s,d)=>{s.replaces&&e[d]&&a.set(s.replaces,e[d].id)});const i=r.claims.map(s=>a.has(s.text)&&!s.supersededBy?{...s,supersededBy:a.get(s.text),supersededAt:c}:s);return e=e.map((s,d)=>o[d]?.replaces?{...s,supersedes:r.claims.find(l=>l.text===o[d].replaces)?.id||null}:s),{brief:{...r,claims:[...i,...e],summary:n.summary||r.summary||"",updatedAt:c},proposal:{...n,state:"accepted",settledAt:c,claims:e}}}function A(r,{now:n=0,why:c=""}={}){if(!r||r.state!=="proposed")throw new TypeError("reject: not a pending proposal");return{...r,state:"rejected",settledAt:n,why:String(c||"")}}function S(r,n){const c=(r?.claims||[]).map(e=>e.text),f=e=>new Set(String(e).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(o=>o.length>3));return n.claims.map(e=>{const o=f(e.text);let a=null,i=0;for(const t of c){const s=f(t);let d=0;for(const m of o)s.has(m)&&(d+=1);const l=o.size?d/o.size:0;l>i&&(i=l,a=t)}return{claim:e,replaces:i>=x?a:null,overlap:i}})}function T(r=[],{minAgree:n=2,threshold:c=.6}={}){const f=t=>new Set(String(t).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(s=>s.length>3)),e=r.flatMap((t,s)=>(t?.claims||[]).map(d=>({c:d,draft:s,t:f(d.text)}))),o=[],a=[],i=new Set;for(let t=0;t<e.length;t+=1){if(i.has(t))continue;const s=[t];for(let p=t+1;p<e.length;p+=1){if(i.has(p)||e[p].draft===e[t].draft)continue;let u=0;for(const g of e[t].t)e[p].t.has(g)&&(u+=1);(e[t].t.size?u/e[t].t.size:0)>=c&&s.push(p)}const d=new Set(s.map(p=>e[p].draft));for(const p of s)i.add(p);const l=[...new Map(s.flatMap(p=>e[p].c.refs||[]).map(p=>[`${p.kind}:${p.id}`,p])).values()],m={...e[t].c,refs:l,agreedBy:d.size};(d.size>=n?o:a).push(m)}return{agreed:o,disputed:a}}export{b as PROPOSAL_STATES,x as SUPERSEDE_OVERLAP,k as accept,T as converge,S as diffProposal,y as linkClaims,j as propose,A as reject};

package/queue.js

@@ -1,98 +1 @@
-// THE SEND QUEUE — what someone typed while a reply was still streaming, and what they are
-// allowed to do about it before it is answered.
-//
-// Typing over a running answer is not a mistake to be prevented; it is how people think. But
-// a queue you can only ADD to is a trap, and in three specific ways:
-//
-//   • the thought that arrives mid-answer is often the URGENT one — it should not have to
-//     wait out a reply it was meant to redirect (steer);
-//   • the reply frequently answers a queued question before it is ever sent, and sending it
-//     anyway spends a turn on something nobody wants any more (dequeue);
-//   • the order things occur to you is not the order they should be asked in (reorder).
-//
-// The queue is deliberately NOT a second list living beside the transcript. It IS the
-// trailing run of user messages that has no reply after it — exactly the set a client
-// answers when the current stream ends. One definition means what is drawn and what is sent
-// can never disagree, and a message cannot be "in the queue" but missing from the turn.
-//
-// Every function here is a pure transform: it returns a NEW array, or the array it was given
-// (by identity) when the operation was a no-op, so a caller can tell "nothing changed" from
-// "changed" without diffing. No clock, no ids minted, no DOM, no storage — the panel, a
-// mobile client, the gateway and the bridge can all reason about the same queue.
-//
-// STEERING, honestly: no engine we speak to accepts new input into a run already in flight
-// (the bridge closes a CLI's stdin with the prompt; HTTP streaming has no upstream channel).
-// So "send now" is promote-then-interrupt: the partial answer stays in the transcript as
-// context, and the next turn opens with the message the user wanted read first. This module
-// owns the ORDER half of that — the client owns the abort.
-
-const isUser = (m) => !!m && m.role === 'user';
-
-/**
- * The pending queue: the trailing run of user messages with no reply after it.
- *
- * Returned oldest-first — the order they will be sent in — as
- * `{ message, id, index, position }`, where `index` is the position in the whole
- * transcript and `position` the position within the queue.
- */
-export function pendingQueue(messages) {
-  const list = Array.isArray(messages) ? messages : [];
-  let start = list.length;
-  while (start > 0 && isUser(list[start - 1])) start--;
-  const out = [];
-  for (let i = start; i < list.length; i++) {
-    out.push({ message: list[i], id: list[i].id, index: i, position: i - start });
-  }
-  return out;
-}
-
-/** Is this message currently in the queue (rather than already answered)? */
-export function isQueued(messages, id) {
-  return pendingQueue(messages).some((e) => e.id === id);
-}
-
-/**
- * Drop a queued message — the question the running reply already answered.
- *
- * Only ever removes from the pending run: an id from further up the transcript is a
- * no-op, so a stale click can never delete a turn that has already been answered.
- */
-export function dequeue(messages, id) {
-  const queue = pendingQueue(messages);
-  const hit = queue.find((e) => e.id === id);
-  if (!hit) return messages;
-  const next = messages.slice();
-  next.splice(hit.index, 1);
-  return next;
-}
-
-/** Move a queued message by `delta` places (-1 up, +1 down). Clamped: past either end is a no-op. */
-export function moveQueued(messages, id, delta) {
-  const queue = pendingQueue(messages);
-  const from = queue.findIndex((e) => e.id === id);
-  if (from < 0) return messages;
-  const step = Math.trunc(Number(delta) || 0);
-  const to = from + step;
-  if (!step || to < 0 || to >= queue.length) return messages;
-  return reordered(messages, queue, from, to);
-}
-
-/**
- * Put a queued message at the FRONT — the ordering half of "send now".
- *
- * The rest of the queue keeps its relative order behind it: steering is a statement about
- * what to read first, not an instruction to throw away everything else that was typed.
- */
-export function promoteQueued(messages, id) {
-  const queue = pendingQueue(messages);
-  const from = queue.findIndex((e) => e.id === id);
-  if (from <= 0) return messages; // absent, or already first
-  return reordered(messages, queue, from, 0);
-}
-
-function reordered(messages, queue, from, to) {
-  const block = queue.map((e) => e.message);
-  const [moved] = block.splice(from, 1);
-  block.splice(to, 0, moved);
-  return messages.slice(0, queue[0].index).concat(block);
-}
+const l=n=>!!n&&n.role==="user";function c(n){const e=Array.isArray(n)?n:[];let r=e.length;for(;r>0&&l(e[r-1]);)r--;const o=[];for(let t=r;t<e.length;t++)o.push({message:e[t],id:e[t].id,index:t,position:t-r});return o}function p(n,e){return c(n).some(r=>r.id===e)}function x(n,e){const o=c(n).find(i=>i.id===e);if(!o)return n;const t=n.slice();return t.splice(o.index,1),t}function s(n,e,r){const o=c(n),t=o.findIndex(f=>f.id===e);if(t<0)return n;const i=Math.trunc(Number(r)||0),u=t+i;return!i||u<0||u>=o.length?n:d(n,o,t,u)}function h(n,e){const r=c(n),o=r.findIndex(t=>t.id===e);return o<=0?n:d(n,r,o,0)}function d(n,e,r,o){const t=e.map(u=>u.message),[i]=t.splice(r,1);return t.splice(o,0,i),n.slice(0,e[0].index).concat(t)}export{x as dequeue,p as isQueued,s as moveQueued,c as pendingQueue,h as promoteQueued};

package/reach.js

@@ -1,23 +1 @@
-// reach.js — how far a request may travel, on its own so it can travel alone.
-//
-// One ordered vocabulary answers "how far may this go" for three very different callers: the
-// model router ranks a model's reach against a turn's requirement, pairing gives a phone a
-// ceiling, and the bridge maps that ceiling to a toolset. Three declarations, one vocabulary,
-// or "how far may this reach" gets three answers that drift.
-//
-// A separate module rather than a constant inside router.js for the reason scopes.js exists:
-// the consumers have wildly different weights. The bridge has zero runtime dependencies by
-// design and vendors what it needs — pulling the 50 KB model router in to reach a
-// three-element array is exactly the transitive-graph mistake that split DATA_SCOPES out of
-// capability.js.
-//
-// ORDERED, least to most: a ceiling comparison is an index comparison.
-export const REACH = Object.freeze(['device', 'trusted', 'any']);
-
-/** Position in the ladder; an unknown tier ranks LOWEST, so a typo never widens reach. */
-export const reachRank = (r) => Math.max(0, REACH.indexOf(r));
-
-/** Does `have` satisfy `need`? Fails closed — an unknown `have` is treated as 'device'. */
-export function reachSatisfies(have, need) {
-  return reachRank(have) >= reachRank(need);
-}
+const n=Object.freeze(["device","trusted","any"]),t=e=>Math.max(0,n.indexOf(e));function a(e,r){return t(e)>=t(r)}export{n as REACH,t as reachRank,a as reachSatisfies};