@staix/agent-hub 0.13.0 → 0.15.0

package/src/hub/token-window.ts

@@ -0,0 +1,33 @@
+/**
+ * A rolling window of counted tokens, by the time each was used (not the time it was read), so a row read late still ages out
+ * on schedule. The hub's own count against a ceiling a person configured, never the provider's quota (#285).
+ */
+export class TokenWindow {
+  private rows: { at: number; n: number }[] = [];
+  constructor(private readonly spanMs: number) {}
+
+  add(at: number, n: number): void {
+    if (!Number.isFinite(at) || !Number.isSafeInteger(n) || n <= 0) return;
+    const index = this.rows.findIndex(row => row.at > at);
+    if (index < 0) this.rows.push({ at, n }); else this.rows.splice(index, 0, { at, n });
+  }
+
+  private prune(now: number): void {
+    let drop = 0;
+    while (drop < this.rows.length && now - this.rows[drop]!.at > this.spanMs) drop++;
+    if (drop) this.rows.splice(0, drop);
+  }
+
+  sum(now: number): number {
+    this.prune(now);
+    return this.rows.reduce((total, row) => total + row.n, 0);
+  }
+
+  /** When the oldest counted token was used: the window frees its first share at this time plus its span. */
+  oldest(now: number): number | undefined {
+    this.prune(now);
+    return this.rows[0]?.at;
+  }
+
+  reset(): void { this.rows = []; }
+}

package/src/hub/ui.ts

@@ -25,6 +25,9 @@ const TICKET_MS = 60_000;
 const SESSION_MS = 60 * 60_000;
 /** How long a session opened by `ahub ui --settings` may change settings that raise authority; it stays an ordinary session after. */
 export const SETTINGS_MS = 15 * 60_000;
+/** The page's view names (index.html DASHBOARD_VIEWS): the only values a snapshot request's `view` may carry to a project hub. */
+export const DASHBOARD_VIEWS = ["board", "office", "stream", "agents", "message", "memory", "settings"] as const;
+export const dashboardView = (value: unknown): typeof DASHBOARD_VIEWS[number] | undefined => (DASHBOARD_VIEWS as readonly unknown[]).includes(value) ? value as typeof DASHBOARD_VIEWS[number] : undefined;
 const LIMIT = 64;
 const secret = () => randomBytes(32).toString("hex");
 

package/src/hub/usage-rollup.ts

@@ -65,6 +65,10 @@ export interface TotalRow { peer: string; tokens: Counter; withoutCache: Counter
 /** `unknownPeers`: the peers whose figure is unknown, which the overall figure then leaves out (so it is `partial`, a lower bound, never a sum that treats them as 0). */
 export interface TotalResult { since: string | null; peers: TotalRow[]; overall: { tokens: Counter; withoutCache: Counter; cacheRead: Counter }; unknownPeers: { tokens: string[]; withoutCache: string[]; cacheRead: string[] } }
 
+/** `empty`: no record at all for that UTC day (a gap), shown as an empty column and never as a zero. */
+export interface DailyRow { day: string; peers: Record<string, Counter>; total: Counter; empty?: true }
+export interface DailyResult { days: DailyRow[]; peers: string[] }
+
 const sum = (a: number | null, b: number | null): number | null => a === null ? b : b === null ? a : a + b;
 const counter = (value: number | null, n: number, source: UsageSource = "native"): Counter => n > 0 && value !== null ? { value, source } : { value: null, source: "unknown" };
 
@@ -97,7 +101,8 @@ export class UsageRollup {
    * Fold the next slice of the log. Whole lines only: a trailing partial line (a crash, or a write in flight) waits for the next pass.
    * A log that is shorter than the stored offset was replaced or reset, so the roll-up starts over from byte 0.
    */
-  poll(): { bytes: number; done: boolean } {
+  poll(maxMs = 20): { bytes: number; done: boolean } {
+    const deadline = performance.now() + Math.max(0, Math.min(20, maxMs));
     if (this.closed) return { bytes: 0, done: true };
     if (!existsSync(this.eventsFile)) return { bytes: 0, done: true };
     const fd = openSync(this.eventsFile, "r");
@@ -123,18 +128,27 @@ export class UsageRollup {
         want = Math.min(size - offset, want * 2);
       }
       if (end < 0) return { bytes: 0, done: true };                    // the last line is still being written: it waits for the next pass
-      const text = buffer.subarray(0, end + 1).toString("utf8");
+      let consumed = 0;
       // The offset was read before the slice was; another roll-up on this hub.db (a restart that overlaps the old process) may have folded the same
       // bytes since. The transaction takes the write lock first and checks the stored offset again: a pass whose start is stale is abandoned whole,
       // so a byte range is folded exactly once however many writers there are (found by a forced interleave: the counts doubled).
       const applied = this.db.transaction(() => {
         if (this.state().offset !== offset) return false;
-        for (const line of text.split("\n")) this.fold(line);
-        this.db.query("UPDATE rollup_state SET byte_offset = ? WHERE id = 1").run(offset + end + 1);
+        // Commit only complete processed records with their offset. Yield between records;
+        // ponytail: one whole record and the existing corrupt-line skip are indivisible;
+        // a streaming parser would be needed to preempt within either operation.
+        for (let start = 0; start <= end;) {
+          const newline = buffer.indexOf(0x0a, start);
+          if (newline < 0 || newline > end) break;
+          this.fold(buffer.subarray(start, newline).toString("utf8"));
+          consumed = newline + 1; start = consumed;
+          if (performance.now() >= deadline) break;
+        }
+        this.db.query("UPDATE rollup_state SET byte_offset = ? WHERE id = 1").run(offset + consumed);
         return true;
       }).immediate();
       if (!applied) return { bytes: 0, done: false };                   // stale: the next pass starts from the stored offset
-      return { bytes: end + 1, done: offset + end + 1 >= size };
+      return { bytes: consumed, done: offset + consumed >= size };
     } finally { closeSync(fd); }
   }
 
@@ -156,7 +170,7 @@ export class UsageRollup {
    */
   catchUp(maxMs?: number): boolean {
     const until = maxMs === undefined ? Infinity : Date.now() + maxMs;
-    for (let i = 0; i < 100_000; i++) { if (this.poll().done) return true; if (Date.now() >= until) return false; }
+    for (let i = 0; i < 100_000; i++) { if (this.poll(Math.min(20, until - Date.now())).done) return true; if (Date.now() >= until) return false; }
     return true;
   }
 
@@ -350,6 +364,60 @@ export class UsageRollup {
       unknownPeers: { tokens: unknownPeers(r => r.tokens), withoutCache: unknownPeers(r => r.withoutCache), cacheRead: unknownPeers(r => r.cacheRead) } };
   }
 
+  /**
+   * Daily tokens per peer for the last `days` calendar UTC days up to `now`, stacked for the dashboard Usage view (#683 U4).
+   * For each day and peer, tokens is native when reported, counted increments when available, otherwise unknown. A day inside
+   * the window with no record is an `empty` row (a gap the chart shows), and the window never starts before the first record.
+   */
+  daily(days = 14, now: number = Date.now()): DailyResult {
+    const raw = this.db.query(`SELECT day, peer, SUM(total) AS total, SUM(total_n) AS total_n FROM usage_rollup GROUP BY day, peer ORDER BY day ASC`).all() as any[];
+    const counted = this.db.query(`SELECT day, peer, SUM(tokens) AS tokens, SUM(increments) AS increments FROM token_rollup GROUP BY day, peer ORDER BY day ASC`).all() as any[];
+    const usageMap = new Map<string, { total: number; total_n: number }>();
+    for (const r of raw) usageMap.set(`${r.day}\0${r.peer}`, { total: r.total, total_n: r.total_n });
+    const countMap = new Map<string, { tokens: number; increments: number }>();
+    for (const r of counted) countMap.set(`${r.day}\0${r.peer}`, { tokens: r.tokens, increments: r.increments });
+
+    const allDays = [...new Set([...raw.map(r => r.day as string), ...counted.map(r => r.day as string)])].sort();
+    const allPeers = [...new Set([...raw.map(r => r.peer as string), ...counted.map(r => r.peer as string)])].sort();
+    // The last `days` calendar days ending today, clipped to the first day that has any record.
+    const dayMs = 86_400_000, today = new Date(now).toISOString().slice(0, 10);
+    const sliceDays: string[] = [];
+    if (allDays.length) for (let i = Math.max(1, Math.min(days, 366)) - 1; i >= 0; i--) {
+      const day = new Date(Date.parse(today + "T00:00:00Z") - i * dayMs).toISOString().slice(0, 10);
+      if (day >= allDays[0]!) sliceDays.push(day);
+    }
+
+    const resultDays: DailyRow[] = [];
+    for (const d of sliceDays) {
+      const peerCounters: Record<string, Counter> = {};
+      const knownCounters: Counter[] = [];
+      for (const p of allPeers) {
+        const u = usageMap.get(`${d}\0${p}`);
+        const c = countMap.get(`${d}\0${p}`);
+        let counterVal: Counter = { value: null, source: "unknown" };
+        if (u && u.total_n > 0) {
+          counterVal = counter(u.total, u.total_n);
+        } else if (c && c.increments > 0) {
+          counterVal = { value: c.tokens, source: "count" };
+        }
+        peerCounters[p] = counterVal;
+        if (counterVal.value !== null) knownCounters.push(counterVal);
+      }
+      let dayTotal: Counter = { value: null, source: "unknown" };
+      if (knownCounters.length > 0) {
+        const sumVal = knownCounters.reduce((acc, cur) => acc + cur.value!, 0);
+        const source: UsageSource = knownCounters.length !== allPeers.length
+          ? "partial"
+          : knownCounters.every(cur => cur.source === "native")
+          ? "native"
+          : "count";
+        dayTotal = { value: sumVal, source };
+      }
+      resultDays.push({ day: d, peers: peerCounters, total: dayTotal, ...(!allDays.includes(d) ? { empty: true as const } : {}) });
+    }
+    return { days: resultDays, peers: allPeers };
+  }
+
   /** Every roll-up row, in key order, for the rebuild-equals-incremental test. */
   dump(): unknown {
     const all = (table: string, order: string) => this.db.query(`SELECT * FROM ${table} ORDER BY ${order}`).all();

package/src/hub/workflow.ts

@@ -46,4 +46,20 @@ export function criteriaView(config: SdlcConfig, task: Task, isPrivate: (t: Task
   for (const criterion of checklist.criteria) if (criterion.required && criterion.result !== "verified") blockers.push(`criterion ${criterion.id}: ${criterion.result}`);
   return { id: checklist.id, ready: blockers.length === 0, blockers, criteria: checklist.criteria.map(c => ({ ...c, refs: [...c.refs] })), ...("tasks" in checklist && (checklist as LegacyPhaseReceipt).tasks.length ? { note: "stored checklist task list ignored: task import was retired (#481)" } : {}) };
 }
+/**
+ * #507b: which of a task's recorded acceptance criteria (the #481 S8 checklist, the only criteria model) a reviewer's unmet items name.
+ * An item names a criterion when it STARTS with that criterion's id, exactly (case and all), followed by the end of the item or a delimiter:
+ * `AC3: the overwrite case has no test`, or just `AC3`. An id the checklist does not hold is plain text, never a criterion, and an id in the
+ * middle of a sentence is not a claim. Pure: items in, ids out (in the order first named, each once).
+ */
+export function unmetCriteriaIds(items: readonly string[], checklist: Pick<CriteriaReceipt, "criteria"> | undefined): string[] {
+  if (!checklist) return [];
+  const known = new Set(checklist.criteria.map(c => c.id));
+  const named: string[] = [];
+  for (const item of items) {
+    const id = /^\s*([A-Za-z][A-Za-z0-9-]{0,47})(?=$|[\s:.,;)\]])/.exec(item)?.[1];
+    if (id !== undefined && known.has(id) && !named.includes(id)) named.push(id);
+  }
+  return named;
+}
 export function workflowHash(value: unknown): string { return createHash("sha256").update(JSON.stringify(value)).digest("hex"); }