@chatpanel/events 0.102.0 → 0.104.0

package/subject-kinds.js

@@ -1,5 +1 @@
-// The subject vocabulary, alone in a file so both halves of subject identity can name it
-// without either importing the other.
-
-/** What a subject can be. `title` is a record title someone linked to with [[…]]. */
-export const SUBJECT_KINDS = Object.freeze(['person', 'topic', 'tag', 'title']);
+const e=Object.freeze(["person","topic","tag","title"]);export{e as SUBJECT_KINDS};

package/subject-name.js

@@ -1,96 +1 @@
-// Naming a subject, and when one is big enough to deserve a page.
-//
-// The small, dependency-free half of subject identity: fold a name to its canonical form,
-// strip the decoration a directory hangs off it, and hold the evidence thresholds. Nothing
-// here resolves aliases, proposes merges or reaches for a Levenshtein — that is `entity.js`,
-// which imports this.
-//
-// The split is a load-time one, and it is the third time the lesson has come up here (see
-// `distance.js` and `redaction-tokens.js`). `knowledge.js` needs exactly `normalizeSubject`
-// to build a brief id, and the extension's brief store needs exactly `DEFAULT_THRESHOLD` —
-// and both are on the MV3 service worker's graph. Reaching them through `entity.js` put
-// entity resolution and merge suggestion on a worker that will never run either.
-
-import { SUBJECT_KINDS } from './subject-kinds.js';
-
-/**
- * A subject earns a brief with EVIDENCE, not on first sight (I-K4).
- *
- * PROVISIONAL. These numbers are the W0 measurement's whole point: `surveyCorpus()` reports
- * how many subjects clear them so they can be set from a real corpus instead of taste. Do
- * not treat them as decided until that report has been run.
- */
-export const DEFAULT_THRESHOLD = Object.freeze({ records: 3, mentions: 5 });
-
-/** Ceiling on the set of briefs, for the same reason memory.js caps memories. Provisional. */
-export const MAX_SUBJECTS = 500;
-/** Longest name we will treat as a subject — past this it is a sentence, not a subject. */
-export const MAX_SUBJECT_CHARS = 60;
-/**
- * Labels a meeting platform uses for the person holding the microphone.
- *
- * Zoom, Meet and Teams all write the local participant as "You" — so the user appears in
- * their own corpus under a name that is not a name, alongside however their colleagues'
- * clients spelled them. Resolving these needs one fact only the host has: who "you" IS.
- * `resolveSubjects` takes it rather than guessing, and with no `self` supplied these stay
- * unresolved instead of collapsing every meeting's local speaker into one fictional person.
- */
-export const SELF_LABELS = Object.freeze(['you', 'me', 'myself', 'yourself', 'i']);
-
-/**
- * Is this the platform's label for the local participant?
- *
- * Exported because two layers need the SAME exception and getting the order wrong is subtle:
- * a self-label fails `isSubjectCandidate` (it is a pronoun), so any pass that filters
- * candidacy BEFORE `resolveSubjects` can fold it has already thrown the user away. `curate.js
- * mentionsFrom` keeps them for exactly this reason and lets resolution decide.
- */
-export function isSelfLabel(name) {
-  return SELF_LABELS.includes(normalizeSubject(name));
-}
-
-/**
- * Strip the decoration a directory or a conference client hangs off a person's name.
- *
- * The same human arrives as "Alex Rivera", "Alex Rivera (ACME)", "Alex Rivera - Host" and
- * "Alex Rivera (he/him)" depending on which client wrote the label. The part in parentheses
- * or after a dash is an org, a role or a pronoun set — decoration, never identity — so it is
- * removed before folding.
- *
- * NOT removed for non-person subjects: "Migration (Phase 2)" is a different topic from
- * "Migration", where "Alex Rivera (ACME)" is not a different person from "Alex Rivera".
- */
-export function stripQualifiers(name) {
-  return String(name ?? '')
-    .replace(/\s*[([{][^)\]}]*[)\]}]\s*/g, ' ')   // (ACME), [external], {guest}
-    .replace(/\s+[-–—|·,]\s+.*$/, '')             // - Host, — Guest, | ACME
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-/**
- * Fold a name to its canonical form: lowercase, Unicode-aware, separators collapsed.
- *
- * Spaces survive as spaces (unlike normalizeTag, which folds them to '-') because a person's
- * name is read back to the user and "alex rivera" has to be recognisable as one.
- */
-export function normalizeSubject(name) {
-  const raw = String(name ?? '').normalize('NFKC').trim().replace(/^[#@]+/, '');
-  if (!raw) return '';
-  return raw
-    .toLowerCase()
-    .replace(/[^\p{L}\p{N}]+/gu, ' ')
-    .trim()
-    .slice(0, MAX_SUBJECT_CHARS)
-    .trim();
-}
-/** `person:alex rivera` — the identity a brief is filed under. '' when nothing survives. */
-export function subjectKey(kind, name) {
-  const norm = normalizeSubject(name);
-  if (!norm || !SUBJECT_KINDS.includes(kind)) return '';
-  return `${kind}:${norm}`;
-}
-/** Tokens of a canonical name. */
-export function subjectTokens(name) {
-  const norm = normalizeSubject(name);
-  return norm ? norm.split(' ').filter(Boolean) : [];
-}
+import{SUBJECT_KINDS as n}from"./subject-kinds.js";const u=Object.freeze({records:3,mentions:5}),p=500,s=60,c=Object.freeze(["you","me","myself","yourself","i"]);function l(e){return c.includes(t(e))}function f(e){return String(e??"").replace(/\s*[([{][^)\]}]*[)\]}]\s*/g," ").replace(/\s+[-–—|·,]\s+.*$/,"").replace(/\s+/g," ").trim()}function t(e){const r=String(e??"").normalize("NFKC").trim().replace(/^[#@]+/,"");return r?r.toLowerCase().replace(/[^\p{L}\p{N}]+/gu," ").trim().slice(0,s).trim():""}function m(e,r){const o=t(r);return!o||!n.includes(e)?"":`${e}:${o}`}function S(e){const r=t(e);return r?r.split(" ").filter(Boolean):[]}export{u as DEFAULT_THRESHOLD,p as MAX_SUBJECTS,s as MAX_SUBJECT_CHARS,c as SELF_LABELS,l as isSelfLabel,t as normalizeSubject,f as stripQualifiers,m as subjectKey,S as subjectTokens};

package/sync-plan.js

@@ -1,213 +1 @@
-// RECONCILING TWO COPIES OF THE LIBRARY — the pure half of two-way sync.
-//
-// The extension holds the corpus in chrome.storage; a desktop app holds it in SQLite; the
-// gateway holds a warm copy. Each pair of those needs the same question answered: given what
-// I have and what you have, what do I pull, what do I push, and what genuinely conflicts.
-//
-// It lives here because the answer must not depend on WHO is asking. If the extension
-// decided ties one way and the desktop the other, two clients syncing the same record would
-// flap — each would keep "winning" and re-pushing, forever. One rule, both sides.
-//
-// WHAT MAKES THIS SAFE TO RUN REPEATEDLY: the plan is a pure function of two index lists, so
-// applying it and re-planning yields an empty plan. That is the property to hold on to —
-// every bug in a sync engine eventually shows up as "running it twice does something".
-//
-// TOMBSTONES ARE NOT OPTIONAL, and this is the sharpest edge in the module. A record that is
-// merely ABSENT from one side is indistinguishable from one that side has never seen. So a
-// deletion has to be representable as a value — `deletedAt` — or "delete" and "not synced
-// yet" are the same input with opposite correct answers. The extension's warm sync already
-// hit this and chose, deliberately, not to tombstone (a missing browser record may simply
-// have aged out of IndexedDB while remaining in a backup). That choice is why warm sync is
-// one-way. A two-way sync cannot make it.
-//
-// Pure over arrays of `{ id, updatedAt, deletedAt }`. No storage, no network, no clock —
-// `now` is never consulted, because a plan that depends on when you asked is not a plan.
-
-export class SyncError extends Error {
-  constructor(message) { super(message); this.name = 'SyncError'; }
-}
-
-/**
- * How far apart two timestamps may be and still count as "the same edit".
- *
- * Clocks on two machines are not identical, and a record copied between them can come back
- * with a millisecond of drift. Without a tolerance every round trip looks like a fresh edit
- * and the two sides push at each other indefinitely.
- */
-export const CLOCK_TOLERANCE_MS = 1000;
-
-const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
-
-/** The comparable stamp of a record: when it last changed, deleted or not. */
-export function stampOf(entry) {
-  if (!entry) return 0;
-  return Math.max(num(entry.updatedAt), num(entry.deletedAt));
-}
-
-function indexById(entries) {
-  const m = new Map();
-  for (const e of entries || []) {
-    if (!e || !e.id) continue;
-    // Later duplicates win: a caller concatenating pages should not be punished for it.
-    m.set(e.id, e);
-  }
-  return m;
-}
-
-/**
- * Decide one record. Exported because it is the whole rule, and a caller that streams
- * records one at a time should not have to build two full indexes to use it.
- *
- * Returns one of:
- *   'none'     — the two sides agree
- *   'pull'     — remote is newer; take theirs
- *   'push'     — local is newer, or remote has never seen it; send ours
- *   'conflict' — both changed since the last common state and neither is clearly newer
- */
-/**
- * Is this entry the COMPLETE record, or a flattened stand-in for one?
- *
- * A warm/indexed copy of a chat is its transcript as one blob of text: enough to search,
- * read and cite, and not enough to open as a conversation. Callers stamp that with
- * `meta.lossy` (or `meta.origin: 'warm'`); a stamp row may carry `lossy` directly, because a
- * sync plan works on stamps and should not have to load bodies to make this decision.
- *
- * Returns 1 for full fidelity and 0 for lossy — an ordering, so the rule below is a
- * comparison rather than a pile of branches.
- */
-export function fidelityOf(entry) {
-  if (!entry) return 0;
-  if (entry.lossy === true) return 0;
-  const meta = entry.meta || null;
-  if (meta && (meta.lossy === true || meta.origin === 'warm')) return 0;
-  return 1;
-}
-
-export function decide(local, remote, { tolerance = CLOCK_TOLERANCE_MS, base = null } = {}) {
-  if (!local && !remote) return 'none';
-  if (!remote) return 'push';
-  if (!local) return 'pull';
-
-  const l = stampOf(local);
-  const r = stampOf(remote);
-
-  // FIDELITY BEATS RECENCY, BOTH WAYS.
-  //
-  // The two sides are not always describing the same kind of thing. One may hold the whole
-  // record and the other a flattened stand-in for it — and those two arrive with the SAME
-  // timestamp, because they describe the same moment. Last-write-wins then reads them as
-  // equal and answers 'none', which is how a complete conversation restored from a backup
-  // gets silently refused in favour of a search-index summary of itself that is already
-  // there. The user restores, is told it worked, and still sees the flattened copy.
-  //
-  // So a complete record always wins over a partial one whatever the clocks say. The
-  // converse — never let a partial overwrite a complete one — is the same rule read the
-  // other way, and it is the one callers usually remember to enforce by hand.
-  //
-  // DELETIONS ARE EXEMPT. A tombstone carries no body, so it is 'lossy' by any measure, and
-  // resurrecting deleted records because their replacement looks fuller would be a far worse
-  // bug than the one this fixes. When either side is deleted, the stamps decide.
-  const deleted = num(local.deletedAt) > 0 || num(remote.deletedAt) > 0;
-  if (!deleted) {
-    const lf = fidelityOf(local);
-    const rf = fidelityOf(remote);
-    if (lf !== rf) return rf > lf ? 'pull' : 'push';
-  }
-
-  const delta = l - r;
-  if (Math.abs(delta) <= tolerance) return 'none';
-
-  // With a recorded base (what both sides last agreed on) we can tell a genuine divergence
-  // from a simple fast-forward: a conflict is when BOTH moved. Without a base the newer
-  // stamp wins, which is last-write-wins and is all a first sync can honestly offer.
-  if (base) {
-    const b = stampOf(base);
-    const localMoved = l - b > tolerance;
-    const remoteMoved = r - b > tolerance;
-    if (localMoved && remoteMoved) return 'conflict';
-  }
-  return delta > 0 ? 'push' : 'pull';
-}
-
-/**
- * Plan a full two-way reconcile.
- *
- * `bases` is optional — a map (or array) of the stamps both sides last agreed on, which is
- * what upgrades last-write-wins into real conflict detection. Callers that keep a sync
- * journal pass it; callers that do not get LWW and no false conflicts.
- *
- * Returns `{ pull, push, conflicts, unchanged }` as arrays of ids, plus `counts`.
- */
-export function planSync(localEntries, remoteEntries, {
-  tolerance = CLOCK_TOLERANCE_MS, bases = null,
-} = {}) {
-  const local = indexById(localEntries);
-  const remote = indexById(remoteEntries);
-  const baseMap = bases instanceof Map ? bases : indexById(bases);
-
-  const pull = [];
-  const push = [];
-  const conflicts = [];
-  let unchanged = 0;
-
-  for (const id of new Set([...local.keys(), ...remote.keys()])) {
-    const verdict = decide(local.get(id), remote.get(id), { tolerance, base: baseMap.get(id) || null });
-    if (verdict === 'pull') pull.push(id);
-    else if (verdict === 'push') push.push(id);
-    else if (verdict === 'conflict') conflicts.push(id);
-    else unchanged += 1;
-  }
-
-  // Stable order so two runs over the same input produce byte-identical plans — which is
-  // what makes a plan diffable in a log and testable without sorting at every assertion.
-  pull.sort();
-  push.sort();
-  conflicts.sort();
-
-  return {
-    pull, push, conflicts, unchanged,
-    counts: { pull: pull.length, push: push.length, conflicts: conflicts.length, unchanged },
-  };
-}
-
-/** Nothing to do — the property a correct sync reaches and stays at. */
-export function isSettled(plan) {
-  return !!plan && plan.pull.length === 0 && plan.push.length === 0 && plan.conflicts.length === 0;
-}
-
-/**
- * Resolve a conflict by keeping both: the loser is preserved under a new id rather than
- * overwritten.
- *
- * Silently discarding one side of a conflict is how a sync engine loses the paragraph
- * someone wrote on a plane. The caller supplies `newId` because id minting is a host
- * concern; this only decides WHAT the two resulting records are.
- */
-export function forkConflict(localRecord, remoteRecord, { newId, label = 'conflicted copy' } = {}) {
-  if (typeof newId !== 'function') throw new SyncError('forkConflict needs a newId() function');
-  const keep = stampOf(localRecord) >= stampOf(remoteRecord) ? localRecord : remoteRecord;
-  const fork = keep === localRecord ? remoteRecord : localRecord;
-  const parsedKind = String(fork.id || '').split(':')[0];
-  return {
-    keep,
-    fork: {
-      ...fork,
-      id: `${parsedKind}:${newId()}`,
-      title: `${fork.title || 'Untitled'} (${label})`,
-      meta: { ...(fork.meta || {}), conflictOf: keep.id },
-    },
-  };
-}
-
-/**
- * Fold applied ids back into a base map, so the NEXT plan can tell a fast-forward from a
- * divergence. Returns a new Map; the input is not mutated.
- */
-export function advanceBases(bases, applied = []) {
-  const next = bases instanceof Map ? new Map(bases) : indexById(bases);
-  for (const entry of applied) {
-    if (!entry || !entry.id) continue;
-    next.set(entry.id, { id: entry.id, updatedAt: num(entry.updatedAt), deletedAt: num(entry.deletedAt) });
-  }
-  return next;
-}
+class m extends Error{constructor(n){super(n),this.name="SyncError"}}const g=1e3,l=t=>Number.isFinite(Number(t))?Number(t):0;function p(t){return t?Math.max(l(t.updatedAt),l(t.deletedAt)):0}function a(t){const n=new Map;for(const e of t||[])!e||!e.id||n.set(e.id,e);return n}function M(t){if(!t||t.lossy===!0)return 0;const n=t.meta||null;return n&&(n.lossy===!0||n.origin==="warm")?0:1}function A(t,n,{tolerance:e=g,base:o=null}={}){if(!t&&!n)return"none";if(!n)return"push";if(!t)return"pull";const s=p(t),i=p(n);if(!(l(t.deletedAt)>0||l(n.deletedAt)>0)){const r=M(t),u=M(n);if(r!==u)return u>r?"pull":"push"}const c=s-i;if(Math.abs(c)<=e)return"none";if(o){const r=p(o),u=s-r>e,d=i-r>e;if(u&&d)return"conflict"}return c>0?"push":"pull"}function y(t,n,{tolerance:e=g,bases:o=null}={}){const s=a(t),i=a(n),h=o instanceof Map?o:a(o),c=[],r=[],u=[];let d=0;for(const f of new Set([...s.keys(),...i.keys()])){const x=A(s.get(f),i.get(f),{tolerance:e,base:h.get(f)||null});x==="pull"?c.push(f):x==="push"?r.push(f):x==="conflict"?u.push(f):d+=1}return c.sort(),r.sort(),u.sort(),{pull:c,push:r,conflicts:u,unchanged:d,counts:{pull:c.length,push:r.length,conflicts:u.length,unchanged:d}}}function k(t){return!!t&&t.pull.length===0&&t.push.length===0&&t.conflicts.length===0}function S(t,n,{newId:e,label:o="conflicted copy"}={}){if(typeof e!="function")throw new m("forkConflict needs a newId() function");const s=p(t)>=p(n)?t:n,i=s===t?n:t,h=String(i.id||"").split(":")[0];return{keep:s,fork:{...i,id:`${h}:${e()}`,title:`${i.title||"Untitled"} (${o})`,meta:{...i.meta||{},conflictOf:s.id}}}}function w(t,n=[]){const e=t instanceof Map?new Map(t):a(t);for(const o of n)!o||!o.id||e.set(o.id,{id:o.id,updatedAt:l(o.updatedAt),deletedAt:l(o.deletedAt)});return e}export{g as CLOCK_TOLERANCE_MS,m as SyncError,w as advanceBases,A as decide,M as fidelityOf,S as forkConflict,k as isSettled,y as planSync,p as stampOf};

package/synthesis.js

@@ -1,123 +1,3 @@
-// SYNTHESIS — the first class-C claims: prose about a subject, written by a model.
-//
-// Everything a brief said until now was class R: a restatement of something a record
-// already held, with nothing to review. This is the layer the wiki pattern is actually
-// about — "what was decided about Atlas, and when did it change" — and it is exactly the
-// layer the community warned about: agent writing nobody reviewed compounds into confident
-// nonsense that a lint pass cannot tell apart from truth six months on (C2).
-//
-// So two rules do all the defending, and both are enforced here rather than promised:
-//
-//   I-K1  EVERY CLAIM CITES A RECORD IT WAS SHOWN. The model sees excerpts labelled with
-//         their ids and must attach at least one to each claim. A claim citing nothing, or
-//         citing an id that was not in the excerpt set, is REFUSED — not downgraded, not
-//         flagged, refused — because a citation a reader cannot open is worse than no claim.
-//   I-K3  NOTHING HERE PROMOTES. `claimsFromSynthesis` produces claims in state `proposed`
-//         and `promotion.js` is the only path to `promoted`. There is no flag to skip it.
-//
-// The model call itself is not made here (no network, per the package rule). This module
-// owns the SHAPE — one schema, one prompt, one parser — so the extension, the gateway and a
-// desktop client ask the same question and read the answer the same way. It is written as
-// a single appointment on purpose: a team appointment (W7 — drafters that must agree) has
-// the same contract, with `converge()` in promotion.js deciding what to propose.
-
-import { defineSchema, describeSchema } from './structured.js';
-
-export const MAX_SYNTHESIS_CLAIMS = 8;
-export const MAX_CLAIM_CHARS = 240;
-export const MAX_EXCERPT_CHARS = 1200;
-export const MAX_EXCERPTS = 24;
-
-export const SYNTHESIS_SCHEMA = defineSchema({
-  name: 'brief_synthesis',
-  purpose: 'What the records establish about one subject, as separate cited claims.',
-  fields: {
-    claims: {
-      type: 'object[]', maxItems: MAX_SYNTHESIS_CLAIMS,
-      describe: 'the things the records establish about the subject — decisions, roles, status, changes — one per entry, each cited',
-      fields: {
-        text: { type: 'string', required: true, max: MAX_CLAIM_CHARS, describe: 'one specific claim in plain prose, past tense for events, present for standing facts' },
-        refs: { type: 'string[]', required: true, maxItems: 6, describe: 'the record ids (exactly as labelled, e.g. meeting:m_12) that support this claim — at least one, only ones you were shown' },
-        when: { type: 'string', max: 10, describe: 'YYYY-MM-DD of the record that establishes it, if one does' },
-      },
-    },
-    summary: { type: 'string', max: 600, describe: 'two or three sentences of what a colleague should know about this subject right now' },
-  },
-  // "The records do not establish anything beyond what is already listed" is a legitimate
-  // answer and must not be read as a failure — read as one, a caller might fall back to the
-  // model's prose without the schema, which is the exact unstructured path this replaces.
-  nothing: { claims: [], summary: '' },
-});
-
-/**
- * The prompt. The subject, what the deterministic layer already says (so the model adds to
- * it rather than restating it), and the excerpts it may cite — each labelled with the id it
- * must use. Excerpts are capped per record and in count, because this is a bounded call by
- * design (I-K4): a subject with two hundred records gets its most recent two dozen, and a
- * later pass can take the rest.
- */
-export function synthesisPrompt({ subject, existing = [], excerpts = [] } = {}) {
-  const name = String(subject?.name || 'the subject');
-  const kind = String(subject?.kind || 'subject');
-  const shown = excerpts.slice(0, MAX_EXCERPTS);
-  const lines = [
-    `Subject: ${name} (${kind})${subject?.aliases?.length ? ` — also written as ${subject.aliases.join(', ')}` : ''}.`,
-    '',
-    'Already established (do not repeat these):',
-    ...(existing.length ? existing.map((c) => `- ${c}`) : ['- nothing yet']),
-    '',
-    `Records you may cite (${shown.length}). Cite ONLY these ids, exactly as written:`,
-    ...shown.map((e) => `[${e.id}] ${e.title || ''}${e.date ? ` (${e.date})` : ''}\n${String(e.text || '').slice(0, MAX_EXCERPT_CHARS)}`),
-    '',
-    'Write what these records ESTABLISH about the subject: decisions, ownership, status, and',
-    'anything that changed over time (say what it was before and after). Every claim must cite',
-    'at least one of the ids above. If the records establish nothing beyond what is already',
-    'listed, return no claims.',
-    '',
-    describeSchema(SYNTHESIS_SCHEMA),
-  ];
-  return lines.join('\n');
-}
-
-/**
- * The model's answer → claims a brief could carry, with the refusals listed.
- *
- * `knownIds` is the set of ids the model was shown. A claim citing anything outside it is
- * refused whole — the model invented or misremembered a citation, and a claim we cannot
- * trace is a claim we cannot keep (I-K1). `hashOf(id)` gives the record's drift hash so the
- * ref can later say "this record changed since I cited it".
- *
- * Returns claims in state `proposed`, class C. There is no argument that produces
- * `promoted`; that is promotion.js's job and nobody else's (I-K3).
- */
-export function claimsFromSynthesis(value, { knownIds, hashOf = () => 'unhashed', now = 0, newId = null } = {}) {
-  const known = knownIds instanceof Set ? knownIds : new Set(knownIds || []);
-  const out = [];
-  const refused = [];
-  let n = 0;
-  const id = () => (newId ? newId() : `s${now}-${(n += 1)}`);
-  for (const raw of value?.claims || []) {
-    const text = String(raw?.text || '').trim();
-    const refs = [...new Set((raw?.refs || []).map((r) => String(r || '').trim()).filter(Boolean))];
-    if (!text) { refused.push({ text, why: 'empty' }); continue; }
-    if (!refs.length) { refused.push({ text, why: 'no citation' }); continue; }
-    const unknown = refs.filter((r) => !known.has(r));
-    if (unknown.length) { refused.push({ text, why: `cites a record it was not shown: ${unknown.join(', ')}` }); continue; }
-    out.push({
-      id: id(),
-      kind: 'synthesis',
-      text: text.slice(0, MAX_CLAIM_CHARS),
-      refs: refs.map((r) => {
-        const idx = r.indexOf(':');
-        return { kind: r.slice(0, idx), id: r.slice(idx + 1), hash: hashOf(r) };
-      }),
-      when: /^\d{4}-\d{2}-\d{2}$/.test(String(raw?.when || '')) ? raw.when : '',
-      firstSeen: now,
-      lastConfirmed: now,
-      confidence: 0.6, // a model's read, not a record's word — lower than any class-R claim
-      cls: 'C',
-      state: 'proposed',
-    });
-  }
-  return { claims: out, summary: String(value?.summary || '').trim().slice(0, 600), refused };
-}
+import{defineSchema as S,describeSchema as g}from"./structured.js";const b=8,p=240,w=1200,x=24,$=S({name:"brief_synthesis",purpose:"What the records establish about one subject, as separate cited claims.",fields:{claims:{type:"object[]",maxItems:b,describe:"the things the records establish about the subject — decisions, roles, status, changes — one per entry, each cited",fields:{text:{type:"string",required:!0,max:p,describe:"one specific claim in plain prose, past tense for events, present for standing facts"},refs:{type:"string[]",required:!0,maxItems:6,describe:"the record ids (exactly as labelled, e.g. meeting:m_12) that support this claim — at least one, only ones you were shown"},when:{type:"string",max:10,describe:"YYYY-MM-DD of the record that establishes it, if one does"}}},summary:{type:"string",max:600,describe:"two or three sentences of what a colleague should know about this subject right now"}},nothing:{claims:[],summary:""}});function C({subject:s,existing:n=[],excerpts:h=[]}={}){const i=String(s?.name||"the subject"),r=String(s?.kind||"subject"),a=h.slice(0,x);return[`Subject: ${i} (${r})${s?.aliases?.length?` — also written as ${s.aliases.join(", ")}`:""}.`,"","Already established (do not repeat these):",...n.length?n.map(e=>`- ${e}`):["- nothing yet"],"",`Records you may cite (${a.length}). Cite ONLY these ids, exactly as written:`,...a.map(e=>`[${e.id}] ${e.title||""}${e.date?` (${e.date})`:""}
+${String(e.text||"").slice(0,w)}`),"","Write what these records ESTABLISH about the subject: decisions, ownership, status, and","anything that changed over time (say what it was before and after). Every claim must cite","at least one of the ids above. If the records establish nothing beyond what is already","listed, return no claims.","",g($)].join(`
+`)}function _(s,{knownIds:n,hashOf:h=()=>"unhashed",now:i=0,newId:r=null}={}){const a=n instanceof Set?n:new Set(n||[]),l=[],e=[];let f=0;const y=()=>r?r():`s${i}-${f+=1}`;for(const c of s?.claims||[]){const o=String(c?.text||"").trim(),d=[...new Set((c?.refs||[]).map(t=>String(t||"").trim()).filter(Boolean))];if(!o){e.push({text:o,why:"empty"});continue}if(!d.length){e.push({text:o,why:"no citation"});continue}const m=d.filter(t=>!a.has(t));if(m.length){e.push({text:o,why:`cites a record it was not shown: ${m.join(", ")}`});continue}l.push({id:y(),kind:"synthesis",text:o.slice(0,p),refs:d.map(t=>{const u=t.indexOf(":");return{kind:t.slice(0,u),id:t.slice(u+1),hash:h(t)}}),when:/^\d{4}-\d{2}-\d{2}$/.test(String(c?.when||""))?c.when:"",firstSeen:i,lastConfirmed:i,confidence:.6,cls:"C",state:"proposed"})}return{claims:l,summary:String(s?.summary||"").trim().slice(0,600),refused:e}}export{p as MAX_CLAIM_CHARS,x as MAX_EXCERPTS,w as MAX_EXCERPT_CHARS,b as MAX_SYNTHESIS_CLAIMS,$ as SYNTHESIS_SCHEMA,_ as claimsFromSynthesis,C as synthesisPrompt};

package/tags.js

@@ -1,203 +1 @@
-// The tag vocabulary — one filing system across notes, chats and meetings.
-//
-// A tag typed in the notes editor and a tag typed on the meetings page have to BE the
-// same tag, and `tag:design` has to select it from any list. That is a pure input →
-// output question about normalization and matching, so it lives here: the extension,
-// the gateway's warm index and any future mobile client all have to agree on what "the
-// same tag" is, and three normalizers would mean three answers to that.
-//
-// Design notes:
-//   • Normalization is lossy on purpose — case, punctuation and spacing are filing
-//     noise. "Design Review", "design-review" and "#DesignReview!" are one tag.
-//   • Unicode-aware. Stripping everything outside [a-z0-9-] silently erases a tag
-//     written in Japanese, Greek or Hindi — it becomes '' and vanishes. Letters and
-//     numbers in ANY script are kept; only separators and punctuation fold to '-'.
-//   • Order is the user's, not ours: tags keep insertion order rather than sorting,
-//     because the first tag someone adds is usually the one they think in.
-
-export const MAX_TAG_LENGTH = 32;
-export const MAX_TAGS = 24;
-
-/**
- * Fold one user-typed value into its canonical tag, or '' when nothing survives.
- * Idempotent: normalizeTag(normalizeTag(x)) === normalizeTag(x).
- */
-export function normalizeTag(value) {
-  const raw = String(value ?? '').trim().replace(/^#+/, '');
-  if (!raw) return '';
-  return raw
-    .toLowerCase()
-    // Any run of things that aren't letters/numbers becomes a single separator.
-    .replace(/[^\p{L}\p{N}]+/gu, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, MAX_TAG_LENGTH)
-    // The slice can land mid-separator; don't leave a trailing dash behind.
-    .replace(/-+$/, '');
-}
-
-/** Normalize a list: drop blanks, dedupe (first wins), cap the count. */
-export function normalizeTags(list, { max = MAX_TAGS } = {}) {
-  const out = [];
-  for (const value of Array.isArray(list) ? list : []) {
-    const tag = normalizeTag(value);
-    if (tag && !out.includes(tag)) out.push(tag);
-    if (out.length >= max) break;
-  }
-  return out;
-}
-
-export function hasTag(tags, value) {
-  const tag = normalizeTag(value);
-  return !!tag && normalizeTags(tags).includes(tag);
-}
-
-/** Append a tag (no-op when blank, already present, or at the cap). */
-export function addTag(tags, value, { max = MAX_TAGS } = {}) {
-  const current = normalizeTags(tags, { max });
-  const tag = normalizeTag(value);
-  if (!tag || current.includes(tag) || current.length >= max) return current;
-  return [...current, tag];
-}
-
-export function removeTag(tags, value) {
-  const tag = normalizeTag(value);
-  return normalizeTags(tags).filter((t) => t !== tag);
-}
-
-export function toggleTag(tags, value, { max = MAX_TAGS } = {}) {
-  return hasTag(tags, value) ? removeTag(tags, value) : addTag(tags, value, { max });
-}
-
-/** Set equality, order-insensitive — so a save can skip a write that changes nothing. */
-export function sameTags(a, b) {
-  const x = normalizeTags(a);
-  const y = normalizeTags(b);
-  return x.length === y.length && x.every((t) => y.includes(t));
-}
-
-/** `#design` — the one display form, so chips read the same on every surface. */
-export function formatTag(tag) {
-  const t = normalizeTag(tag);
-  return t ? `#${t}` : '';
-}
-
-// --------------------------------------------------------------------------
-// Query language
-// --------------------------------------------------------------------------
-
-// One search box, two jobs: free text and tag selection. Rather than a second input
-// per page, a query may carry tag terms inline —
-//   tag:design            include
-//   #design               include (the shorthand people already type)
-//   -tag:done / -#done    exclude
-//   tag:"deep work"       quoted, folded to deep-work
-// …and everything left over is the free-text part the ranker sees. A `#` that is part
-// of a word ("C#", "issue #12") is left alone: only a leading, standalone one counts.
-const TERM_RE = /(^|\s)(-)?(?:tag:|#)("([^"]*)"|[^\s"]+)/giu;
-
-/**
- * Split a raw query into { include, exclude, text }.
- * `text` is the query with the tag terms removed (whitespace collapsed).
- */
-export function parseTagQuery(query) {
-  const raw = String(query ?? '');
-  const include = [];
-  const exclude = [];
-  let text = raw.replace(TERM_RE, (match, lead, minus, bare, quoted) => {
-    const tag = normalizeTag(quoted !== undefined ? quoted : bare);
-    if (!tag) return match; // nothing usable — leave it in the free text
-    const bucket = minus ? exclude : include;
-    if (!bucket.includes(tag)) bucket.push(tag);
-    return lead || '';
-  });
-  text = text.replace(/\s+/g, ' ').trim();
-  return { include, exclude, text };
-}
-
-/** True when `query` carries at least one tag term. */
-export function hasTagTerms(query) {
-  const { include, exclude } = parseTagQuery(query);
-  return include.length > 0 || exclude.length > 0;
-}
-
-/** Render a filter back into query syntax — the inverse of parseTagQuery. */
-export function formatTagQuery({ include = [], exclude = [], text = '' } = {}) {
-  return [
-    ...normalizeTags(include).map((t) => `tag:${t}`),
-    ...normalizeTags(exclude).map((t) => `-tag:${t}`),
-    String(text || '').trim(),
-  ].filter(Boolean).join(' ');
-}
-
-/**
- * Does one record's tags satisfy a filter?
- * Include terms are ANDed (narrowing is what filters are for); `mode:'any'` ORs them.
- * Exclusions always win.
- */
-export function matchesTagFilter(tags, { include = [], exclude = [] } = {}, { mode = 'all' } = {}) {
-  const own = normalizeTags(tags);
-  const wanted = normalizeTags(include);
-  const banned = normalizeTags(exclude);
-  if (banned.some((t) => own.includes(t))) return false;
-  if (!wanted.length) return true;
-  return mode === 'any' ? wanted.some((t) => own.includes(t)) : wanted.every((t) => own.includes(t));
-}
-
-const defaultGetTags = (entry) => entry?.tags;
-
-/** Filter a list of records by a parsed filter. Order is preserved. */
-export function filterByTags(entries, filter, getTags = defaultGetTags, opts) {
-  const f = filter || {};
-  if (!(f.include?.length || f.exclude?.length)) return [...(entries || [])];
-  return (entries || []).filter((e) => matchesTagFilter(getTags(e), f, opts));
-}
-
-/**
- * Tag facets for a filter bar: every tag in the corpus with its count, most-used
- * first then alphabetical (so the bar is stable as counts tie). `selected` tags are
- * always included even at count 0, so a filter that empties the list can be undone.
- */
-export function tagFacets(entries, getTags = defaultGetTags, { limit = 0, selected = [] } = {}) {
-  const counts = new Map();
-  for (const entry of entries || []) {
-    for (const tag of normalizeTags(getTags(entry))) counts.set(tag, (counts.get(tag) || 0) + 1);
-  }
-  for (const tag of normalizeTags(selected)) if (!counts.has(tag)) counts.set(tag, 0);
-  const facets = [...counts.entries()]
-    .map(([tag, count]) => ({ tag, count }))
-    .sort((a, b) => b.count - a.count || a.tag.localeCompare(b.tag));
-  const keep = new Set(normalizeTags(selected));
-  if (!limit || facets.length <= limit) return facets;
-  // Truncation must never hide an active selection — keep those, then fill by rank.
-  const picked = facets.filter((f) => keep.has(f.tag));
-  for (const f of facets) {
-    if (picked.length >= limit) break;
-    if (!keep.has(f.tag)) picked.push(f);
-  }
-  return picked.sort((a, b) => b.count - a.count || a.tag.localeCompare(b.tag));
-}
-
-/**
- * Suggest tags a record doesn't have yet, drawn from what's already in use —
- * `existing` facets ranked by count, minus what's on the record. Reusing a tag the
- * user coined beats inventing a synonym for it.
- */
-export function suggestExistingTags(facets, tags, { limit = 6 } = {}) {
-  const own = new Set(normalizeTags(tags));
-  return (facets || [])
-    .map((f) => (typeof f === 'string' ? { tag: normalizeTag(f), count: 0 } : f))
-    .filter((f) => f.tag && !own.has(f.tag))
-    .slice(0, limit)
-    .map((f) => f.tag);
-}
-
-/**
- * The line a full-text index should carry for tags. Both forms are emitted — `#design`
- * so an exact-text search for what the chip shows hits, and `design` so a plain word
- * query does too.
- */
-export function tagsSearchText(tags) {
-  const list = normalizeTags(tags);
-  if (!list.length) return '';
-  return [...list.map((t) => `#${t}`), ...list].join(' ');
-}
+const S=32,w=24;function g(t){const n=String(t??"").trim().replace(/^#+/,"");return n?n.toLowerCase().replace(/[^\p{L}\p{N}]+/gu,"-").replace(/^-+|-+$/g,"").slice(0,32).replace(/-+$/,""):""}function a(t,{max:n=24}={}){const e=[];for(const o of Array.isArray(t)?t:[]){const r=g(o);if(r&&!e.includes(r)&&e.push(r),e.length>=n)break}return e}function x(t,n){const e=g(n);return!!e&&a(t).includes(e)}function h(t,n,{max:e=24}={}){const o=a(t,{max:e}),r=g(n);return!r||o.includes(r)||o.length>=e?o:[...o,r]}function d(t,n){const e=g(n);return a(t).filter(o=>o!==e)}function G(t,n,{max:e=24}={}){return x(t,n)?d(t,n):h(t,n,{max:e})}function _(t,n){const e=a(t),o=a(n);return e.length===o.length&&e.every(r=>o.includes(r))}function M(t){const n=g(t);return n?`#${n}`:""}const m=/(^|\s)(-)?(?:tag:|#)("([^"]*)"|[^\s"]+)/giu;function A(t){const n=String(t??""),e=[],o=[];let r=n.replace(m,(u,f,i,c,s)=>{const l=g(s!==void 0?s:c);if(!l)return u;const p=i?o:e;return p.includes(l)||p.push(l),f||""});return r=r.replace(/\s+/g," ").trim(),{include:e,exclude:o,text:r}}function X(t){const{include:n,exclude:e}=A(t);return n.length>0||e.length>0}function $({include:t=[],exclude:n=[],text:e=""}={}){return[...a(t).map(o=>`tag:${o}`),...a(n).map(o=>`-tag:${o}`),String(e||"").trim()].filter(Boolean).join(" ")}function y(t,{include:n=[],exclude:e=[]}={},{mode:o="all"}={}){const r=a(t),u=a(n);return a(e).some(i=>r.includes(i))?!1:u.length?o==="any"?u.some(i=>r.includes(i)):u.every(i=>r.includes(i)):!0}const T=t=>t?.tags;function k(t,n,e=T,o){const r=n||{};return r.include?.length||r.exclude?.length?(t||[]).filter(u=>y(e(u),r,o)):[...t||[]]}function E(t,n=T,{limit:e=0,selected:o=[]}={}){const r=new Map;for(const c of t||[])for(const s of a(n(c)))r.set(s,(r.get(s)||0)+1);for(const c of a(o))r.has(c)||r.set(c,0);const u=[...r.entries()].map(([c,s])=>({tag:c,count:s})).sort((c,s)=>s.count-c.count||c.tag.localeCompare(s.tag)),f=new Set(a(o));if(!e||u.length<=e)return u;const i=u.filter(c=>f.has(c.tag));for(const c of u){if(i.length>=e)break;f.has(c.tag)||i.push(c)}return i.sort((c,s)=>s.count-c.count||c.tag.localeCompare(s.tag))}function L(t,n,{limit:e=6}={}){const o=new Set(a(n));return(t||[]).map(r=>typeof r=="string"?{tag:g(r),count:0}:r).filter(r=>r.tag&&!o.has(r.tag)).slice(0,e).map(r=>r.tag)}function b(t){const n=a(t);return n.length?[...n.map(e=>`#${e}`),...n].join(" "):""}export{w as MAX_TAGS,S as MAX_TAG_LENGTH,h as addTag,k as filterByTags,M as formatTag,$ as formatTagQuery,x as hasTag,X as hasTagTerms,y as matchesTagFilter,g as normalizeTag,a as normalizeTags,A as parseTagQuery,d as removeTag,_ as sameTags,L as suggestExistingTags,E as tagFacets,b as tagsSearchText,G as toggleTag};