@chatpanel/events 0.102.0 → 0.103.1

package/note-plan.js

@@ -1,113 +1,15 @@
-// Planning a goal into a note: the decomposition, the document it becomes, and who wrote
-// which part of it.
-//
-// "Plan this in a new note" is not one model call. A goal is decomposed into sub-tasks, each
-// sub-task is assigned a ROLE — research (needs facts, options, current information) or write
-// (drafting, structure, synthesis) — and each is then run by whichever member of the team
-// suits it. The note is rebuilt after every step, so the user watches a checklist fill in
-// rather than a spinner.
-//
-// What has to be shared is the SHAPE: the decomposition prompt and how its answer is read,
-// the document the tasks render into, and the authorship ledger that matches that document
-// character for character. What stays in the client is the orchestration — running the calls,
-// choosing the models, and painting the editor.
-//
-// THE LEDGER IS BUILT FROM THE SAME PARTS AS THE BODY, which is the whole reason `planParts`
-// exists rather than a template string. A plan note is written entirely by agents; attributing
-// it to "You" would be a lie the History tab then repeats forever. Building the text and the
-// run-list from one list of `{ author, text }` parts means the ledger cannot drift from the
-// document — it sums to its length by construction, which is the invariant every attribution
-// test asserts.
+import{mergeRuns as h}from"./attribution.js";const m=Object.freeze(["research","write"]),i=Object.freeze({planner:"Planner",research:"Researcher",write:"Writer"}),S='You are a planning orchestrator. Break the goal into 3–6 concrete sub-tasks. For each, pick a role: "research" (needs facts, options, prices, or current info — it will web + history search) or "write" (drafting, structure, synthesis). Return ONLY compact JSON: {"tasks":[{"title":"short title","role":"research|write","prompt":"a focused instruction for this sub-task"}]}',_=600,x=.2;function E(t,e){return`You are drafting ONE section of a plan for the goal "${t}". Write the section titled "${e?.title||""}". Instruction: ${e?.prompt||e?.title||""}. Be concrete and actionable — bullets, - [ ] tasks, or a small table for options. Output ONLY the section's markdown content (no heading, no preamble).`}const O=700,k=.5;function w(t,e="",r=6){let n=[];try{const s=JSON.parse((String(t||"").match(/\{[\s\S]*\}/)||["{}"])[0]);n=(Array.isArray(s.tasks)?s.tasks:[]).slice(0,r).map(a=>p(a))}catch{}return n=n.filter(s=>s.title||s.prompt),!n.length&&String(e).trim()&&(n=[p({title:f(e),role:"write",prompt:e})]),n}const p=t=>({title:String(t?.title||"Task").slice(0,80),role:t?.role==="research"?"research":"write",prompt:String(t?.prompt||t?.title||""),done:!1,working:!1,output:""});function f(t,e=60){return String(t||"").replace(/[#*_`>~[\]]/g,"").replace(/\s+/g," ").trim().slice(0,e)}function u(t,e){const r=Array.isArray(e)?e:[],n=r.filter(o=>o.done).length,s=r.map((o,c)=>`- [${o.done?"x":" "}] ${c+1}. ${o.title}${o.working?" — _working…_":""}`).join(`
+`),a=[{author:i.planner,text:`# ${t}
 
-import { mergeRuns } from './attribution.js';
+**Plan** — ${n}/${r.length} sub-tasks done
 
-/** Roles a sub-task can be assigned. Anything a model invents is coerced to `write`. */
-export const PLAN_ROLES = Object.freeze(['research', 'write']);
+${s}
 
-/** The authors a plan note's ledger can name — the team, not the user. */
-export const PLAN_AUTHORS = Object.freeze({ planner: 'Planner', research: 'Researcher', write: 'Writer' });
+---
 
-export const PLAN_DECOMPOSE_SYSTEM = 'You are a planning orchestrator. Break the goal into 3–6 concrete sub-tasks. For each, pick a role: "research" (needs facts, options, prices, or current info — it will web + history search) or "write" (drafting, structure, synthesis). Return ONLY compact JSON: {"tasks":[{"title":"short title","role":"research|write","prompt":"a focused instruction for this sub-task"}]}';
-export const PLAN_DECOMPOSE_MAX_TOKENS = 600;
-export const PLAN_DECOMPOSE_TEMPERATURE = 0.2;
+`}];return r.forEach((o,c)=>{const l=o.role==="research"?i.research:i.write;a.push({author:i.planner,text:`## ${c+1}. ${o.title}
 
-/** The instruction for ONE drafted section of a plan. */
-export function planSectionSystem(goal, task) {
-  return `You are drafting ONE section of a plan for the goal "${goal}". Write the section titled "${task?.title || ''}". Instruction: ${task?.prompt || task?.title || ''}. Be concrete and actionable — bullets, - [ ] tasks, or a small table for options. Output ONLY the section's markdown content (no heading, no preamble).`;
-}
-export const PLAN_SECTION_MAX_TOKENS = 700;
-export const PLAN_SECTION_TEMPERATURE = 0.5;
+`}),a.push({author:o.output?l:i.planner,text:o.output||(o.working?`_⏳ ${l} working…_`:"_pending_")}),a.push({author:i.planner,text:c<r.length-1?`
 
-/**
- * Read the decomposer's answer into tasks.
- *
- * Generous on purpose: this is a model returning JSON through whatever wrapper its provider
- * felt like adding, and a plan that fails because the answer arrived in a fenced block is a
- * plan that failed for no reason. The object is found inside the text, an unknown role
- * becomes `write`, and a completely unreadable answer falls back to ONE task carrying the
- * original goal — which still produces a useful note rather than an error.
- */
-export function parsePlanTasks(raw, goal = '', max = 6) {
-  let tasks = [];
-  try {
-    const json = JSON.parse((String(raw || '').match(/\{[\s\S]*\}/) || ['{}'])[0]);
-    tasks = (Array.isArray(json.tasks) ? json.tasks : []).slice(0, max).map((t) => makeTask(t));
-  } catch { /* fall through to the single-task plan */ }
-  tasks = tasks.filter((t) => t.title || t.prompt);
-  if (!tasks.length && String(goal).trim()) tasks = [makeTask({ title: planTitleFor(goal), role: 'write', prompt: goal })];
-  return tasks;
-}
-
-const makeTask = (t) => ({
-  title: String(t?.title || 'Task').slice(0, 80),
-  role: t?.role === 'research' ? 'research' : 'write',
-  prompt: String(t?.prompt || t?.title || ''),
-  done: false,
-  working: false,
-  output: '',
-});
-
-/** A goal reduced to something that reads as a title — markdown stripped, one line, capped. */
-export function planTitleFor(goal, max = 60) {
-  return String(goal || '').replace(/[#*_`>~[\]]/g, '').replace(/\s+/g, ' ').trim().slice(0, max);
-}
-
-/**
- * The plan note, as `{ author, text }` parts.
- *
- * A checklist at the top that fills in as the work lands — so the note is a progress report
- * at a glance — then one section per sub-task. A task with no output yet says which member is
- * working on it rather than showing an empty heading, because a heading with nothing under it
- * reads as a section that came back empty.
- */
-export function planParts(goal, tasks) {
-  const list = Array.isArray(tasks) ? tasks : [];
-  const done = list.filter((t) => t.done).length;
-  const checklist = list
-    .map((t, i) => `- [${t.done ? 'x' : ' '}] ${i + 1}. ${t.title}${t.working ? ' — _working…_' : ''}`)
-    .join('\n');
-  const parts = [{
-    author: PLAN_AUTHORS.planner,
-    text: `# ${goal}\n\n**Plan** — ${done}/${list.length} sub-tasks done\n\n${checklist}\n\n---\n\n`,
-  }];
-  list.forEach((t, i) => {
-    const who = t.role === 'research' ? PLAN_AUTHORS.research : PLAN_AUTHORS.write;
-    parts.push({ author: PLAN_AUTHORS.planner, text: `## ${i + 1}. ${t.title}\n\n` });
-    parts.push({
-      author: t.output ? who : PLAN_AUTHORS.planner,
-      text: t.output || (t.working ? `_⏳ ${who} working…_` : '_pending_'),
-    });
-    parts.push({ author: PLAN_AUTHORS.planner, text: i < list.length - 1 ? '\n\n' : '\n' });
-  });
-  return parts;
-}
-
-/** The plan note's markdown. */
-export function planBody(goal, tasks) {
-  return planParts(goal, tasks).map((p) => p.text).join('');
-}
-
-/** The authorship run-list for `planBody(goal, tasks)` — equal in length by construction. */
-export function planAttribution(goal, tasks, at = Date.now()) {
-  return mergeRuns(planParts(goal, tasks).map((p) => ({ len: p.text.length, author: p.author, at })));
-}
+`:`
+`})}),a}function A(t,e){return u(t,e).map(r=>r.text).join("")}function N(t,e,r=Date.now()){return h(u(t,e).map(n=>({len:n.text.length,author:n.author,at:r})))}export{i as PLAN_AUTHORS,_ as PLAN_DECOMPOSE_MAX_TOKENS,S as PLAN_DECOMPOSE_SYSTEM,x as PLAN_DECOMPOSE_TEMPERATURE,m as PLAN_ROLES,O as PLAN_SECTION_MAX_TOKENS,k as PLAN_SECTION_TEMPERATURE,w as parsePlanTasks,N as planAttribution,A as planBody,u as planParts,E as planSectionSystem,f as planTitleFor};

package/note-research.js

@@ -1,135 +1 @@
-// What a note is ABOUT, and whether a search result is actually related to it.
-//
-// A research pane beside a note answers two questions, and both are ranking problems rather
-// than retrieval ones. The retrieval is already shared (`sources-retrieval.js`, `rrf.js`) and
-// the corpus differs per client; what has to be identical is the JUDGEMENT — what words the
-// query is built from, and which results are close enough to show.
-//
-// THE FAILURE THIS EXISTS TO PREVENT IS A PANE FULL OF PLAUSIBLE, UNRELATED THINGS. Any
-// ranker returns its top N for any query, so a note containing "can you check the plan today"
-// retrieves the user's whole history ranked by nothing. Every result looks like a result. The
-// fix is two-sided: build the query from the note's content-bearing words, then require a real
-// overlap before showing anything. **Empty is better than irrelevant** — an empty pane is read
-// as "nothing yet", a full one as "these are related", and only one of those can be wrong.
-//
-// Extracted from the extension's `notes-util.js`, where it was already pure.
-
-/**
- * Words that carry no topic, dropped from every query and every relevance test.
- *
- * Beyond ordinary stop-words this drops NOTE-META and AGENT noise — claude, codex, agent,
- * research, question, answer, summarize, https, www — because a note that says "ask Claude to
- * research this" would otherwise be judged to be ABOUT Claude and research, and would match
- * every other note in which the user typed the same sentence.
- */
-const STOP = new Set(('the a an and or but for to of in on at by with from as is are was were be been being this that these those it its i you your my me we our they them he she his her can could would should will shall may might do does did done get got make made just like about into over under out up down off not no yes plan planning day today check please help note notes write writing claude code codex anthropic agent agents assistant research researcher question questions answer answers answered reply inline summary summarize source sources cite citation https http www com net org html url link links thing things using use used need needs want wants below above here there').split(/\s+/));
-
-/**
- * The content-bearing terms of a query — lowercased words of 4+ characters that are not
- * stop-words. Used to judge relevance, so it is about what the text IS, not how it is phrased.
- */
-export function salientTerms(q) {
-  const out = new Set();
-  for (const w of String(q || '').toLowerCase().match(/[a-z0-9][a-z0-9'-]{3,}/g) || []) {
-    if (!STOP.has(w)) out.add(w);
-  }
-  return out;
-}
-
-/**
- * A note's TOPIC terms, most-repeated first — what a good search query is built from.
- *
- * Ranked by FREQUENCY rather than position, because the words at the top of a note are
- * usually its scaffolding ("Notes from the meeting about…") while the words it keeps
- * returning to are its subject. Ties break toward the longer, more specific term.
- */
-export function topicTerms(text, n = 8) {
-  const freq = new Map();
-  for (const w of String(text || '').toLowerCase().match(/[a-z][a-z'-]{3,}/g) || []) {
-    if (STOP.has(w)) continue;
-    freq.set(w, (freq.get(w) || 0) + 1);
-  }
-  return [...freq.entries()]
-    .sort((a, b) => b[1] - a[1] || b[0].length - a[0].length)
-    .slice(0, n)
-    .map(([w]) => w);
-}
-
-/**
- * How related a result is to the query — 0 means "do not show this".
- *
- * A specific word (6+ characters) is worth twice a short one, and a WORKSPACE hit has to earn
- * its place: two matching terms, or one specific one. A single generic word in common is how
- * an unrelated note from March ends up in the pane.
- *
- * `web: true` relaxes that last rule, deliberately. A web result was fetched for a query the
- * user explicitly asked for, and re-gating it on snippet overlap drops valid hits whose
- * snippet happens to paraphrase — which is most of them.
- */
-export function researchRelevance(card, salient, { web = false } = {}) {
-  if (!salient || !salient.size) return 0;
-  const hay = `${card?.title || ''} ${card?.snippet || ''}`.toLowerCase();
-  let hits = 0;
-  let specific = 0;
-  let score = 0;
-  for (const t of salient) {
-    if (!hay.includes(t)) continue;
-    hits += 1;
-    score += t.length >= 6 ? 2 : 1;
-    if (t.length >= 6) specific += 1;
-  }
-  if (!hits) return 0;
-  if (web || hits >= 2 || specific >= 1) return score;
-  return 0;
-}
-
-/** The web query for a note: its title plus its topic terms, capped at a sane length. */
-export function webQuery(title, terms) {
-  return [String(title || ''), [...(terms || [])].slice(0, 8).join(' ')]
-    .filter(Boolean).join(' ').replace(/\s+/g, ' ').trim()
-    .slice(0, 120);
-}
-
-/** One line of a source, flattened — enough to recognise it, not enough to read instead. */
-export function researchSnippet(text = '', max = 160) {
-  return String(text).replace(/\s+/g, ' ').trim().slice(0, max);
-}
-
-/**
- * Rank and gate a set of candidate cards against the query.
- *
- * `{ kind, title, snippet, url, key }` in, the same objects out, ordered by relevance with
- * the irrelevant dropped and `dismissed` keys removed. Web cards keep their retrieval order
- * (the engine already ranked them and the user asked for them); workspace cards are re-ranked
- * on overlap, which is the gate described above.
- */
-export function rankResearchCards(cards, query, { dismissed = null, web = false } = {}) {
-  const salient = salientTerms(query);
-  const skip = dismissed instanceof Set ? dismissed : new Set(dismissed || []);
-  const kept = (Array.isArray(cards) ? cards : []).filter((c) => c && !skip.has(c.key ?? c.url));
-  if (web) return kept;
-  return kept
-    .map((c) => ({ c, s: researchRelevance(c, salient) }))
-    .filter((x) => x.s > 0)
-    .sort((a, b) => b.s - a.s)
-    .map((x) => x.c);
-}
-
-/**
- * Merge the two lanes into one shelf.
- *
- * Web first when the user explicitly asked for a web search — that is what they pressed —
- * then the grounded workspace hits, deduped by key across both.
- */
-export function mergeResearchLanes(webCards, localCards, limit = 12) {
-  const out = [];
-  const seen = new Set();
-  for (const c of [...(webCards || []), ...(localCards || [])]) {
-    const k = c?.key ?? c?.url;
-    if (!k || seen.has(k)) continue;
-    seen.add(k);
-    out.push(c);
-    if (out.length >= limit) break;
-  }
-  return out;
-}
+const c=new Set("the a an and or but for to of in on at by with from as is are was were be been being this that these those it its i you your my me we our they them he she his her can could would should will shall may might do does did done get got make made just like about into over under out up down off not no yes plan planning day today check please help note notes write writing claude code codex anthropic agent agents assistant research researcher question questions answer answers answered reply inline summary summarize source sources cite citation https http www com net org html url link links thing things using use used need needs want wants below above here there".split(/\s+/));function l(r){const e=new Set;for(const o of String(r||"").toLowerCase().match(/[a-z0-9][a-z0-9'-]{3,}/g)||[])c.has(o)||e.add(o);return e}function f(r,e=8){const o=new Map;for(const t of String(r||"").toLowerCase().match(/[a-z][a-z'-]{3,}/g)||[])c.has(t)||o.set(t,(o.get(t)||0)+1);return[...o.entries()].sort((t,s)=>s[1]-t[1]||s[0].length-t[0].length).slice(0,e).map(([t])=>t)}function h(r,e,{web:o=!1}={}){if(!e||!e.size)return 0;const t=`${r?.title||""} ${r?.snippet||""}`.toLowerCase();let s=0,a=0,i=0;for(const n of e)t.includes(n)&&(s+=1,i+=n.length>=6?2:1,n.length>=6&&(a+=1));return s&&(o||s>=2||a>=1)?i:0}function p(r,e){return[String(r||""),[...e||[]].slice(0,8).join(" ")].filter(Boolean).join(" ").replace(/\s+/g," ").trim().slice(0,120)}function w(r="",e=160){return String(r).replace(/\s+/g," ").trim().slice(0,e)}function g(r,e,{dismissed:o=null,web:t=!1}={}){const s=l(e),a=o instanceof Set?o:new Set(o||[]),i=(Array.isArray(r)?r:[]).filter(n=>n&&!a.has(n.key??n.url));return t?i:i.map(n=>({c:n,s:h(n,s)})).filter(n=>n.s>0).sort((n,u)=>u.s-n.s).map(n=>n.c)}function m(r,e,o=12){const t=[],s=new Set;for(const a of[...r||[],...e||[]]){const i=a?.key??a?.url;if(!(!i||s.has(i))&&(s.add(i),t.push(a),t.length>=o))break}return t}export{m as mergeResearchLanes,g as rankResearchCards,h as researchRelevance,w as researchSnippet,l as salientTerms,f as topicTerms,p as webQuery};

package/observability.js

@@ -1,119 +1 @@
-// observability.js — the contract for "who consumed what, when, and how much is stored".
-//
-// ChatPanel's data is reachable by more than one agent now: the side panel, and any CLI
-// (Codex, Claude Code, OpenCode…) wired to the gateway's MCP server. Once several agents
-// read your history and skills, you need to SEE that — which agent touched what, and how
-// much sits in each storage tier. That is one question with one answer shape, so it lives
-// here, not re-derived in every client. The extension renders it; the gateway records it;
-// a desktop/mobile app will do both against this same contract.
-//
-// Pure and dependency-free (the @chatpanel/events rule): identical code in browser ESM,
-// the gateway (Node) and a mobile JS runtime. No clock, no storage, no platform APIs —
-// the caller passes `ts`; the caller owns persistence.
-//
-// PRIVACY IS THE POINT of the redactor below. An access log that stored raw tool arguments
-// would quietly become a second copy of every search query — the exact PII we redact
-// everywhere else. So the note attached to each event is built from a per-tool WHITELIST of
-// non-sensitive fields; a search query's TEXT is never recorded, only that a search ran.
-
-export const ACCESS_LOG_VERSION = 1;
-
-// Default ring size — enough to see a working session's activity without unbounded growth.
-export const ACCESS_LOG_MAX = 500;
-
-// Per-tool whitelist: which argument fields are safe to keep in the human note. Anything not
-// listed here is dropped. Content-bearing fields (a search `query`) are deliberately ABSENT —
-// the tool name already says "a search happened"; the words searched are not logged.
-const SAFE_ARGS = {
-  // Metadata filters are safe to keep (they are not content) and useful to see in the log:
-  // "type=meeting since=7d". The search QUERY is deliberately absent — never recorded.
-  search_history: ['type', 'since', 'before', 'limit', 'offset'],
-  list_history: ['limit', 'offset'],
-  get_record: ['id', 'maxChars', 'offset'], // opaque record id + paging, not content
-  find_related: ['id', 'limit'],            // graph navigation from an opaque id
-  open_skill: ['skill'],                    // skill names are catalog identifiers, not PII
-  read_skill_file: ['skill', 'path'],
-  list_skills: ['limit'],
-};
-
-/**
- * A short, SAFE descriptor of a call's arguments for display. Never returns content that
- * could carry PII. Unknown tools get an empty note (the tool name is the only signal).
- */
-export function redactAccessArgs(tool, args) {
-  const allow = SAFE_ARGS[tool];
-  if (!allow || !args || typeof args !== 'object') return '';
-  const parts = [];
-  for (const key of allow) {
-    const v = args[key];
-    if (v === undefined || v === null || v === '') continue;
-    // Cap any string field so a long id/path can't smuggle content or blow up the row.
-    const s = typeof v === 'string' ? (v.length > 80 ? `${v.slice(0, 77)}…` : v) : String(v);
-    parts.push(`${key}=${s}`);
-  }
-  return parts.join(' ');
-}
-
-/**
- * Normalize one access into the record everything stores and renders. `client` is the calling
- * agent's self-reported name (MCP clientInfo) — untrusted, so it's coerced to a short string.
- */
-export function makeAccessEvent({ ts, client, tool, ok = true, ms, args, error } = {}) {
-  return {
-    v: ACCESS_LOG_VERSION,
-    ts: Number(ts) || 0,
-    client: shortStr(client, 'unknown', 60),
-    tool: shortStr(tool, 'unknown', 60),
-    ok: !!ok,
-    ms: Number.isFinite(ms) ? Math.max(0, Math.round(ms)) : null,
-    note: redactAccessArgs(tool, args),
-    error: error ? shortStr(error, '', 200) : '',
-  };
-}
-
-function shortStr(v, fallback, max) {
-  const s = (v == null ? '' : String(v)).trim() || fallback;
-  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
-}
-
-/**
- * A tiny fixed-capacity ring for access events. Pure and synchronous — the gateway keeps one
- * in memory and snapshots it for the dashboard; the caller decides whether/how to persist.
- */
-export function createAccessLog(max = ACCESS_LOG_MAX) {
-  const cap = Math.max(1, max | 0);
-  let buf = [];
-  return {
-    push(evt) { buf.push(evt); if (buf.length > cap) buf = buf.slice(buf.length - cap); return evt; },
-    // Newest first, optionally limited — the order a dashboard wants.
-    snapshot(limit) { const out = buf.slice().reverse(); return limit ? out.slice(0, limit) : out; },
-    get size() { return buf.length; },
-    clear() { buf = []; },
-  };
-}
-
-// ── Storage tiers ────────────────────────────────────────────────────────────────────────
-// One descriptor per place data lives: hot (browser), warm (local gateway), cold (cloud,
-// future). The dashboard renders a row per tier; a tier that isn't configured says so.
-
-export function makeStorageTier({ tier, label, present = true, records = null, bytes = null, newest = null, note = '' } = {}) {
-  return {
-    tier: String(tier || ''),
-    label: String(label || tier || ''),
-    present: !!present,
-    records: records == null ? null : Math.max(0, records | 0),
-    bytes: bytes == null ? null : Math.max(0, Number(bytes) || 0),
-    newest: newest == null ? null : Number(newest) || 0,
-    note: String(note || ''),
-  };
-}
-
-/** Human-friendly byte size. Binary units, one decimal above KB. */
-export function formatBytes(n) {
-  const b = Number(n);
-  if (!Number.isFinite(b) || b <= 0) return '0 B';
-  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-  let i = 0, v = b;
-  while (v >= 1024 && i < units.length - 1) { v /= 1024; i++; }
-  return `${i === 0 ? Math.round(v) : v.toFixed(1)} ${units[i]}`;
-}
+const f=1,a=500,u={search_history:["type","since","before","limit","offset"],list_history:["limit","offset"],get_record:["id","maxChars","offset"],find_related:["id","limit"],open_skill:["skill"],read_skill_file:["skill","path"],list_skills:["limit"]};function c(l,n){const t=u[l];if(!t||!n||typeof n!="object")return"";const e=[];for(const r of t){const i=n[r];if(i==null||i==="")continue;const s=typeof i=="string"?i.length>80?`${i.slice(0,77)}…`:i:String(i);e.push(`${r}=${s}`)}return e.join(" ")}function h({ts:l,client:n,tool:t,ok:e=!0,ms:r,args:i,error:s}={}){return{v:1,ts:Number(l)||0,client:o(n,"unknown",60),tool:o(t,"unknown",60),ok:!!e,ms:Number.isFinite(r)?Math.max(0,Math.round(r)):null,note:c(t,i),error:s?o(s,"",200):""}}function o(l,n,t){const e=(l==null?"":String(l)).trim()||n;return e.length>t?`${e.slice(0,t-1)}…`:e}function p(l=500){const n=Math.max(1,l|0);let t=[];return{push(e){return t.push(e),t.length>n&&(t=t.slice(t.length-n)),e},snapshot(e){const r=t.slice().reverse();return e?r.slice(0,e):r},get size(){return t.length},clear(){t=[]}}}function S({tier:l,label:n,present:t=!0,records:e=null,bytes:r=null,newest:i=null,note:s=""}={}){return{tier:String(l||""),label:String(n||l||""),present:!!t,records:e==null?null:Math.max(0,e|0),bytes:r==null?null:Math.max(0,Number(r)||0),newest:i==null?null:Number(i)||0,note:String(s||"")}}function m(l){const n=Number(l);if(!Number.isFinite(n)||n<=0)return"0 B";const t=["B","KB","MB","GB","TB"];let e=0,r=n;for(;r>=1024&&e<t.length-1;)r/=1024,e++;return`${e===0?Math.round(r):r.toFixed(1)} ${t[e]}`}export{a as ACCESS_LOG_MAX,f as ACCESS_LOG_VERSION,p as createAccessLog,m as formatBytes,h as makeAccessEvent,S as makeStorageTier,c as redactAccessArgs};

package/omni.js

@@ -1,125 +1 @@
-// THE COMMAND BAR — what one line of typing means.
-//
-// Every ChatPanel surface is growing the same input: a single field that searches the
-// corpus, asks the model, jumps to a subject, filters by tag, or runs a command. The
-// extension has an omni modal, the desktop has an ambient composer, mobile will have a
-// search sheet. If each decides on its own what `#atlas` means, muscle memory stops
-// transferring between them — which is the whole value of a command bar.
-//
-// So the GRAMMAR lives here and the surfaces only decide how to paint it. Pure string in,
-// structured intent out. No storage, no search, no model.
-//
-// WHY PREFIXES RATHER THAN A MODE PICKER: a picker costs a click before every query and has
-// to be reset afterwards. A prefix is typed in the same keystroke as the query and is
-// self-evident on screen. The set is deliberately tiny — five modes, each one character —
-// because a grammar nobody can recall is a grammar nobody uses.
-//
-// AMBIGUITY RESOLVES TOWARD SEARCH. Anything unrecognised is a search, never an error: a bar
-// that refuses input is worse than one that searches for a literal "?" .
-
-export const OMNI_MODES = Object.freeze(['search', 'ask', 'subject', 'tag', 'command']);
-
-/**
- * The grammar. `prefix` is what the user types; `hint` is what a surface shows in the
- * mode strip. Order is display order.
- */
-export const OMNI_GRAMMAR = Object.freeze([
-  Object.freeze({ mode: 'search', prefix: '', hint: 'search' }),
-  Object.freeze({ mode: 'ask', prefix: '?', hint: 'ask' }),
-  Object.freeze({ mode: 'subject', prefix: '@', hint: 'subject' }),
-  Object.freeze({ mode: 'tag', prefix: '#', hint: 'tag' }),
-  Object.freeze({ mode: 'command', prefix: '>', hint: 'command' }),
-]);
-
-const BY_PREFIX = new Map(OMNI_GRAMMAR.filter((g) => g.prefix).map((g) => [g.prefix, g.mode]));
-
-/**
- * Filters a surface may apply inside a search. Kept here so `type:note since:7d` means the
- * same thing in the extension's omni and the desktop's bar — and the same thing the
- * gateway's `search_history` already accepts.
- */
-const FILTER_KEYS = new Set(['type', 'since', 'before', 'in', 'limit']);
-
-/**
- * Parse one line.
- *
- * Returns `{ mode, query, prefix, filters, raw }`. `query` has the prefix and any recognised
- * `key:value` filters removed, so it is ready to hand to a search or a model verbatim.
- */
-export function parseOmni(input) {
-  const raw = String(input ?? '');
-  const trimmed = raw.trimStart();
-  const first = trimmed.slice(0, 1);
-  const mode = BY_PREFIX.get(first) || 'search';
-  const prefix = mode === 'search' ? '' : first;
-
-  // Only strip the prefix when it IS one — a search for "#" alone should still search.
-  let rest = prefix ? trimmed.slice(1) : trimmed;
-  rest = rest.replace(/^\s+/, '');
-
-  const { query, filters } = extractFilters(rest);
-  return { mode, prefix, query, filters, raw };
-}
-
-/**
- * Pull `key:value` pairs out of a query.
- *
- * A value may be quoted (`in:"cutover review"`). Unknown keys are LEFT IN the query rather
- * than dropped, because `http://example.com` and `note:` typed by mistake are both far more
- * likely than a user inventing a filter we forgot to implement.
- */
-export function extractFilters(text) {
-  const filters = {};
-  const kept = [];
-  // The `key:` prefix has to be part of the quoted alternative. Without it `\S+` matches
-  // `in:"cutover` first and the value loses everything after its first space.
-  const tokens = String(text || '').match(/(?:[A-Za-z]+:)?"[^"]*"|\S+/g) || [];
-
-  for (const tok of tokens) {
-    const m = /^([a-z]+):(.*)$/i.exec(tok);
-    if (m && FILTER_KEYS.has(m[1].toLowerCase())) {
-      const key = m[1].toLowerCase();
-      const value = m[2].replace(/^"|"$/g, '');
-      if (value) filters[key] = value;
-      continue;
-    }
-    kept.push(tok.replace(/^"|"$/g, ''));
-  }
-  return { query: kept.join(' ').trim(), filters };
-}
-
-/**
- * A relative duration (`7d`, `24h`, `30m`) or a date, resolved against an injected `now`.
- *
- * `now` is a parameter for the reason it is one in `loop.js`: a function that reads the
- * clock cannot be tested, and "since 7d" must mean the same span in every client.
- */
-export function resolveSince(value, now = Date.now()) {
-  const s = String(value || '').trim().toLowerCase();
-  if (!s) return 0;
-  if (s === 'today') { const d = new Date(now); d.setHours(0, 0, 0, 0); return d.getTime(); }
-  if (s === 'yesterday') { const d = new Date(now); d.setHours(0, 0, 0, 0); return d.getTime() - 86_400_000; }
-  const rel = /^(\d+)\s*([mhdw])$/.exec(s);
-  if (rel) {
-    const n = Number(rel[1]);
-    const unit = { m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000 }[rel[2]];
-    return now - n * unit;
-  }
-  const t = Date.parse(s);
-  return Number.isFinite(t) ? t : 0;
-}
-
-/** Does this line ask for a model turn? Surfaces use it to decide whether to warm a target. */
-export function wantsModel(parsed) {
-  return !!parsed && parsed.mode === 'ask';
-}
-
-/**
- * Is the line worth acting on yet? Guards the "search on every keystroke" path so a bare
- * prefix does not run an empty query against the whole corpus.
- */
-export function isActionable(parsed, { minChars = 2 } = {}) {
-  if (!parsed) return false;
-  if (parsed.mode === 'command') return parsed.query.length >= 1;
-  return parsed.query.length >= minChars;
-}
+const l=Object.freeze(["search","ask","subject","tag","command"]),f=Object.freeze([Object.freeze({mode:"search",prefix:"",hint:"search"}),Object.freeze({mode:"ask",prefix:"?",hint:"ask"}),Object.freeze({mode:"subject",prefix:"@",hint:"subject"}),Object.freeze({mode:"tag",prefix:"#",hint:"tag"}),Object.freeze({mode:"command",prefix:">",hint:"command"})]),m=new Map(f.filter(e=>e.prefix).map(e=>[e.prefix,e.mode])),u=new Set(["type","since","before","in","limit"]);function d(e){const n=String(e??""),r=n.trimStart(),o=r.slice(0,1),c=m.get(o)||"search",t=c==="search"?"":o;let s=t?r.slice(1):r;s=s.replace(/^\s+/,"");const{query:i,filters:a}=p(s);return{mode:c,prefix:t,query:i,filters:a,raw:n}}function p(e){const n={},r=[],o=String(e||"").match(/(?:[A-Za-z]+:)?"[^"]*"|\S+/g)||[];for(const c of o){const t=/^([a-z]+):(.*)$/i.exec(c);if(t&&u.has(t[1].toLowerCase())){const s=t[1].toLowerCase(),i=t[2].replace(/^"|"$/g,"");i&&(n[s]=i);continue}r.push(c.replace(/^"|"$/g,""))}return{query:r.join(" ").trim(),filters:n}}function x(e,n=Date.now()){const r=String(e||"").trim().toLowerCase();if(!r)return 0;if(r==="today"){const t=new Date(n);return t.setHours(0,0,0,0),t.getTime()}if(r==="yesterday"){const t=new Date(n);return t.setHours(0,0,0,0),t.getTime()-864e5}const o=/^(\d+)\s*([mhdw])$/.exec(r);if(o){const t=Number(o[1]),s={m:6e4,h:36e5,d:864e5,w:6048e5}[o[2]];return n-t*s}const c=Date.parse(r);return Number.isFinite(c)?c:0}function h(e){return!!e&&e.mode==="ask"}function b(e,{minChars:n=2}={}){return e?e.mode==="command"?e.query.length>=1:e.query.length>=n:!1}export{f as OMNI_GRAMMAR,l as OMNI_MODES,p as extractFilters,b as isActionable,d as parseOmni,x as resolveSince,h as wantsModel};

package/order.js

@@ -1,78 +1 @@
-// THE LINEARIZATION RULE — stated once, never varied.
-//
-//   Replay orders events by topological sort over `causes`, breaking ties by
-//   (host, seq) with hosts in lexicographic id order. Wall time is never consulted.
-//
-// This is what makes replay deterministic when two hosts append concurrently. A
-// timestamp is not an order: clocks skew, and two hosts can stamp the same millisecond.
-// `causes` gives a partial order; the tie-break makes it total; neither depends on a
-// clock, so the same set of events linearizes identically on every host, forever.
-//
-// Dangling causes (an id we do not hold, e.g. a partial export) are IGNORED rather than
-// fatal, so a sanitized or truncated trace still replays. A cycle is fatal, because it
-// means the log is corrupt.
-
-import { EventError } from './event.js';
-
-/** (host, seq) with hosts lexicographic — the deterministic tie-break. */
-export function compareEvents(a, b) {
-  if (a.host !== b.host) return a.host < b.host ? -1 : 1;
-  if (a.seq !== b.seq) return a.seq - b.seq;
-  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0; // total, for identical (host,seq)
-}
-
-/**
- * Deterministic topological linearization. Pure; input array is not mutated.
- * @throws EventError('CYCLE') if `causes` contains a cycle.
- */
-export function linearize(events) {
-  const byId = new Map();
-  for (const e of events) byId.set(e.id, e);
-
-  const indegree = new Map();
-  const dependents = new Map();
-  for (const e of events) {
-    const deps = e.causes.filter((c) => byId.has(c)); // dangling causes ignored
-    indegree.set(e.id, deps.length);
-    for (const d of deps) {
-      if (!dependents.has(d)) dependents.set(d, []);
-      dependents.get(d).push(e.id);
-    }
-  }
-
-  // Kahn's algorithm with a ready-set kept in (host, seq) order, so the output is a
-  // function of the event set alone and not of the input array's order.
-  const ready = events.filter((e) => indegree.get(e.id) === 0).sort(compareEvents);
-  const out = [];
-  while (ready.length > 0) {
-    const next = ready.shift();
-    out.push(next);
-    const kids = dependents.get(next.id);
-    if (!kids) continue;
-    let unlocked = false;
-    for (const kid of kids) {
-      const left = indegree.get(kid) - 1;
-      indegree.set(kid, left);
-      if (left === 0) { ready.push(byId.get(kid)); unlocked = true; }
-    }
-    if (unlocked) ready.sort(compareEvents);
-  }
-
-  if (out.length !== events.length) {
-    const stuck = events.filter((e) => !out.includes(e)).map((e) => e.id);
-    throw new EventError('CYCLE', 'causes contains a cycle', stuck);
-  }
-  return out;
-}
-
-/** True when `causes` never points forward within one host's own sequence. */
-export function causesAreWellFormed(events) {
-  const byId = new Map(events.map((e) => [e.id, e]));
-  for (const e of events) {
-    for (const c of e.causes) {
-      const cause = byId.get(c);
-      if (cause && cause.host === e.host && cause.seq >= e.seq) return false;
-    }
-  }
-  return true;
-}
+import{EventError as l}from"./event.js";function h(t,s){return t.host!==s.host?t.host<s.host?-1:1:t.seq!==s.seq?t.seq-s.seq:t.id<s.id?-1:t.id>s.id?1:0}function a(t){const s=new Map;for(const e of t)s.set(e.id,e);const o=new Map,c=new Map;for(const e of t){const n=e.causes.filter(i=>s.has(i));o.set(e.id,n.length);for(const i of n)c.has(i)||c.set(i,[]),c.get(i).push(e.id)}const r=t.filter(e=>o.get(e.id)===0).sort(h),f=[];for(;r.length>0;){const e=r.shift();f.push(e);const n=c.get(e.id);if(!n)continue;let i=!1;for(const d of n){const u=o.get(d)-1;o.set(d,u),u===0&&(r.push(s.get(d)),i=!0)}i&&r.sort(h)}if(f.length!==t.length){const e=t.filter(n=>!f.includes(n)).map(n=>n.id);throw new l("CYCLE","causes contains a cycle",e)}return f}function g(t){const s=new Map(t.map(o=>[o.id,o]));for(const o of t)for(const c of o.causes){const r=s.get(c);if(r&&r.host===o.host&&r.seq>=o.seq)return!1}return!0}export{g as causesAreWellFormed,h as compareEvents,a as linearize};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/events",
-  "version": "0.102.0",
+  "version": "0.103.1",
   "description": "The canonical ChatPanel event-log and capability contracts — typed durable facts, clock-free deterministic linearization, schema upcasting, and the invariants the replay harness asserts. Pure, dependency-free ESM shared by the ChatPanel extension, gateway and bridge.",
   "type": "module",
   "main": "index.js",
@@ -284,9 +284,6 @@
     "web-search.js",
     "widget.js"
   ],
-  "scripts": {
-    "test": "node --test tests/*.test.js"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/chatpanel/chatpanel-events.git"