@chatpanel/gateway 0.6.85 → 0.6.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.85",
+  "version": "0.6.87",
   "description": "Local privacy gateway \u2014 redacts PII out of OpenAI/Anthropic API traffic before it reaches a model, then restores it in the reply. Point opencode, codex, aider, Claude Code, etc. at it.",
   "type": "module",
   "bin": {

package/src/scorecard-store.js

@@ -0,0 +1,92 @@
+// The agents' scorecards — every fact the runner said about a member, chained and attested
+// here, where no client and no agent can write one for itself.
+//
+// One chain per agent id. A fact arrives as the run store's `task.scored` event (or a
+// person's rating through the route); the store makes the entry (scorecard.js: canonical,
+// hashed onto the previous), marks it with an HMAC over a key only this process holds, and
+// appends. Nothing is ever edited: a correction is a new entry. The file is encrypted at
+// rest with the team store's key, like the runs; the attestation key is derived from it
+// (HKDF-style label), so the same install attests the same way across restarts and a copied
+// file elsewhere cannot forge a mark.
+//
+// Read: `GET /v1/agents/:id/scorecard` → the chain, its summary, and whether it verifies.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import os from 'node:os';
+import { createHmac, webcrypto } from 'node:crypto';
+import { makeEntry, attest, verifyChain, verifyAttested, summarize, SCORECARD_ENTRY_KINDS } from './scorecard.js';
+
+const DIR = join(os.homedir(), '.chatpanel');
+const STORE_PATH = process.env.CHATPANEL_SCORECARDS_STORE || join(DIR, 'scorecards.json');
+const MAX_ENTRIES_PER_AGENT = 5000;
+
+export class ScorecardStore {
+  constructor({ storePath = STORE_PATH, key = null, now = () => Date.now() } = {}) {
+    this.path = storePath;
+    this.now = now;
+    // The attestation key: derived from the store key with a label, never the key itself.
+    this._mark = key ? createHmac('sha256', key).update('chatpanel:scorecard:attest:v1').digest() : null;
+    this.chains = new Map(); // agentId -> [entries]
+    this._queue = Promise.resolve(); // appends are serialised: a chain has one head
+  }
+  load() {
+    try {
+      if (existsSync(this.path)) {
+        const doc = JSON.parse(readFileSync(this.path, 'utf8'));
+        for (const [id, entries] of Object.entries(doc?.chains || {})) if (Array.isArray(entries)) this.chains.set(id, entries);
+      }
+    } catch { this.chains = new Map(); }
+    return this;
+  }
+  save() {
+    mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+    const tmp = `${this.path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ v: 1, chains: Object.fromEntries(this.chains) }), { mode: 0o600 });
+    renameSync(tmp, this.path);
+  }
+  /** Append one fact to an agent's chain: made, chained, attested, saved. Serialised per store. */
+  append(fact) {
+    const run = async () => {
+      const agentId = String(fact?.agentId || '');
+      if (!agentId) throw new Error('scorecard: agentId required');
+      if (!SCORECARD_ENTRY_KINDS.includes(fact?.kind)) throw new Error(`scorecard: kind must be one of ${SCORECARD_ENTRY_KINDS.join(', ')}`);
+      const chain = this.chains.get(agentId) || [];
+      if (chain.length >= MAX_ENTRIES_PER_AGENT) throw new Error('scorecard: chain is full');
+      let entry = await makeEntry({ ...fact, at: fact.at || this.now() }, chain.at(-1) || null, { now: this.now, subtle: webcrypto.subtle });
+      if (this._mark) entry = await attest(entry, this._mark, { subtle: webcrypto.subtle });
+      chain.push(entry);
+      this.chains.set(agentId, chain);
+      this.save();
+      return entry;
+    };
+    const p = this._queue.then(run, run);
+    this._queue = p.catch(() => {});
+    return p;
+  }
+  /** The chain, its card, and whether it verifies — what a recruiter (or a person) reads. */
+  async get(agentId) {
+    const chain = this.chains.get(String(agentId || '')) || [];
+    const verified = await verifyChain(chain, { subtle: webcrypto.subtle });
+    const attested = this._mark ? await verifyAttested(chain, this._mark, { subtle: webcrypto.subtle }) : { ok: false, attested: 0, of: chain.length };
+    return { agentId: String(agentId || ''), entries: chain, summary: summarize(chain), verified, attested };
+  }
+  /** Every agent's card, without the chains. */
+  list() {
+    return [...this.chains.entries()].map(([agentId, chain]) => ({ agentId, ...summarize(chain) }));
+  }
+  /** A run store event, as the fold sees it: only `task.scored` becomes a fact. */
+  fromRunEvent(ev, run) {
+    if (String(ev?.type || '') !== 'task.scored') return null;
+    const p = ev.payload && typeof ev.payload === 'object' ? ev.payload : {};
+    if (!p.agentId) return null;
+    return this.append({
+      agentId: p.agentId, kind: p.outcome === 'task.failed' ? 'task.failed' : 'task.done', at: ev.at,
+      runId: run?.id || p.runId, taskId: p.taskId, model: p.model, size: p.size, roleKind: p.roleKind,
+      tools: p.tools, with: p.with, refs: p.refs, error: p.error,
+      ...(run?.projectId ? { projectId: run.projectId } : {}), ...(run?.jobId ? { jobId: run.jobId } : {}),
+    }).catch(() => null);
+  }
+}
+
+export function createScorecardStore(opts) { return new ScorecardStore(opts).load(); }

package/src/scorecard.js

@@ -0,0 +1,192 @@
+// VENDORED from @chatpanel/events/scorecard.js — edit there, then copy over.
+// An agent's scorecard — an immutable record of what it actually did, and matching on it.
+//
+// A scorecard is a CHAIN of entries, one per fact, append-only: a task it finished (how big,
+// with which tools, alongside whom, in which role), a rating a job gave it, an agent it
+// created, an interaction. Every entry carries the hash of the one before and its own hash,
+// so an edit anywhere breaks every link after it; the gateway's store adds its own mark
+// (an HMAC over the hash with a key only the store holds) so an entry a client — or an
+// agent — wrote for itself shows as unattested. The facts are produced by the runner and
+// attested by the store, never written by the agent: the only way to a better scorecard is
+// the work.
+//
+// `summarize` turns the chain into the card a recruiter reads; `fit` scores an agent type
+// against a job's needs with that record — the same function the evaluator starts from, so
+// an application's fit has reasons a person can read and overrule.
+//
+// Dependency-free: hashing is `crypto.subtle` (browser, Node, a phone), injectable for tests.
+
+export const SCORECARD_ENTRY_KINDS = Object.freeze(['task.done', 'task.failed', 'rating', 'created', 'interaction', 'role']);
+export const ROLE_KINDS = Object.freeze(['ic', 'orchestrator', 'manager', 'manager-of-managers']);
+export const SCORECARD_VERSION = 1;
+
+const enc = new TextEncoder();
+const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('');
+
+/** Canonical JSON: keys sorted at every level, so the same fact hashes the same everywhere. */
+export function canonical(v) {
+  if (v === null || typeof v !== 'object') return JSON.stringify(v);
+  if (Array.isArray(v)) return `[${v.map(canonical).join(',')}]`;
+  return `{${Object.keys(v).sort().map((k) => (v[k] === undefined ? null : `${JSON.stringify(k)}:${canonical(v[k])}`)).filter(Boolean).join(',')}}`;
+}
+
+/** SHA-256 over text, as hex; `subtle` is injectable (a runtime without it passes its own). */
+export async function sha256(text, { subtle = globalThis.crypto?.subtle } = {}) {
+  if (!subtle) throw new Error('scorecard: no crypto.subtle — pass one');
+  return hex(await subtle.digest('SHA-256', enc.encode(String(text))));
+}
+
+/** The fields a hash covers — everything but the hash and the store's mark. */
+function hashable(e) {
+  const { hash: _h, sig: _s, ...rest } = e;
+  return rest;
+}
+
+/**
+ * A new entry chained onto `prev` (the last entry, or null for the first). Pure apart from
+ * the digest: the caller (the store) decides whether it is attested.
+ */
+export async function makeEntry(fact, prev, { now = () => Date.now(), subtle } = {}) {
+  if (!fact || typeof fact !== 'object') throw new Error('scorecard: an entry needs a fact');
+  if (!SCORECARD_ENTRY_KINDS.includes(fact.kind)) throw new Error(`scorecard: kind must be one of ${SCORECARD_ENTRY_KINDS.join(', ')}`);
+  if (!fact.agentId) throw new Error('scorecard: agentId required');
+  const e = {
+    v: SCORECARD_VERSION,
+    seq: prev ? prev.seq + 1 : 0,
+    agentId: String(fact.agentId),
+    kind: fact.kind,
+    at: Number(fact.at) || now(),
+    ...(fact.projectId ? { projectId: String(fact.projectId) } : {}),
+    ...(fact.jobId ? { jobId: String(fact.jobId) } : {}),
+    ...(fact.runId ? { runId: String(fact.runId) } : {}),
+    ...(fact.taskId ? { taskId: String(fact.taskId) } : {}),
+    ...(fact.model ? { model: String(fact.model) } : {}),
+    ...(fact.size ? { size: sizeOf(fact.size) } : {}),
+    ...(fact.roleKind ? { roleKind: ROLE_KINDS.includes(fact.roleKind) ? fact.roleKind : 'ic' } : {}),
+    ...(Array.isArray(fact.tools) && fact.tools.length ? { tools: [...new Set(fact.tools.map(String))].sort() } : {}),
+    ...(Array.isArray(fact.with) && fact.with.length ? { with: [...new Set(fact.with.map(String))].sort() } : {}),
+    ...(Array.isArray(fact.created) && fact.created.length ? { created: [...new Set(fact.created.map(String))] } : {}),
+    ...(fact.rating ? { rating: { by: String(fact.rating.by || 'person'), score: clamp01(fact.rating.score), ...(fact.rating.note ? { note: String(fact.rating.note).slice(0, 500) } : {}), ...(fact.rating.about != null ? { about: Number(fact.rating.about) } : {}) } } : {}),
+    ...(Array.isArray(fact.refs) && fact.refs.length ? { refs: fact.refs.map(String).slice(0, 12) } : {}),
+    ...(fact.error ? { error: String(fact.error).slice(0, 300) } : {}),
+    prev: prev ? prev.hash : null,
+  };
+  e.hash = await sha256(canonical(hashable(e)), { subtle });
+  return e;
+}
+
+const clamp01 = (n) => Math.max(0, Math.min(1, Number(n) || 0));
+const sizeOf = (s) => ({ ms: Math.max(0, Math.round(Number(s.ms) || 0)), steps: Math.max(0, Math.round(Number(s.steps) || 0)), tools: Math.max(0, Math.round(Number(s.tools) || 0)), findings: Math.max(0, Math.round(Number(s.findings) || 0)), tokens: Math.max(0, Math.round(Number(s.tokens) || 0)) });
+
+/** Does every link hold? Returns `{ ok, at }` — `at` is the seq of the first broken entry. */
+export async function verifyChain(entries, { subtle } = {}) {
+  let prev = null;
+  for (const e of entries || []) {
+    if (!e || typeof e !== 'object') return { ok: false, at: prev ? prev.seq + 1 : 0, why: 'not an entry' };
+    if ((prev ? prev.seq + 1 : 0) !== e.seq) return { ok: false, at: e.seq, why: 'seq' };
+    if ((prev ? prev.hash : null) !== e.prev) return { ok: false, at: e.seq, why: 'prev' };
+    const h = await sha256(canonical(hashable(e)), { subtle });
+    if (h !== e.hash) return { ok: false, at: e.seq, why: 'hash' };
+    prev = e;
+  }
+  return { ok: true, at: null, length: (entries || []).length };
+}
+
+/**
+ * The store's mark. `key` is raw bytes only the store holds; an HMAC-SHA-256 over the hash.
+ * Anyone can re-hash the chain; only the store can mark it, so an entry written elsewhere
+ * is honest about being unattested. Injectable `subtle` again.
+ */
+export async function attest(entry, key, { subtle = globalThis.crypto?.subtle } = {}) {
+  const k = await subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+  return { ...entry, sig: hex(await subtle.sign('HMAC', k, enc.encode(entry.hash))) };
+}
+export async function verifyAttested(entries, key, { subtle = globalThis.crypto?.subtle } = {}) {
+  const k = await subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-256' }, false, ['verify']);
+  const out = [];
+  for (const e of entries || []) {
+    const sig = e?.sig ? new Uint8Array(e.sig.match(/../g).map((x) => parseInt(x, 16))) : null;
+    out.push(!!sig && await subtle.verify('HMAC', k, sig, enc.encode(e.hash)));
+  }
+  return { ok: out.every(Boolean), attested: out.filter(Boolean).length, of: out.length };
+}
+
+/** The card a recruiter reads. */
+export function summarize(entries, { recent = 5 } = {}) {
+  const list = (entries || []).filter((e) => e && e.kind);
+  const done = list.filter((e) => e.kind === 'task.done');
+  const failed = list.filter((e) => e.kind === 'task.failed');
+  const sum = (k) => done.reduce((n, e) => n + (e.size?.[k] || 0), 0);
+  const largest = done.reduce((m, e) => Math.max(m, e.size?.steps || 0), 0);
+  const tools = new Set(); const withAgents = new Set(); const created = new Set();
+  const roles = { ic: 0, orchestrator: 0, manager: 0, 'manager-of-managers': 0 };
+  const models = new Map();
+  for (const e of list) {
+    for (const t of e.tools || []) tools.add(t);
+    for (const a of e.with || []) withAgents.add(a);
+    for (const a of e.created || []) created.add(a);
+    if (e.roleKind && (e.kind === 'task.done' || e.kind === 'task.failed' || e.kind === 'role')) roles[e.roleKind] = (roles[e.roleKind] || 0) + 1;
+    if (e.model) models.set(e.model, (models.get(e.model) || 0) + 1);
+  }
+  const ratings = list.filter((e) => e.kind === 'rating' && e.rating).map((e) => e.rating.score);
+  const avg = ratings.length ? ratings.reduce((a, b) => a + b, 0) / ratings.length : null;
+  const recentRatings = ratings.slice(-recent);
+  const refs = [...new Set(list.flatMap((e) => e.refs || []))].slice(-recent);
+  return {
+    agentId: list[0]?.agentId || null,
+    entries: list.length,
+    jobsDone: done.length,
+    jobsFailed: failed.length,
+    size: { ms: sum('ms'), steps: sum('steps'), tools: sum('tools'), findings: sum('findings'), tokens: sum('tokens'), largestSteps: largest },
+    tools: [...tools].sort(),
+    workedWith: [...withAgents].sort(),
+    created: [...created],
+    roles,
+    models: [...models.entries()].sort((a, b) => b[1] - a[1]).map(([m, n]) => ({ model: m, tasks: n })),
+    rating: { avg, count: ratings.length, recent: recentRatings.length ? recentRatings.reduce((a, b) => a + b, 0) / recentRatings.length : null },
+    refs,
+    since: list[0]?.at || null,
+    last: list.at(-1)?.at || null,
+    head: list.at(-1)?.hash || null,
+  };
+}
+
+/**
+ * How well an agent TYPE fits a job, with that type's record. `job.needs` is
+ * `{ skills[], tools[], grants[] }`; `type` carries `skills[]`, `tools[]`, `grants[]`; the
+ * summary is `summarize()`'s. Returns `{ score, reasons }` in [0, 1] — needs first (a type
+ * without the tools cannot do the job), track record second, size third.
+ */
+export function fit(job, type, summary = null) {
+  const needs = job?.needs || {};
+  const have = (xs) => new Set((xs || []).map((x) => String(x).toLowerCase()));
+  const skills = have(type?.skills); const tools = have(type?.tools); const grants = have(type?.grants);
+  const reasons = [];
+  const coverage = (want, has, label) => {
+    const w = (want || []).map((x) => String(x).toLowerCase());
+    if (!w.length) return 1;
+    const hit = w.filter((x) => has.has(x));
+    if (hit.length < w.length) reasons.push(`missing ${label}: ${w.filter((x) => !has.has(x)).join(', ')}`);
+    return hit.length / w.length;
+  };
+  const cSkills = coverage(needs.skills, skills, 'skills');
+  const cTools = coverage(needs.tools, tools, 'tools');
+  const cGrants = coverage(needs.grants, grants, 'grants');
+  const needScore = (cSkills * 0.5 + cTools * 0.3 + cGrants * 0.2);
+  if (needScore === 1) reasons.push('has every skill, tool and grant the job names');
+  let record = 0.5; // a fresh type is neither trusted nor distrusted
+  if (summary && summary.entries) {
+    const doneRate = summary.jobsDone + summary.jobsFailed ? summary.jobsDone / (summary.jobsDone + summary.jobsFailed) : 0.5;
+    const rated = summary.rating.avg == null ? 0.5 : summary.rating.avg;
+    record = doneRate * 0.5 + rated * 0.5;
+    reasons.push(`${summary.jobsDone} done, ${summary.jobsFailed} failed${summary.rating.avg != null ? `, rated ${Math.round(summary.rating.avg * 100)}%` : ''}`);
+    if (summary.roles.orchestrator + summary.roles.manager + summary.roles['manager-of-managers'] > 0) reasons.push(`has led: ${summary.roles.orchestrator} as orchestrator, ${summary.roles.manager} as manager`);
+  } else {
+    reasons.push('no record yet');
+  }
+  const wantSize = Number(job?.size?.steps) || 0;
+  const sizeScore = !wantSize ? 1 : Math.min(1, (summary?.size?.largestSteps || 0) / wantSize) * 0.5 + 0.5;
+  if (wantSize && (summary?.size?.largestSteps || 0) < wantSize) reasons.push(`largest task so far ${summary?.size?.largestSteps || 0} steps; this one is ~${wantSize}`);
+  const score = Math.round((needScore * 0.6 + record * 0.3 + sizeScore * 0.1) * 1000) / 1000;
+  return { score, reasons, parts: { needs: needScore, record, size: sizeScore } };
+}

package/src/server.js

@@ -34,7 +34,8 @@ import { installTimestampedConsole } from './log.js';
 import { saveBackupSecret, clearBackupSecret, loadBackupSecret, hasBackupSecret } from './history-store.js';
 import { createMemoryStore } from './memory-store.js';
 import { createPrefsStore } from './prefs-store.js';
-import { createTeamStore } from './team-store.js';
+import { createTeamStore, loadOrCreateKey as loadTeamKey } from './team-store.js';
+import { createScorecardStore } from './scorecard-store.js';
 import { createHistoryStore } from './sqlite-store.js';
 import { ingestBackups } from './backup-ingest.js';
 import * as nerEngine from './ner-engine.js';
@@ -58,7 +59,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.85';
+export const VERSION = '0.6.87';
 
 // WARM search tier — SQLite + FTS5 record store (falls back to an encrypted-JSON
 // store if SQLite can't load), fed by the extension's ingest sync + backup-ingest.
@@ -67,7 +68,8 @@ export const VERSION = '0.6.85';
 const historyStore = await createHistoryStore();
 const memoryStore = await createMemoryStore();
 const prefsStore = createPrefsStore();
-const teamStore = createTeamStore();
+const scorecards = createScorecardStore({ key: loadTeamKey() });
+const teamStore = createTeamStore({ scorecards });
 // Who is watching prefs change — a client with a live subscription is told the moment a
 // section is written by the other client, instead of waiting for its next focus.
 const prefsWatchers = new Set();
@@ -706,7 +708,7 @@ export function createGateway(cfg = loadConfig()) {
     // Client preferences travel between the extension and the desktop through here, and an
     // MCP server entry can carry an Authorization header — so READS are gated too, unlike
     // history and memory. A drive-by page must not learn what tools the user connected.
-    if ((pathname === '/v1/prefs' || pathname.startsWith('/v1/prefs/') || pathname.startsWith('/v1/teams')) && !isAdminAuthorized(req)) {
+    if ((pathname === '/v1/prefs' || pathname.startsWith('/v1/prefs/') || pathname.startsWith('/v1/teams') || pathname.startsWith('/v1/agents')) && !isAdminAuthorized(req)) {
       return sendJson(res, 403, { error: { message: 'prefs: extension origin or gateway token required', type: 'forbidden' } });
     }
     // The access log is who-read-what — sensitive, and writable only by the local MCP
@@ -820,6 +822,23 @@ export function createGateway(cfg = loadConfig()) {
       return undefined;
     }
 
+    // --- SCORECARDS. Every agent's attested record (scorecard-store.js): the chain, its card,
+    //     whether it verifies; a person's rating appended from either client.
+    if (pathname === '/v1/agents/scorecards' && req.method === 'GET') return sendJson(res, 200, { ok: true, agents: scorecards.list() });
+    {
+      const m = /^\/v1\/agents\/([a-zA-Z0-9_.:@+-]{1,120})\/scorecard$/.exec(pathname);
+      if (m) {
+        const agentId = decodeURIComponent(m[1]);
+        if (req.method === 'GET') return sendJson(res, 200, { ok: true, ...(await scorecards.get(agentId)) });
+        if (req.method === 'POST') {
+          try {
+            const body = JSON.parse((await readBody(req, cfg.maxBodyBytes)).toString('utf8')) || {};
+            const entry = await scorecards.append({ agentId, kind: 'rating', runId: body.runId, taskId: body.taskId, jobId: body.jobId, rating: { by: String(body.by || 'person').slice(0, 40), score: body.score, note: body.note, about: body.about }, refs: body.refs });
+            return sendJson(res, 200, { ok: true, entry });
+          } catch (e) { return sendJson(res, 400, { error: { message: `scorecard: ${e.message}`, type: 'scorecard_error' } }); }
+        }
+      }
+    }
     // --- TEAM RUNS. The board every client can read (team-store.js).
     //   GET  /v1/teams/runs[?limit&team]     → { ok, runs }            newest first, no boards
     //   POST /v1/teams/runs { id, team, request, client } → { ok, run }

package/src/team-store.js

@@ -34,7 +34,7 @@ export const STALE_AFTER_MS = 5 * 60_000;
 const RUN_ID_RE = /^[a-zA-Z0-9_-]{4,64}$/;
 const LIVE = new Set(LIVE_RUN_STATUSES);
 
-function loadOrCreateKey() {
+export function loadOrCreateKey() {
   try { if (existsSync(KEY_PATH)) return Buffer.from(readFileSync(KEY_PATH, 'utf8').trim(), 'base64'); } catch { /* regenerate */ }
   const key = randomBytes(32);
   mkdirSync(dirname(KEY_PATH), { recursive: true, mode: 0o700 });
@@ -58,7 +58,8 @@ const clone = (v) => (v === undefined ? undefined : JSON.parse(JSON.stringify(v)
 export function applyEvent(run, ev) { return foldRun(run, ev); }
 
 export class TeamStore {
-  constructor({ storePath = STORE_PATH, now = () => Date.now(), staleAfterMs = STALE_AFTER_MS } = {}) {
+  constructor({ storePath = STORE_PATH, now = () => Date.now(), staleAfterMs = STALE_AFTER_MS, scorecards = null } = {}) {
+    this.scorecards = scorecards; // the agents' ledgers (scorecard-store.js), fed by task.scored
     this.path = storePath;
     this.now = now;
     this.staleAfterMs = staleAfterMs;
@@ -97,6 +98,9 @@ export class TeamStore {
     const v = clone({ ...run, events: undefined });
     delete v.events;
     v.stale = LIVE.has(run.status) && this.now() - run.lastEventAt > this.staleAfterMs;
+    // How long since the running client last wrote — a person who knows the process died
+    // does not have to wait for the stale mark to pick the run up.
+    v.quietMs = LIVE.has(run.status) ? Math.max(0, this.now() - run.lastEventAt) : 0;
     // Can a client pick this run up again? Not while its own client is live on it.
     v.resumable = isResumable(v);
     if (events) v.events = clone(run.events);
@@ -128,6 +132,8 @@ export class TeamStore {
       const ev = { seq: seq++, type: String(type), at: Number(at) || this.now(), payload };
       run.events.push(ev);
       applyEvent(run, ev);
+      // A finished task's fact goes to the member's scorecard — chained and attested there.
+      if (this.scorecards && ev.type === 'task.scored') this.scorecards.fromRunEvent(ev, run);
       for (const fn of this.watchers.get(run.id) || []) { try { fn(ev); } catch { /* a dead watcher */ } }
     }
     this.save();