@staix/agent-hub 0.16.0 → 0.18.0

package/src/memory/brief.ts

@@ -1,3 +1,4 @@
+import { buildIntentBrief, type IntentBriefOptions, type IntentBriefSource } from "@staix/agent-mem";
 import type { PeerId } from "../hub/envelope.ts";
 import type { MemoryClient } from "./client.ts";
 
@@ -30,17 +31,20 @@ export async function related(client: MemoryClient, project: string, query: stri
 /** A native memory line for a brief (#258): `mem:<id8> <kind> <tier>: <title or text>`, fails first. */
 export interface NativeItem { id: string; line: string; kind?: string; about?: readonly string[]; tier?: string; peer?: string; machine?: string; at?: string }
 export type NativeBrief = (task: BriefTask) => NativeItem[] | Promise<NativeItem[]>;
+export interface IntentBriefContext { source: IntentBriefSource; options: IntentBriefOptions }
+/** Host-owned policy and store binding; the library owns relevance, ordering and text. */
+export type IntentBriefHost = (task: BriefTask) => IntentBriefContext | Promise<IntentBriefContext>;
 export interface BriefTask { id?: number; created?: number; title: string; refs: { paths?: string[] }; plan?: { paths?: string[]; symbols?: string[] } }
 
 /**
- * Task briefs: what memory already knows about a piece of work, handed over with it. The hub's own store first (#258:
- * entries one or two hops from the task's paths, symbols, issue and task, a linked fail first, superseded entries
- * dropped), then amem: index first (search), then the neighbourhood of the top hit (timeline); details stay in
- * the store for the receiver to fetch by id. `brief_items` caps both together. A peer is never shown the same entry
- * twice in one hub run, except a directly matching plan fail that must accompany a new task.
+ * Production task briefs use the library's intent retrieval and rendering with host policy and bindings.
+ * The hub applies its per-peer delivery dedupe and item cap to complete library rows, reserving the front
+ * for host-screened plan fails even when the library's byte cap omitted them. Injected clients without
+ * the library port retain the legacy index/timeline bridge; intent mode retires its related/readNotice path.
  */
 export class Briefs {
   private readonly seen = new Map<PeerId, Set<string>>();
+  private readonly libraryRuns = new Map<PeerId, Promise<unknown>>();
 
   constructor(
     private readonly client: MemoryClient | undefined,
@@ -50,11 +54,47 @@ export class Briefs {
     /** Counts of what a brief carried, for the research records (#258 AC11); never its text. */
     private readonly observe?: (peer: PeerId, task: number, counts: { native: number; fails: number; claudeMem: number }) => void,
     private readonly displayNative?: (items: readonly NativeItem[]) => string[],
+    private readonly intent?: IntentBriefHost,
   ) {}
 
   async forTask(peer: PeerId, task: BriefTask, priority: readonly NativeItem[] = []): Promise<string | undefined> {
     // A brief snapshots its configured cap once, before either optional source is selected.
     const maximum = typeof this.maxItems === "function" ? this.maxItems() : this.maxItems;
+    if (this.intent) {
+      // Serialize only this peer's library reads, so awaited policy cannot duplicate a delivered note.
+      const previous = this.libraryRuns.get(peer);
+      const run = (async () => {
+        await previous?.catch(() => undefined);
+        if (maximum < 1) return undefined;
+        try {
+          const context = await this.intent!(task);
+          const seen = this.seen.get(peer) ?? new Set<string>();
+          this.seen.set(peer, seen);
+          const revision = context.options.policyVersion();
+          const result = await buildIntentBrief(context.source, context.options);
+          if (result.state === "unknown" || context.options.allowed?.() === false || context.options.policyVersion() !== revision) return undefined;
+          context.options.assertCurrent?.();
+          const lines = result.text.split("\n");
+          const rendered = new Map(result.items.map((item, index) => [`mem:${item.id}`, lines[index + 1]!]));
+          const selected: NativeItem[] = [];
+          // Priority is already screened and sanitized by the host's plan guard. Its advice must survive
+          // the standalone library's byte cap or narrower retrieval policy, and recur with the next task.
+          for (const item of priority) if (selected.length < maximum && !selected.some(row => row.id === item.id)) selected.push({ ...item, line: rendered.get(item.id) ?? item.line });
+          for (const item of result.items) {
+            const id = `mem:${item.id}`;
+            if (selected.length < maximum && !seen.has(id) && !selected.some(row => row.id === id)) selected.push({ id, line: rendered.get(id)!, kind: item.kind });
+          }
+          if (!selected.length) return undefined;
+          // Preserve complete library rows (including graph neighbours after a seen direct bridge).
+          const text = [lines[0] || "Live fail notes for this plan (advice, not a block):", ...selected.map(item => item.line)].join("\n");
+          for (const item of selected) seen.add(item.id);
+          if (task.id !== undefined) try { this.observe?.(peer, task.id, { native: selected.length, fails: selected.filter(item => item.kind === "fail").length, claudeMem: 0 }); } catch { /* telemetry never fails a brief */ }
+          return text;
+        } catch { return undefined; }
+      })();
+      this.libraryRuns.set(peer, run);
+      try { return await run; } finally { if (this.libraryRuns.get(peer) === run) this.libraryRuns.delete(peer); }
+    }
     const seen = this.seen.get(peer) ?? new Set<string>();
     this.seen.set(peer, seen);
     let native: NativeItem[] = [];

package/src/ui/index.html

@@ -1399,7 +1399,8 @@ function renderBoard(snapshot, peers, ids) {
       const data=(snapshot.boardLegend || []).find(item=>item.peer===id), row=el('div',undefined,'agent-slot');
       row.append(peerMark(id),el('p',String(peers[id].state || 'unknown'),'meta'));
       const wip=data && Number.isSafeInteger(data.wip) && data.wip>=0 ? data.wip : 'unknown';
-      row.append(el('p','WIP '+wip+(Number.isSafeInteger(data?.wipLimit) ? '/'+data.wipLimit : '')+' / permission '+(data?.permissionMode || 'unknown'),'meta'));
+      const split=data?.wipBreakdown,splitText=split && [split.active,split.reviewWait,split.reserved].every(Number.isSafeInteger) ? ' (active '+split.active+', review-wait '+split.reviewWait+', reserved '+split.reserved+')' : '';
+      row.append(el('p','WIP '+wip+(Number.isSafeInteger(data?.wipLimit) ? '/'+data.wipLimit : '')+splitText+' / permission '+(data?.permissionMode || 'unknown'),'meta'));
       if (Array.isArray(data?.activeTasks) && data.activeTasks.length) row.append(el('p','Active tasks: '+data.activeTasks.map(id=>'#'+id).join(', '),'meta'));
       const filter=el('button','View '+id);filter.type='button';filter.addEventListener('click',()=>{if(!boardViewState)return;peerFilter.value=id;renderBoard(boardViewState.snapshot,boardViewState.peers,boardViewState.ids)});row.append(filter);
       if (eligible.includes(id)) dropTarget(row,card=>card.assignable,{action:'assign',peer:id});