@chatpanel/events 0.102.0 → 0.104.0

package/backup-envelope.js

@@ -1,221 +1 @@
-// THE BACKUP ENVELOPE — one wire format, one implementation.
-//
-// A ChatPanel backup is the only LOSSLESS channel the corpus has between clients: the
-// extension writes one, the gateway reads one, and a desktop client has to do both. Today
-// that format is implemented twice — the extension's `crypto-backup.js` (both directions)
-// and the gateway's `backup-decrypt.js` (decrypt only, re-derived from the format's shape).
-// Two implementations of a CRYPTO format is the worst kind of duplication: a divergence does
-// not show up as a wrong pixel, it shows up as a backup nobody can open.
-//
-// Envelope, unchanged and frozen:
-//   { type:'chatpanel-backup-encrypted', version, kdf:{iterations,salt},
-//     cipher:'AES-GCM', compression:'brotli'|'gzip'|'none'|absent, iv, ct }
-//
-// COMPRESSION IS INJECTED, crypto is not. WebCrypto is on every runtime we target
-// (browser, Node 19+, Electron), so it is imported as a global. Compression is not: the
-// browser has CompressionStream, Node has zlib, and neither can be reached from the other.
-// So the caller passes a `codec` — which is the same shape as the `page-capability.js`
-// factory and the `loop.js` clock, and for the same reason.
-//
-// COMPRESS THEN ENCRYPT, never the reverse. Ciphertext is indistinguishable from random and
-// does not compress, so the order is load-bearing rather than stylistic. The envelope
-// records which codec was used so a gzip backup written in 2025 still opens forever.
-
-export class BackupError extends Error {
-  constructor(message) { super(message); this.name = 'BackupError'; }
-}
-
-export const ENCRYPTED_TYPE = 'chatpanel-backup-encrypted';
-
-/** PBKDF2-SHA256 rounds. Recorded IN the envelope so this can be raised without breaking old files. */
-export const KDF_ITERATIONS = 250_000;
-
-export const COMPRESSIONS = Object.freeze(['brotli', 'gzip', 'none']);
-
-// --------------------------------------------------------------------------
-// Bytes ↔ base64, without Buffer or atob assumptions
-// --------------------------------------------------------------------------
-
-const CHUNK = 0x8000;
-
-export function toB64(bytes) {
-  if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64');
-  let bin = '';
-  for (let i = 0; i < bytes.length; i += CHUNK) {
-    bin += String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK));
-  }
-  return btoa(bin);
-}
-
-export function fromB64(s) {
-  const str = String(s || '');
-  if (typeof Buffer !== 'undefined') return new Uint8Array(Buffer.from(str, 'base64'));
-  const bin = atob(str);
-  const out = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-  return out;
-}
-
-// --------------------------------------------------------------------------
-// Codecs
-// --------------------------------------------------------------------------
-
-/**
- * The no-op codec. A backup written with it is still encrypted — it is just larger.
- * Useful in tests and on a runtime that offers no compression at all.
- */
-export const identityCodec = Object.freeze({
-  name: 'none',
-  async compress(bytes) { return bytes; },
-  async decompress(bytes) { return bytes; },
-});
-
-/**
- * The browser/Electron-renderer codec, built from CompressionStream.
- * Returns `null` when the runtime lacks the format, so a caller can fall back rather than
- * discover the gap at write time.
- */
-export function streamCodec(format = 'gzip') {
-  if (typeof CompressionStream === 'undefined' || typeof DecompressionStream === 'undefined') return null;
-  try {
-    new CompressionStream(format);
-    new DecompressionStream(format);
-  } catch {
-    return null;
-  }
-  const run = async (bytes, Stream) => {
-    const stream = new Blob([bytes]).stream().pipeThrough(new Stream(format));
-    return new Uint8Array(await new Response(stream).arrayBuffer());
-  };
-  return Object.freeze({
-    name: format,
-    compress: (b) => run(b, CompressionStream),
-    decompress: (b) => run(b, DecompressionStream),
-  });
-}
-
-/**
- * Build a codec from Node's zlib without importing it here — the caller passes the module,
- * so this file stays dependency-free and loadable in a browser.
- *
- *   import zlib from 'node:zlib';
- *   const codec = nodeCodec(zlib, 'brotli');
- */
-export function nodeCodec(zlib, format = 'brotli') {
-  if (!zlib) return null;
-  const pair = format === 'brotli'
-    ? [zlib.brotliCompressSync, zlib.brotliDecompressSync]
-    : format === 'gzip' ? [zlib.gzipSync, zlib.gunzipSync] : null;
-  if (!pair || !pair[0] || !pair[1]) return null;
-  const [enc, dec] = pair;
-  return Object.freeze({
-    name: format,
-    async compress(bytes) { return new Uint8Array(enc(Buffer.from(bytes))); },
-    async decompress(bytes) { return new Uint8Array(dec(Buffer.from(bytes))); },
-  });
-}
-
-/** Pick the best codec a runtime offers, preferring the smallest output. */
-export function bestCodec({ zlib = null } = {}) {
-  if (zlib) return nodeCodec(zlib, 'brotli') || nodeCodec(zlib, 'gzip') || identityCodec;
-  return streamCodec('brotli') || streamCodec('gzip') || identityCodec;
-}
-
-// --------------------------------------------------------------------------
-// Key derivation
-// --------------------------------------------------------------------------
-
-async function deriveKey(passphrase, salt, iterations, usages, subtle) {
-  const crypto_ = subtle || globalThis.crypto?.subtle;
-  if (!crypto_) throw new BackupError('no WebCrypto available on this runtime');
-  const base = await crypto_.importKey(
-    'raw', new TextEncoder().encode(String(passphrase)), 'PBKDF2', false, ['deriveKey'],
-  );
-  return crypto_.deriveKey(
-    { name: 'PBKDF2', salt, iterations, hash: 'SHA-256' },
-    base,
-    { name: 'AES-GCM', length: 256 },
-    false,
-    usages,
-  );
-}
-
-// --------------------------------------------------------------------------
-// The two directions
-// --------------------------------------------------------------------------
-
-export function isEncryptedBackup(obj) {
-  return !!obj && typeof obj === 'object' && obj.type === ENCRYPTED_TYPE;
-}
-
-/**
- * data + passphrase → envelope.
- *
- * `version` is the ENVELOPE's version, not the payload's — the backup body carries its own.
- */
-export async function encryptBackup(data, passphrase, {
-  codec = null, iterations = KDF_ITERATIONS, subtle = null, random = null, version = 3,
-} = {}) {
-  if (!passphrase) throw new BackupError('a passphrase is required to encrypt a backup');
-  const c = codec || bestCodec();
-  const rand = random || ((n) => globalThis.crypto.getRandomValues(new Uint8Array(n)));
-
-  const plain = new TextEncoder().encode(JSON.stringify(data));
-  const packed = await c.compress(plain);
-
-  const salt = rand(16);
-  const iv = rand(12);
-  const key = await deriveKey(passphrase, salt, iterations, ['encrypt'], subtle);
-  const cryptoSubtle = subtle || globalThis.crypto.subtle;
-  const ct = new Uint8Array(await cryptoSubtle.encrypt({ name: 'AES-GCM', iv }, key, packed));
-
-  return {
-    type: ENCRYPTED_TYPE,
-    version,
-    kdf: { iterations, salt: toB64(salt) },
-    cipher: 'AES-GCM',
-    compression: c.name,
-    iv: toB64(iv),
-    ct: toB64(ct),
-  };
-}
-
-/**
- * envelope + passphrase → the original data object.
- *
- * A wrong passphrase and a tampered file are the SAME failure here, and deliberately so:
- * AES-GCM's auth tag catches both, and telling them apart would be an oracle.
- */
-export async function decryptBackup(envelope, passphrase, { codec = null, subtle = null } = {}) {
-  if (!isEncryptedBackup(envelope)) throw new BackupError('not an encrypted ChatPanel backup');
-  if (!passphrase) throw new BackupError('a passphrase is required to decrypt this backup');
-
-  const salt = fromB64(envelope.kdf?.salt);
-  const iterations = Number(envelope.kdf?.iterations) || KDF_ITERATIONS;
-  const key = await deriveKey(passphrase, salt, iterations, ['decrypt'], subtle);
-  const cryptoSubtle = subtle || globalThis.crypto?.subtle;
-  if (!cryptoSubtle) throw new BackupError('no WebCrypto available on this runtime');
-
-  let payload;
-  try {
-    payload = new Uint8Array(await cryptoSubtle.decrypt(
-      { name: 'AES-GCM', iv: fromB64(envelope.iv) }, key, fromB64(envelope.ct),
-    ));
-  } catch {
-    throw new BackupError('wrong passphrase, or the backup file is corrupted');
-  }
-
-  // v1 wrote plaintext, v2 gzip, v3 may use brotli. The envelope says which; an absent
-  // field means the oldest behaviour, which is why `none` and absent must agree.
-  const want = envelope.compression || 'none';
-  if (want !== 'none') {
-    const c = codec || bestCodec();
-    if (c.name !== want) {
-      // Being explicit beats returning garbage: a gzip envelope handed a brotli-only codec
-      // fails here with a readable reason instead of a JSON parse error twenty lines later.
-      throw new BackupError(`this backup is ${want}-compressed; supply a matching codec`);
-    }
-    payload = await c.decompress(payload);
-  }
-  return JSON.parse(new TextDecoder().decode(payload));
-}
+class a extends Error{constructor(n){super(n),this.name="BackupError"}}const w="chatpanel-backup-encrypted",h=25e4,O=Object.freeze(["brotli","gzip","none"]),b=32768;function f(e){if(typeof Buffer<"u")return Buffer.from(e).toString("base64");let n="";for(let r=0;r<e.length;r+=b)n+=String.fromCharCode.apply(null,e.subarray(r,r+b));return btoa(n)}function l(e){const n=String(e||"");if(typeof Buffer<"u")return new Uint8Array(Buffer.from(n,"base64"));const r=atob(n),o=new Uint8Array(r.length);for(let t=0;t<r.length;t++)o[t]=r.charCodeAt(t);return o}const S=Object.freeze({name:"none",async compress(e){return e},async decompress(e){return e}});function g(e="gzip"){if(typeof CompressionStream>"u"||typeof DecompressionStream>"u")return null;try{new CompressionStream(e),new DecompressionStream(e)}catch{return null}const n=async(r,o)=>{const t=new Blob([r]).stream().pipeThrough(new o(e));return new Uint8Array(await new Response(t).arrayBuffer())};return Object.freeze({name:e,compress:r=>n(r,CompressionStream),decompress:r=>n(r,DecompressionStream)})}function C(e,n="brotli"){if(!e)return null;const r=n==="brotli"?[e.brotliCompressSync,e.brotliDecompressSync]:n==="gzip"?[e.gzipSync,e.gunzipSync]:null;if(!r||!r[0]||!r[1])return null;const[o,t]=r;return Object.freeze({name:n,async compress(c){return new Uint8Array(o(Buffer.from(c)))},async decompress(c){return new Uint8Array(t(Buffer.from(c)))}})}function x({zlib:e=null}={}){return e?C(e,"brotli")||C(e,"gzip")||S:g("brotli")||g("gzip")||S}async function k(e,n,r,o,t){const c=t||globalThis.crypto?.subtle;if(!c)throw new a("no WebCrypto available on this runtime");const i=await c.importKey("raw",new TextEncoder().encode(String(e)),"PBKDF2",!1,["deriveKey"]);return c.deriveKey({name:"PBKDF2",salt:n,iterations:r,hash:"SHA-256"},i,{name:"AES-GCM",length:256},!1,o)}function D(e){return!!e&&typeof e=="object"&&e.type===w}async function U(e,n,{codec:r=null,iterations:o=h,subtle:t=null,random:c=null,version:i=3}={}){if(!n)throw new a("a passphrase is required to encrypt a backup");const p=r||x(),s=c||(T=>globalThis.crypto.getRandomValues(new Uint8Array(T))),u=new TextEncoder().encode(JSON.stringify(e)),y=await p.compress(u),d=s(16),m=s(12),B=await k(n,d,o,["encrypt"],t),A=t||globalThis.crypto.subtle,E=new Uint8Array(await A.encrypt({name:"AES-GCM",iv:m},B,y));return{type:w,version:i,kdf:{iterations:o,salt:f(d)},cipher:"AES-GCM",compression:p.name,iv:f(m),ct:f(E)}}async function K(e,n,{codec:r=null,subtle:o=null}={}){if(!D(e))throw new a("not an encrypted ChatPanel backup");if(!n)throw new a("a passphrase is required to decrypt this backup");const t=l(e.kdf?.salt),c=Number(e.kdf?.iterations)||h,i=await k(n,t,c,["decrypt"],o),p=o||globalThis.crypto?.subtle;if(!p)throw new a("no WebCrypto available on this runtime");let s;try{s=new Uint8Array(await p.decrypt({name:"AES-GCM",iv:l(e.iv)},i,l(e.ct)))}catch{throw new a("wrong passphrase, or the backup file is corrupted")}const u=e.compression||"none";if(u!=="none"){const y=r||x();if(y.name!==u)throw new a(`this backup is ${u}-compressed; supply a matching codec`);s=await y.decompress(s)}return JSON.parse(new TextDecoder().decode(s))}export{a as BackupError,O as COMPRESSIONS,w as ENCRYPTED_TYPE,h as KDF_ITERATIONS,x as bestCodec,K as decryptBackup,U as encryptBackup,l as fromB64,S as identityCodec,D as isEncryptedBackup,C as nodeCodec,g as streamCodec,f as toB64};

package/board-tool.js

@@ -1,166 +1,3 @@
-// The `board` tool — how a member operates on the board.
-//
-// Every role gets it, whatever its grants: it reaches nothing outside the run. Four actions:
-// `read` the threads this member may see, `post` a note or draft in a thread, `reply` to a
-// post (agree, dispute with a ref, extend), and `ask` — open an ask thread and WAIT for a
-// person to answer it, from either client. Members do not chat freely: a post is typed, a
-// reply hangs off a post, and an ask pauses the member's own task, never the run.
-//
-// A fifth, `request`: a member hands a PIECE of its task to someone else — the runner turns
-// it into a sub-task with its own thread, offers it to the members that fit, posts it on the
-// job board when none does, and (by default) waits for it and returns its findings here.
-//
-// Bound per task: the member's role and task are fixed at bind time, so a member cannot post
-// as someone else, and its ask lands in its own task's context.
+import{boardText as g,POST_KINDS as x,ASK_TYPES as q}from"./team-board.js";import{normalizeRequest as T}from"./team-subtask.js";const b="board",S=10*6e4;function I(){return{name:b,annotations:{readOnlyHint:!1,destructiveHint:!1,idempotentHint:!1},description:`The team board — where the other members' work is, and where you speak to them and to the user. Actions: {"action":"read"} the threads you may see; {"action":"post","kind":"note|draft|question","text":"…","refs":["…"]} a post in your task's thread; {"action":"reply","postId":"…","kind":"note","text":"…","refs":["…"]} a reply to another member's post — agree, dispute with a ref, extend; {"action":"ask","type":"info|budget|permission|direction","text":"what you need and why","options":["…"]} asks the USER and waits for the answer (minutes). {"action":"request","title":"check the valuation","brief":"what to do and what done looks like","skills":["finance"],"grants":["web"],"wait":true} hands a piece of your task to another member (or, if none fits, to the job board): a sub-task with its own thread; with wait (default) you get its findings back here. Ask only when you are stuck — a fact you could not find, a choice only the user can make. Otherwise decide, say what you assumed, and go on. Request only work you should not do yourself — another skill, a tool you lack, or a second pair of eyes.`,parameters:{type:"object",properties:{action:{type:"string",enum:["read","post","reply","ask","request"]},kind:{type:"string",enum:x.filter(e=>e!=="finding"&&e!=="answer"&&e!=="decision")},text:{type:"string"},refs:{type:"array",items:{type:"string"}},postId:{type:"string",description:"For reply: the post to reply to."},threadId:{type:"string",description:"For post: another thread you may see (default: your task's)."},type:{type:"string",enum:[...q],description:"For ask."},options:{type:"array",items:{type:"string"},description:"For ask: choices to offer the user."},title:{type:"string",description:"For request: the sub-task in a few words."},brief:{type:"string",description:"For request: what to do and what done looks like."},skills:{type:"array",items:{type:"string"},description:"For request: skills it needs."},grants:{type:"array",items:{type:"string"},description:"For request: tools it needs — data, web, history, mcp, shell, fs:write, scm:read, scm:push, scm:pr."},wait:{type:"boolean",description:"For request: wait for it and get its findings back (default true); false queues it after your task."}},required:["action"]}}}const a=e=>JSON.stringify(e);function O({board:e,role:o,taskId:n,taskIds:s=null,waitFor:i=null,onAsk:u=null,onRequest:p=null,askTimeoutMs:l=S,signal:h=null}={}){const f=()=>e.threadForTask(n)||e.openThread({taskId:n,kind:"task",title:n,by:"runner"});return{id:"board",specs:[I()],system:"Other members' work is on the board (the `board` tool): read it before repeating a lookup, reply where you disagree, and ask the user only when you are stuck.",async execute(k,d){if(k!==b)return a({error:`Unknown tool: ${k}`});const c=String(d?.action||"");if(c==="read"){const r=g(e,{taskIds:s,role:o}),y=e.threads().filter(t=>t.kind!=="proposal").map(t=>({id:t.id,kind:t.kind,title:t.title,status:t.status,by:t.by,posts:t.posts}));return a({board:r||"Nothing on the board yet.",threads:y,postIds:e.posts().filter(t=>t.kind!=="answer").map(t=>({id:t.id,threadId:t.threadId,by:t.by,kind:t.kind,head:t.text.slice(0,80)}))})}const w=String(d?.text||"").trim();if(c==="post"||c==="reply"){if(!w)return a({error:`${c} needs text.`});let r=f().id,y=null;if(c==="reply"){const m=e.postById(String(d?.postId||""));if(!m)return a({error:`No post ${d?.postId}. Read the board for post ids.`});r=m.threadId,y=m.id}else d?.threadId&&e.thread(String(d.threadId))&&(r=String(d.threadId));const t=e.post({threadId:r,by:o,kind:d?.kind||"note",text:w,refs:d?.refs,replyTo:y});return a({posted:t.id,threadId:r,replyTo:y})}if(c==="ask"){if(!w)return a({error:"ask needs text — what you need and why."});if(typeof i!="function")return a({error:"This run cannot wait for the user. Decide on your best assumption and say what you assumed."});const{thread:r,post:y}=e.ask({taskId:n,by:o,type:d?.type,text:w,options:d?.options,timeoutMs:l});u?.(r,y);const t=await i(r.id,l,h);return a(t?{answered:!0,threadId:r.id,answer:t.text,by:t.by}:{answered:!1,threadId:r.id,hint:"No answer arrived in time. Proceed on your best assumption, say what you assumed, and note that the user did not answer."})}if(c==="request"){if(typeof p!="function")return a({error:"This run cannot delegate. Do the work yourself with the tools you have, and say what you could not do."});const r=T(d);if(!r.ok)return a({error:r.error});const y=e.post({threadId:f().id,by:o,kind:"request",text:`${r.request.title}${r.request.brief&&r.request.brief!==r.request.title?` — ${r.request.brief}`:""}`,refs:[]}),t=await p({...r.request,postId:y.id});return a(t||{error:"the request was not taken"})}return a({error:`Unknown action "${c}". Use read, post, reply, ask or request.`})}}}function _(){const e=new Map,o=new Map;return{wait(n,s,i=null){if(o.has(n)){const u=o.get(n);return o.delete(n),Promise.resolve(u)}return new Promise(u=>{let p=null;const l=f=>{clearTimeout(p),e.delete(n),i?.removeEventListener?.("abort",h),u(f)},h=()=>l(null);e.set(n,l),s>0&&(p=setTimeout(()=>l(null),s)),i?.addEventListener?.("abort",h,{once:!0})})},answer(n,s){const i={text:String(s?.text??s??""),by:s?.by||"person",id:s?.id||null},u=e.get(n);return u?u(i):o.set(n,i),!!u},get pending(){return[...e.keys()]}}}function E(e,o){if(!e)return{specs:[...o.specs],system:o.system,execute:(s,i)=>o.execute(s,i)};const n=new Set(o.specs.map(s=>s.name));return{...e,specs:[...o.specs,...(e.specs||[]).filter(s=>!n.has(s.name))],system:[o.system,e.system].filter(Boolean).join(`
 
-import { boardText, POST_KINDS, ASK_TYPES } from './team-board.js';
-import { normalizeRequest } from './team-subtask.js';
-
-export const BOARD_TOOL_NAME = 'board';
-export const DEFAULT_ASK_TIMEOUT_MS = 10 * 60_000;
-
-export function boardToolSpec() {
-  return {
-    name: BOARD_TOOL_NAME,
-    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
-    description:
-      'The team board — where the other members\' work is, and where you speak to them and to the user. '
-      + 'Actions: {"action":"read"} the threads you may see; '
-      + '{"action":"post","kind":"note|draft|question","text":"…","refs":["…"]} a post in your task\'s thread; '
-      + '{"action":"reply","postId":"…","kind":"note","text":"…","refs":["…"]} a reply to another member\'s post — agree, dispute with a ref, extend; '
-      + '{"action":"ask","type":"info|budget|permission|direction","text":"what you need and why","options":["…"]} asks the USER and waits for the answer (minutes). '
-      + '{"action":"request","title":"check the valuation","brief":"what to do and what done looks like","skills":["finance"],"grants":["web"],"wait":true} hands a piece of your task to another member (or, if none fits, to the job board): a sub-task with its own thread; with wait (default) you get its findings back here. '
-      + 'Ask only when you are stuck — a fact you could not find, a choice only the user can make. Otherwise decide, say what you assumed, and go on. Request only work you should not do yourself — another skill, a tool you lack, or a second pair of eyes.',
-    parameters: {
-      type: 'object',
-      properties: {
-        action: { type: 'string', enum: ['read', 'post', 'reply', 'ask', 'request'] },
-        kind: { type: 'string', enum: POST_KINDS.filter((k) => k !== 'finding' && k !== 'answer' && k !== 'decision') },
-        text: { type: 'string' },
-        refs: { type: 'array', items: { type: 'string' } },
-        postId: { type: 'string', description: 'For reply: the post to reply to.' },
-        threadId: { type: 'string', description: 'For post: another thread you may see (default: your task\'s).' },
-        type: { type: 'string', enum: [...ASK_TYPES], description: 'For ask.' },
-        options: { type: 'array', items: { type: 'string' }, description: 'For ask: choices to offer the user.' },
-        title: { type: 'string', description: 'For request: the sub-task in a few words.' },
-        brief: { type: 'string', description: 'For request: what to do and what done looks like.' },
-        skills: { type: 'array', items: { type: 'string' }, description: 'For request: skills it needs.' },
-        grants: { type: 'array', items: { type: 'string' }, description: 'For request: tools it needs — data, web, history, mcp, shell, fs:write, scm:read, scm:push, scm:pr.' },
-        wait: { type: 'boolean', description: 'For request: wait for it and get its findings back (default true); false queues it after your task.' },
-      },
-      required: ['action'],
-    },
-  };
-}
-
-const json = (v) => JSON.stringify(v);
-
-/**
- * @param board     the run's live board (team-board.js createBoard)
- * @param role      the member's role id
- * @param taskId    the member's task
- * @param taskIds   the tasks this member may read (its dependencies, or null for all)
- * @param waitFor   `async (threadId, timeoutMs, signal) => { text, by } | null` — the runner's answer box
- * @param onAsk     `(thread, post) => void` — the runner marks the task waiting
- * @param onRequest `async ({ title, brief, needs, wait }) => result` — the runner turns a request
- *                  into a sub-task (team-subtask.js); absent, a member is told to do it itself
- */
-export function boardToolProvider({ board, role, taskId, taskIds = null, waitFor = null, onAsk = null, onRequest = null, askTimeoutMs = DEFAULT_ASK_TIMEOUT_MS, signal = null } = {}) {
-  const ownThread = () => board.threadForTask(taskId) || board.openThread({ taskId, kind: 'task', title: taskId, by: 'runner' });
-  return {
-    id: 'board',
-    specs: [boardToolSpec()],
-    system: 'Other members\' work is on the board (the `board` tool): read it before repeating a lookup, reply where you disagree, and ask the user only when you are stuck.',
-    async execute(name, input) {
-      if (name !== BOARD_TOOL_NAME) return json({ error: `Unknown tool: ${name}` });
-      const action = String(input?.action || '');
-      if (action === 'read') {
-        const text = boardText(board, { taskIds, role });
-        const threads = board.threads().filter((t) => t.kind !== 'proposal').map((t) => ({ id: t.id, kind: t.kind, title: t.title, status: t.status, by: t.by, posts: t.posts }));
-        return json({ board: text || 'Nothing on the board yet.', threads, postIds: board.posts().filter((p) => p.kind !== 'answer').map((p) => ({ id: p.id, threadId: p.threadId, by: p.by, kind: p.kind, head: p.text.slice(0, 80) })) });
-      }
-      const text = String(input?.text || '').trim();
-      if (action === 'post' || action === 'reply') {
-        if (!text) return json({ error: `${action} needs text.` });
-        let threadId = ownThread().id;
-        let replyTo = null;
-        if (action === 'reply') {
-          const target = board.postById(String(input?.postId || ''));
-          if (!target) return json({ error: `No post ${input?.postId}. Read the board for post ids.` });
-          threadId = target.threadId; replyTo = target.id;
-        } else if (input?.threadId && board.thread(String(input.threadId))) {
-          threadId = String(input.threadId);
-        }
-        const post = board.post({ threadId, by: role, kind: input?.kind || 'note', text, refs: input?.refs, replyTo });
-        return json({ posted: post.id, threadId, replyTo });
-      }
-      if (action === 'ask') {
-        if (!text) return json({ error: 'ask needs text — what you need and why.' });
-        if (typeof waitFor !== 'function') return json({ error: 'This run cannot wait for the user. Decide on your best assumption and say what you assumed.' });
-        const { thread, post } = board.ask({ taskId, by: role, type: input?.type, text, options: input?.options, timeoutMs: askTimeoutMs });
-        onAsk?.(thread, post);
-        const answer = await waitFor(thread.id, askTimeoutMs, signal);
-        if (!answer) return json({ answered: false, threadId: thread.id, hint: 'No answer arrived in time. Proceed on your best assumption, say what you assumed, and note that the user did not answer.' });
-        return json({ answered: true, threadId: thread.id, answer: answer.text, by: answer.by });
-      }
-      if (action === 'request') {
-        if (typeof onRequest !== 'function') return json({ error: 'This run cannot delegate. Do the work yourself with the tools you have, and say what you could not do.' });
-        const r = normalizeRequest(input);
-        if (!r.ok) return json({ error: r.error });
-        // The request is a post in the member's own thread — the record of who asked for what.
-        const post = board.post({ threadId: ownThread().id, by: role, kind: 'request', text: `${r.request.title}${r.request.brief && r.request.brief !== r.request.title ? ` — ${r.request.brief}` : ''}`, refs: [] });
-        const result = await onRequest({ ...r.request, postId: post.id });
-        return json(result || { error: 'the request was not taken' });
-      }
-      return json({ error: `Unknown action "${action}". Use read, post, reply, ask or request.` });
-    },
-  };
-}
-
-/**
- * The runner's answer box: `wait(threadId, ms, signal)` resolves when `answer(threadId, …)`
- * is called — by the host, from its own UI or from the run store's tail when the OTHER
- * client answered. An answer that arrives before anyone waits is kept.
- */
-export function createAnswerBox() {
-  const waiting = new Map(); // threadId -> resolve
-  const early = new Map(); // threadId -> answer
-  return {
-    wait(threadId, timeoutMs, signal = null) {
-      if (early.has(threadId)) { const a = early.get(threadId); early.delete(threadId); return Promise.resolve(a); }
-      return new Promise((resolve) => {
-        let timer = null;
-        const done = (v) => { clearTimeout(timer); waiting.delete(threadId); signal?.removeEventListener?.('abort', onAbort); resolve(v); };
-        const onAbort = () => done(null);
-        waiting.set(threadId, done);
-        if (timeoutMs > 0) timer = setTimeout(() => done(null), timeoutMs);
-        if (typeof timer?.unref === 'function') timer.unref();
-        signal?.addEventListener?.('abort', onAbort, { once: true });
-      });
-    },
-    answer(threadId, answer) {
-      const a = { text: String(answer?.text ?? answer ?? ''), by: answer?.by || 'person', id: answer?.id || null };
-      const w = waiting.get(threadId);
-      if (w) w(a); else early.set(threadId, a);
-      return !!w;
-    },
-    get pending() { return [...waiting.keys()]; },
-  };
-}
-
-/** The host's toolset with the board tool added — first, so it is read first. */
-export function withBoardTool(toolset, provider) {
-  if (!toolset) {
-    return {
-      specs: [...provider.specs], system: provider.system,
-      execute: (name, input) => provider.execute(name, input),
-    };
-  }
-  const own = new Set(provider.specs.map((s) => s.name));
-  return {
-    ...toolset,
-    specs: [...provider.specs, ...(toolset.specs || []).filter((s) => !own.has(s.name))],
-    system: [provider.system, toolset.system].filter(Boolean).join('\n\n'),
-    execute: (name, input, ...rest) => (own.has(name) ? provider.execute(name, input) : toolset.execute(name, input, ...rest)),
-  };
-}
+`),execute:(s,i,...u)=>n.has(s)?o.execute(s,i):e.execute(s,i,...u)}}export{b as BOARD_TOOL_NAME,S as DEFAULT_ASK_TIMEOUT_MS,O as boardToolProvider,I as boardToolSpec,_ as createAnswerBox,E as withBoardTool};

package/budget.js

@@ -1,116 +1 @@
-// A budget — the number a run may not exceed, and the record of what it spent.
-//
-// There was no spend cap anywhere. A live monitor is declared class C and starts model turns
-// for the length of a meeting; a spoken "keep an eye on X" arms that with nothing bounding
-// it; `jobs.js` caps a per-day job COUNT, not spend. The class declarations on every intent
-// and rule were made for exactly this, and nothing read them.
-//
-// A budget is a VALUE: declared on the thing that spends (a team, a schedule, a monitor),
-// charged by whatever runs it, and carried on the run record so the ledger can say what a
-// run cost in the same units it was capped in. Four dimensions, because the expensive thing
-// differs by executor: tokens and calls for a model, wall time for an agent that thinks for
-// minutes, cost when the gateway can report it. Any dimension may be absent; an absent one is
-// not enforced. A budget with NO dimension is not a budget — `validateBudget` refuses it, and
-// a team without one does not run (F8, O1).
-//
-// Pure. `now` is injected so a wall-time cap is testable.
-
-export const BUDGET_DIMENSIONS = Object.freeze(['tokens', 'calls', 'ms', 'usd']);
-
-export class BudgetError extends Error {
-  constructor(code, message) { super(message); this.name = 'BudgetError'; this.code = code; }
-}
-
-/** `{ ok, errors }` — a budget must cap at least one thing, and every cap must be a positive number. */
-export function validateBudget(b) {
-  const errors = [];
-  if (!b || typeof b !== 'object') return { ok: false, errors: ['budget must be an object'] };
-  let any = false;
-  for (const k of BUDGET_DIMENSIONS) {
-    if (b[k] === undefined || b[k] === null) continue;
-    const n = Number(b[k]);
-    if (!Number.isFinite(n) || n <= 0) errors.push(`${k}: a positive number`);
-    else any = true;
-  }
-  for (const k of Object.keys(b)) if (!BUDGET_DIMENSIONS.includes(k)) errors.push(`${k}: not a budget dimension (${BUDGET_DIMENSIONS.join(', ')})`);
-  if (!any) errors.push('a budget must cap at least one of tokens, calls, ms, usd');
-  return { ok: errors.length === 0, errors };
-}
-
-/** Only the declared dimensions, as numbers. */
-export function normalizeBudget(b) {
-  const out = {};
-  for (const k of BUDGET_DIMENSIONS) {
-    const n = Number(b?.[k]);
-    if (Number.isFinite(n) && n > 0) out[k] = n;
-  }
-  return out;
-}
-
-/**
- * The usage a model call reports, in the shapes the providers use, as one record:
- * `{ tokens, calls, usd }`. `ms` is measured by the budget itself.
- */
-export function usageOf(u = {}) {
-  const tokens = Number(u.tokens ?? u.total_tokens ?? ((Number(u.input_tokens ?? u.prompt_tokens) || 0) + (Number(u.output_tokens ?? u.completion_tokens) || 0)));
-  return { tokens: Number.isFinite(tokens) ? tokens : 0, calls: Number(u.calls ?? 1) || 0, usd: Number(u.usd ?? u.cost) || 0 };
-}
-
-/**
- * A live budget for one run.
- *
- *   charge(usage)        add a model call's usage; returns what is left
- *   canAfford(estimate)  false when an estimated call would cross a cap — ask BEFORE calling
- *   exhausted()          the dimension that ran out, or null
- *   snapshot()           { cap, spent, remaining, exhausted } for the run record and the meter
- */
-export function createBudget(declared, { now = () => Date.now() } = {}) {
-  const v = validateBudget(declared);
-  if (!v.ok) throw new BudgetError('INVALID', v.errors.join('; '));
-  const cap = { ...normalizeBudget(declared) };
-  const startedAt = now();
-  const spent = { tokens: 0, calls: 0, usd: 0 };
-  const elapsed = () => now() - startedAt;
-  const remaining = () => {
-    const out = {};
-    for (const k of BUDGET_DIMENSIONS) {
-      if (cap[k] === undefined) continue;
-      out[k] = Math.max(0, cap[k] - (k === 'ms' ? elapsed() : spent[k]));
-    }
-    return out;
-  };
-  const exhausted = () => {
-    for (const k of BUDGET_DIMENSIONS) {
-      if (cap[k] === undefined) continue;
-      if ((k === 'ms' ? elapsed() : spent[k]) >= cap[k]) return k;
-    }
-    return null;
-  };
-  return {
-    cap,
-    charge(usage) {
-      const u = usageOf(usage);
-      spent.tokens += u.tokens; spent.calls += u.calls; spent.usd += u.usd;
-      return remaining();
-    },
-    canAfford(estimate = {}) {
-      if (exhausted()) return false;
-      const e = usageOf({ calls: 1, ...estimate });
-      for (const k of ['tokens', 'calls', 'usd']) {
-        if (cap[k] !== undefined && spent[k] + e[k] > cap[k]) return false;
-      }
-      return true;
-    },
-    remaining,
-    exhausted,
-    /** A person raised the cap mid-run (a budget ask answered "allow"): by a factor, once. */
-    raise(factor = 1.5) {
-      const f = Math.max(1, Number(factor) || 1);
-      for (const k of Object.keys(cap)) if (cap[k] !== undefined) cap[k] = Math.ceil(cap[k] * f);
-      return { ...cap };
-    },
-    snapshot() {
-      return { cap, spent: { ...spent, ms: elapsed() }, remaining: remaining(), exhausted: exhausted() };
-    },
-  };
-}
+const i=Object.freeze(["tokens","calls","ms","usd"]);class k extends Error{constructor(n,r){super(r),this.name="BudgetError",this.code=n}}function p(t){const n=[];if(!t||typeof t!="object")return{ok:!1,errors:["budget must be an object"]};let r=!1;for(const e of i){if(t[e]===void 0||t[e]===null)continue;const f=Number(t[e]);!Number.isFinite(f)||f<=0?n.push(`${e}: a positive number`):r=!0}for(const e of Object.keys(t))i.includes(e)||n.push(`${e}: not a budget dimension (${i.join(", ")})`);return r||n.push("a budget must cap at least one of tokens, calls, ms, usd"),{ok:n.length===0,errors:n}}function b(t){const n={};for(const r of i){const e=Number(t?.[r]);Number.isFinite(e)&&e>0&&(n[r]=e)}return n}function m(t={}){const n=Number(t.tokens??t.total_tokens??(Number(t.input_tokens??t.prompt_tokens)||0)+(Number(t.output_tokens??t.completion_tokens)||0));return{tokens:Number.isFinite(n)?n:0,calls:Number(t.calls??1)||0,usd:Number(t.usd??t.cost)||0}}function h(t,{now:n=()=>Date.now()}={}){const r=p(t);if(!r.ok)throw new k("INVALID",r.errors.join("; "));const e={...b(t)},f=n(),c={tokens:0,calls:0,usd:0},a=()=>n()-f,l=()=>{const s={};for(const o of i)e[o]!==void 0&&(s[o]=Math.max(0,e[o]-(o==="ms"?a():c[o])));return s},d=()=>{for(const s of i)if(e[s]!==void 0&&(s==="ms"?a():c[s])>=e[s])return s;return null};return{cap:e,charge(s){const o=m(s);return c.tokens+=o.tokens,c.calls+=o.calls,c.usd+=o.usd,l()},canAfford(s={}){if(d())return!1;const o=m({calls:1,...s});for(const u of["tokens","calls","usd"])if(e[u]!==void 0&&c[u]+o[u]>e[u])return!1;return!0},remaining:l,exhausted:d,raise(s=1.5){const o=Math.max(1,Number(s)||1);for(const u of Object.keys(e))e[u]!==void 0&&(e[u]=Math.ceil(e[u]*o));return{...e}},snapshot(){return{cap:e,spent:{...c,ms:a()},remaining:l(),exhausted:d()}}}}export{i as BUDGET_DIMENSIONS,k as BudgetError,h as createBudget,b as normalizeBudget,m as usageOf,p as validateBudget};