@staix/agent-hub 0.30.0 → 0.32.0

package/src/memory/capture.ts

@@ -1,6 +1,7 @@
+import { reviewCaptureExcluded } from "../hub/memory-policy.ts";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { defaultCapturePeer } from "../adapters/definitions/native-identity-defaults.ts";
-import { BOUNDED_TASK_TOOLS, CAPABILITY_TOOLS, HANDOFF_TOOLS, STUDY_TOOLS } from "../hub/hub-tools.ts";
+import { BOUNDED_TASK_TOOLS, CAPABILITY_TOOLS, HANDOFF_TOOLS, QUESTION_TOOLS, STUDY_TOOLS } from "../hub/hub-tools.ts";
 import { MEMORY_READ_TOOLS } from "../hub/read-tools.ts";
 import { isDenied } from "../local/deny.ts";
 import type { MemoryClient } from "./client.ts";
@@ -38,7 +39,9 @@ export class Capture {
   }
 
   observe(call: { tool: string; args: string; output: string; id: string; paths: string[]; sourceId?: string }): void {
-    if (!this.sessionId || ((MEMORY_READ_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || BOUNDED_TASK_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || CAPABILITY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || STUDY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || HANDOFF_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, ""))) || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_memory_correct") || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_source_read" || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_set_title" || this.opts.skip?.includes(call.tool)) return;
+    if (!this.sessionId || reviewCaptureExcluded(call.tool, call.args) || ((MEMORY_READ_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || BOUNDED_TASK_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || CAPABILITY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || STUDY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || HANDOFF_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, ""))) || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_memory_correct") || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_source_read" || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_set_title" || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_evidence_record" || this.opts.skip?.includes(call.tool)) return;
+    // #1053: a question and its answer are the person's and the peer's words: never memory evidence, whatever the call's paths say.
+    if (QUESTION_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, ""))) return;
     // Anything that names a denylisted path is kept out of memory entirely, input and output alike.
     if (call.paths.some((p) => isDenied(p, this.opts.deny) || p.split(/\s+/).some((word) => isDenied(word, this.opts.deny)))) return;
     // ponytail: legacy callers without a host sourceId dedupe native ids within a summary interval; all live LocalPeer calls supply invocation identity. Require that port for other hosts.

package/src/pet/config.ts

@@ -8,7 +8,14 @@ const PALETTES: Record<string, PetPalette> = { a: "blue", b: "teal", c: "violet"
 export function petPalette(value: unknown): PetPalette | undefined {
   return typeof value === "string" ? PALETTES[value.toLowerCase()] : undefined;
 }
-export interface PetConfig { enabled: boolean; blink: boolean; bell: boolean; character?: CharacterId; size?: PetSize; glyphs?: PetGlyphs; palette?: PetPalette; notice?: string; window?: boolean }
+export const PET_WINDOW_RETIRED_NOTICE = "The floating pet window moved to acon Mini; run acon ui and open Mini.";
+/** Source compatibility only. Removed window data is never a terminal option or a settings capability. */
+export function stripLegacyPetWindow(value: unknown): unknown {
+  if (!value || typeof value !== "object" || Array.isArray(value) || !Object.hasOwn(value, "window")) return value;
+  const { window: _retired, ...terminal } = value as Record<string, unknown>;
+  return terminal;
+}
+export interface PetConfig { enabled: boolean; blink: boolean; bell: boolean; character?: CharacterId; size?: PetSize; glyphs?: PetGlyphs; palette?: PetPalette; notice?: string }
 /** Console-local presentation only; it merges pet.palette into config.local.json and grants no authority. */
 export function savePetPalette(cwd: string, value: string): string {
   const palette = petPalette(value);
@@ -35,34 +42,39 @@ export function savePetPalette(cwd: string, value: string): string {
 /** Console-local presentation only; this reader never writes config or grants authority. */
 export function loadPetConfig(cwd: string): PetConfig {
   let value: unknown;
-  let enabled = true;
+  let enabled = true, retiredWindow = false;
   for (const name of ["config.json", "config.local.json"]) {
     try {
       const file = JSON.parse(readFileSync(join(cwd, ".agenthub", name), "utf8"));
-      // A window-only local opt-in does not undo inherited pet:false presentation.
-      if (file.pet === false) enabled = false;
-      else if (file.pet !== undefined && !(file.pet && typeof file.pet === "object" && !Array.isArray(file.pet) && Object.keys(file.pet).length === 1 && Object.hasOwn(file.pet, "window"))) enabled = true;
-      if (file.pet !== undefined) value = value && typeof value === "object" && file.pet && typeof file.pet === "object" ? { ...value, ...file.pet } : file.pet;
+      const pet = stripLegacyPetWindow(file.pet);
+      if (pet !== file.pet) {
+        retiredWindow = true;
+        // A retired-only block contributes no terminal override, including no enablement over inherited pet:false.
+        if (pet && typeof pet === "object" && !Object.keys(pet).length) continue;
+      }
+      if (pet === false) enabled = false;
+      else if (pet !== undefined) enabled = true;
+      if (pet !== undefined) value = value && typeof value === "object" && pet && typeof pet === "object" ? { ...value, ...pet } : pet;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
     }
   }
-  if (value === false) return { enabled: false, blink: true, bell: false };
+  const notice = (other?: string) => [retiredWindow ? PET_WINDOW_RETIRED_NOTICE : undefined, other].filter(Boolean).join(" ");
+  if (value === false) return { enabled: false, blink: true, bell: false, ...(retiredWindow ? { notice: notice() } : {}) };
   const defaults = { enabled: true, blink: true, bell: false };
-  if (value === undefined) return defaults;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return { ...defaults, notice: "Unknown pet configuration; using stai line defaults." };
+  if (value === undefined) return { ...defaults, ...(retiredWindow ? { notice: notice() } : {}) };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { ...defaults, notice: notice("Unknown pet configuration; using stai line defaults.") };
   const row = value as Record<string, unknown>;
-  const invalid = Object.keys(row).some(key => !["character", "size", "glyphs", "blink", "bell", "palette", "window"].includes(key)) ||
+  const invalid = Object.keys(row).some(key => !["character", "size", "glyphs", "blink", "bell", "palette"].includes(key)) ||
     row.character !== undefined && !characterId(row.character) || row.size !== undefined && !["line", "mini", "full"].includes(row.size as string) ||
     row.glyphs !== undefined && (typeof row.glyphs !== "string" || !["auto", "ascii", "blocks"].includes(row.glyphs)) ||
     row.palette !== undefined && !petPalette(row.palette) ||
-    row.blink !== undefined && typeof row.blink !== "boolean" || row.bell !== undefined && typeof row.bell !== "boolean" || row.window !== undefined && typeof row.window !== "boolean";
+    row.blink !== undefined && typeof row.blink !== "boolean" || row.bell !== undefined && typeof row.bell !== "boolean";
   const palette = petPalette(row.palette);
   return { enabled, blink: typeof row.blink === "boolean" ? row.blink : true, bell: typeof row.bell === "boolean" ? row.bell : false,
-    ...(typeof row.window === "boolean" ? { window: row.window } : {}),
     ...(characterId(row.character) && row.character !== "stai" ? { character: row.character } : {}),
     ...(row.size === "mini" || row.size === "full" ? { size: row.size } : {}),
     ...(row.glyphs === "ascii" || row.glyphs === "blocks" ? { glyphs: row.glyphs } : {}),
     ...(palette && palette !== "teal" ? { palette } : {}),
-    ...(invalid ? { notice: "Unknown pet option; using stai line defaults for that option." } : {}) };
+    ...(invalid || retiredWindow ? { notice: notice(invalid ? "Unknown pet option; using stai line defaults for that option." : undefined) } : {}) };
 }

package/src/rooms/commands.ts

@@ -3,14 +3,17 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { assertRoomCryptoReady, decodeBase64url, encodeBase64url, signBytes, verifyBytes } from "./crypto.ts";
 import { acceptRoomEpoch, brokerUrl, canonicalBytes, createInvite, createJoin, createRoomEpoch, decodeInvite, decodeJoin, decodeRoster, roomMembers } from "./wire.ts";
-import { RoomStore, type RoomState, type RoomPersonInboxMeta, type RoomPersonInboxItem } from "./store.ts";
+import { RoomStore, type RoomState, type RoomPersonInboxMeta, type RoomPersonInboxItem, type RoomOutgoing } from "./store.ts";
 import { RoomLink } from "./link.ts";
 import { exposedPeers, roomName, RoomPolicy } from "./policy.ts";
 import type { RoomChat } from "./service.ts";
 import { projectRoomStatus, type RoomStatusView } from "./status.ts";
 
 export interface RoomCommandResult { kind?: string; artifact?: string; name?: string; room?: string; owner?: string; member?: string }
-export interface RoomPreview { owner: string; member: string; commit: () => Promise<RoomCommandResult> }
+export interface RoomPreview { owner: string; member: string; outstanding?: readonly string[]; commit: () => Promise<RoomCommandResult> }
+export class RoomRotationHoldError extends Error {
+  constructor() { super("room epoch rotated but delivery journal holds are unavailable; inspect ahub room status and ahub queue show before another mutation"); this.name = "RoomRotationHoldError"; }
+}
 const FP = /^[0-9a-f]{64}$/;
 function refuse(code: string): never { throw new Error(`room: ${code}`); }
 function fields(input: unknown, keys: string[], optional: string[] = []): Record<string, any> {
@@ -47,9 +50,10 @@ export class RoomCommands {
   private pending?: Promise<RoomStore>;
   private store?: RoomStore;
   private stopped = false;
+  private stopWork?: Promise<void>;
   private readonly links = new Map<string, RoomLink>();
   private readonly policy: RoomPolicy;
-  constructor(private readonly options: { stateDir: string; cwd: string; clock?: () => number; presence?: () => readonly {id: string; state: string}[]; chat?: RoomChat }) { this.policy = new RoomPolicy(options.cwd); }
+  constructor(private readonly options: { stateDir: string; cwd: string; clock?: () => number; refreshMs?: number; presence?: () => readonly {id: string; state: string}[]; chat?: RoomChat }) { this.policy = new RoomPolicy(options.cwd); }
   private async open(): Promise<RoomStore> {
     if (this.stopped) refuse("stopped");
     this.pending ??= RoomStore.open({ stateDir: join(this.options.stateDir, "rooms"), ...(this.options.clock ? { clock: this.options.clock } : {}) }).then(store => {
@@ -63,13 +67,19 @@ export class RoomCommands {
     const store = await this.open();
     if (!this.stopped) for (const state of store.list()) if (!state.left) this.link(state.name);
   }
-  stop(): void { this.stopped = true; clearTimeout(this.presenceTimer); this.options.chat?.stop(); for (const link of this.links.values()) link.stop(); this.links.clear(); this.store?.close(); }
+  stop(): Promise<void> {
+    if (this.stopWork) return this.stopWork;
+    this.stopped = true; clearTimeout(this.presenceTimer); this.options.chat?.stop();
+    const stops = [...this.links.values()].map(link => link.stop()); this.links.clear();
+    this.stopWork = Promise.allSettled([...(this.pending ? [this.pending] : []), ...stops]).then(() => { this.store?.close(); });
+    return this.stopWork;
+  }
   private link(name: string): void {
     if (this.stopped || !this.store || this.store.get(name)?.left) return;
     let link = this.links.get(name);
     if (!link) {
       const store = this.store;
-      const created: RoomLink = new RoomLink({ store, name, application: this.options.chat?.application,
+      const created: RoomLink = new RoomLink({ store, name, application: this.options.chat?.application, refreshMs: this.options.refreshMs, now: this.options.clock,
         onPresence: value => this.options.chat?.presence(store, name, created, value),
         onState: state => this.options.chat?.linkState(store, name, created, state), presence: () => {
         const allowed = new Set(this.policy.get(name));
@@ -78,7 +88,7 @@ export class RoomCommands {
       this.links.set(name, created); link = created;
       this.options.chat?.bind(store, name, created);
       void created.start().catch(() => undefined);
-    } else { this.options.chat?.bind(this.store, name, link); link.refresh(); }
+    } else { this.options.chat?.bind(this.store, name, link); link.refresh(); void link.start().catch(() => undefined); }
   }
   private presenceTimer?: ReturnType<typeof setTimeout>;
   changed(): void {
@@ -91,6 +101,26 @@ export class RoomCommands {
     this.presenceTimer.unref?.();
   }
   private current(check: () => boolean): void { if (this.stopped || !check()) refuse("state_changed"); }
+  private async rotate(store: RoomStore, name: string, digest: string, expected: readonly RoomOutgoing[], check: () => boolean,
+    operation: (current: () => boolean) => Promise<RoomState>, after?: () => void): Promise<RoomState> {
+    const ids = expected.map(row => row.deliveryId).sort(), release = await this.links.get(name)?.quiesceApplications();
+    let next: RoomState | undefined, returned = false;
+    const current = () => !this.stopped && check() && store.get(name)?.current.digest === digest
+      && JSON.stringify(store.rotationPending(name).map(row => row.deliveryId).sort()) === JSON.stringify(ids);
+    try {
+      if (!current()) refuse("state_changed");
+      next = await operation(current);
+      const held = next.current.digest === digest || this.options.chat?.epochRotated(store, name, digest, expected) !== false;
+      this.current(check); after?.();
+      if (!held) throw new RoomRotationHoldError();
+      returned = true; return next;
+    } finally {
+      release?.();
+      // A committed epoch still needs publication if its journal label or local
+      // policy update failed; its old sealed intents were already fenced atomically.
+      if (next && !returned && next.current.digest !== digest) this.link(name);
+    }
+  }
   private active(store: RoomStore, name: string): RoomState {
     const state = store.get(name); if (!state || state.left) refuse("unavailable"); return state;
   }
@@ -196,9 +226,12 @@ export class RoomCommands {
         ? { room: existing.current.room, owner, minEpoch: existing.current.epoch, digest: existing.current.digest }
         : { room: invitation!.room, owner, minEpoch: "0" } });
       this.current(check);
-      return { owner, member: own, commit: async () => {
+      const outstanding = existing ? store.rotationPending(name) : [];
+      return { owner, member: own, ...(existing ? { outstanding: outstanding.map(row => row.deliveryId).sort() } : {}), commit: async () => {
         this.current(check);
-        const state = await store.install({ name, broker, wire, expectedDigest: existing?.current.digest ?? null, current: check, reactivate: true });
+        const state = existing ? await this.rotate(store, name, existing.current.digest, outstanding, check, current =>
+          store.install({ name, broker, wire, expectedDigest: existing.current.digest, current, reactivate: true }))
+          : await store.install({ name, broker, wire, expectedDigest: null, current: check, reactivate: true });
         return completed(state);
       } };
     }
@@ -235,7 +268,11 @@ export class RoomCommands {
     const state = this.active(store, name), owner = this.owner(state), digest = state.current.digest;
     if (action === "leave") return { owner, member: own, commit: async () => {
       this.current(check); if (store.get(name)?.current.digest !== digest) refuse("state_changed");
-      store.leave(name); this.links.get(name)?.stop(); this.links.delete(name); return { name, room: state.current.room, owner, member: own };
+      await this.links.get(name)?.stop();
+      try {
+        this.current(check); if (store.get(name)?.current.digest !== digest) refuse("state_changed");
+        store.leave(name); this.links.delete(name); return { name, room: state.current.room, owner, member: own };
+      } catch (error) { this.link(name); throw error; }
     } };
     if (action === "invite") {
       if (owner !== own) refuse("owner_only");
@@ -254,9 +291,12 @@ export class RoomCommands {
         if (!sender || exposure.room !== state.current.room || exposure.owner !== owner || exposure.digest !== digest || !await verifyBytes({ fingerprint: sender.fingerprint, signingKey: sender.signingKey, agreementKey: sender.agreementKey }, exposureBytes(body), decodeBase64url(signature, 64))) refuse("untrusted");
       }
       this.current(check);
-      return { owner, member, commit: async () => {
+      const outstanding = store.rotationPending(name);
+      return { owner, member, outstanding: outstanding.map(row => row.deliveryId).sort(), commit: async () => {
         this.current(check);
-        const next = exposure ? await store.rotate(name, roomMembers(state.current).map(m => m.fingerprint === member ? { ...m, exposedPeers: exposedPeers(exposure.peers) } : m), digest, check) : await store.enroll(name, request, check);
+        const next = await this.rotate(store, name, digest, outstanding, check, current => exposure
+          ? store.rotate(name, roomMembers(state.current).map(m => m.fingerprint === member ? { ...m, exposedPeers: exposedPeers(exposure.peers) } : m), digest, current)
+          : store.enroll(name, request, current));
         this.current(check); completed(next);
         return { name, owner, member, kind: "roster", artifact: encodeBase64url(next.wire) };
       } };
@@ -264,19 +304,24 @@ export class RoomCommands {
     if (action === "revoke") {
       if (owner !== own) refuse("owner_only");
       if (typeof row.member !== "string" || !FP.test(row.member) || row.member === own || !roomMembers(state.current).some(m => m.fingerprint === row.member)) refuse("invalid_member");
-      return { owner, member: row.member, commit: async () => {
-        this.current(check); const next = await store.rotate(name, roomMembers(state.current).filter(m => m.fingerprint !== row.member), digest, check); return completed(next);
+      const outstanding = store.rotationPending(name);
+      return { owner, member: row.member, outstanding: outstanding.map(row => row.deliveryId).sort(), commit: async () => {
+        this.current(check); const next = await this.rotate(store, name, digest, outstanding, check, current =>
+          store.rotate(name, roomMembers(state.current).filter(m => m.fingerprint !== row.member), digest, current)); return completed(next);
       } };
     }
     if (action === "expose") {
       const peers = exposedPeers(row.peers ?? []);
       this.policy.assertWritable(name, peers, check);
-      return { owner, member: own, commit: async () => {
+      const outstanding = owner === own ? store.rotationPending(name) : [];
+      return { owner, member: own, ...(owner === own ? { outstanding: outstanding.map(row => row.deliveryId).sort() } : {}), commit: async () => {
         this.current(check); this.policy.assertWritable(name, peers, check);
         if (store.get(name)?.current.digest !== digest) refuse("state_changed");
         if (owner === own) {
-          const next = await store.rotate(name, roomMembers(state.current).map(m => m.fingerprint === own ? { ...m, exposedPeers: peers } : m), digest, check);
-          this.current(check); this.policy.set(name, peers, check); return completed(next);
+          const next = await this.rotate(store, name, digest, outstanding, check, current =>
+            store.rotate(name, roomMembers(state.current).map(m => m.fingerprint === own ? { ...m, exposedPeers: peers } : m), digest, current),
+          () => this.policy.set(name, peers, check));
+          return completed(next);
         }
         const body: Omit<ExposureRequest, "signature"> = { v: 1, type: "exposure", room: state.current.room, owner, member: own, digest, peers };
         const request = canonicalBytes({ ...body, signature: encodeBase64url(await signBytes(store.identity, exposureBytes(body))) });