@staix/agent-hub 0.12.23 → 0.12.25

package/src/hub/bus.ts

@@ -10,9 +10,12 @@ export type BusEvent =
   | { t: "undeliverable"; env: Envelope; peer: PeerId; reason?: string }
   | { t: "stale"; env: Envelope; peer: PeerId; reason: string }
   | { t: "quiet"; env: Envelope; peers: PeerId[]; reason: string }
+  | { t: "off_roster"; env: Envelope; peers: PeerId[] }
   | { t: "state"; peer: PeerId; state: PeerState };
 
 export interface BusOptions {
+  /** Live project membership; absent preserves the existing audience and delivery behaviour. */
+  rostered?: (peer: PeerId) => boolean;
   /** Transient owner lifecycle fence: retain new work without changing console/budget pauses. */
   deliveryHeld?: (peer: PeerId) => boolean;
   /** Observe original envelopes immediately before a transport starts its turn. */
@@ -155,6 +158,7 @@ export class Bus {
     if (!this.queues.has(peer.id)) this.queues.set(peer.id, []);
     peer.onDelivery = (receipt) => this.deliveryReceipt(peer.id, receipt);
     peer.onMessage = (text, opts) => {
+      if (!this.isRostered(peer.id)) return `off roster: ${peer.id}`;
       const { priority, body } = parseMarker(text);
       if (!body) return;
       // What the peer was handed differs from what it stands for once a delivery was condensed; both the audience
@@ -167,15 +171,22 @@ export class Bus {
       const audienceOriginals = originals ?? (opts?.to?.includes(DIGEST) && condensed ? last?.originals : undefined);
       const to = opts?.to?.length ? resolveTo(opts.to, audienceOriginals) : undefined;
       let env = newEnvelope(peer.id, body, { ...opts, ...(to ? { to } : {}), priority: opts?.priority ?? capPriority(peer, priority, opts?.inReplyTo, originals) });
+      const offRoster = this.offRosterRecipients(env);
+      if (offRoster.length && offRoster.length === new Set(env.to?.filter(id => id !== env.from)).size) {
+        const reason = `off roster: ${offRoster.join(", ")}`;
+        this.note(peer.id, noteLine(HUB, "decision", `your message was not delivered: ${reason}`));
+        return reason; // no publication and no limiter spend for an entirely refused audience
+      }
+      const admittedEnv = offRoster.length ? { ...env, to: env.to!.filter(id => !offRoster.includes(id)) } : env;
       // Limits count what is sent: the envelope as built (a reply goes to its parent's sender, `digest` is resolved,
       // the priority is capped), never the raw `to`.
       const parent = opts?.inReplyTo?.id;
       // Held back from every recipient (issue #107): nothing goes out, so nothing counts against the sender's limits.
       const hushed = this.hushed(env);
       const heldBack = hushed.length > 0 && hushed.length === this.audience(env).length;
-      let refused = heldBack ? undefined : this.opts.admit?.(env, parent);
+      let refused = heldBack ? undefined : this.opts.admit?.(admittedEnv, parent);
       // A turn answer has no caller to refuse: over its important budget it goes out as status, not at all.
-      if (refused && env.priority === "important" && !this.opts.admit?.({ ...env, priority: "status" }, parent)) {
+      if (refused && env.priority === "important" && !this.opts.admit?.({ ...admittedEnv, priority: "status" }, parent)) {
         // It went out, so the advice on how to send it does not apply.
         this.note(peer.id, noteLine(HUB, "decision", `your [IMPORTANT] message went out as status: ${refused.replace(/[;:] (retry after \d+ s, or )?send it without \[IMPORTANT\]$/, "")}`));
         env = { ...env, priority: "status" };
@@ -186,6 +197,7 @@ export class Bus {
         return refused;
       }
       this.publish(env);
+      if (offRoster.length) this.note(peer.id, noteLine(HUB, "decision", `your message is retained off roster for ${offRoster.join(", ")}; delivered to the other recipients`));
       // The sender's result (issue #107): a turn answer has no caller, so it hears it on its next delivery. It counts as
       // not sent only when nobody got it.
       if (hushed.length) this.note(peer.id, noteLine(HUB, "decision", `your message was not delivered to ${hushed.map((h) => h.peer).join(", ")}: ${hushed[0]!.reason}`));
@@ -466,6 +478,17 @@ export class Bus {
     return (this.queues.get(id) ?? []).map((e) => e.id);
   }
 
+  queuedBacklogIds(id: PeerId): Set<number> {
+    const ids = new Set<number>();
+    const retained = [...(this.queues.get(id) ?? []), ...(this.journal?.unresolved(id).filter(row => row.state !== "queued").flatMap(row => row.originals) ?? [])];
+    for (const env of retained) {
+      const backlog = env.refs?.backlog;
+      if (env.from !== HUB || env.kind !== "task" || !Array.isArray(backlog) || backlog.length > 64) continue;
+      for (const task of backlog) if (Number.isSafeInteger(task) && task > 0) ids.add(task);
+    }
+    return ids;
+  }
+
   attemptState(): Record<string, number> {
     return Object.fromEntries(this.attempts);
   }
@@ -541,12 +564,12 @@ export class Bus {
 
     const hushed = this.hushed(env);
     if (hushed.length) this.emit({ t: "quiet", env, peers: hushed.map((h) => h.peer), reason: hushed[0]!.reason });
-    const targets = this.audience(env).filter((id) => !hushed.some((h) => h.peer === id));
+    const targets = this.audience(env).filter((id) => !hushed.some((h) => h.peer === id) || !this.isRostered(id));
     this.suppressDrain = !!this.journal;
     try { for (const id of targets) {
       const peer = this.peers.get(id);
       if (!peer) { this.enqueue(id, env); continue; }
-      if (!this.journal && !this.recoveryHeld && !this.recoveryHeldPeers.has(id) && !this.opts.deliveryHeld?.(id) && env.priority === "important" && peer.steer && this.stateOf(id) === "busy") {
+      if (!this.journal && !this.held(id) && env.priority === "important" && peer.steer && this.stateOf(id) === "busy") {
         // Not queued while the steer is in flight, or an idle transition would deliver it a second time.
         this.steering++;
         const deliveryId = crypto.randomUUID();
@@ -566,23 +589,39 @@ export class Bus {
       this.onQueues?.();
       for (const id of targets) {
         const peer = this.peers.get(id);
-        if (!this.recoveryHeld && !this.recoveryHeldPeers.has(id) && !this.opts.deliveryHeld?.(id) && env.priority === "important" && peer?.steer && this.stateOf(id) === "busy") void this.steerQueued(id, env);
+        if (!this.held(id) && env.priority === "important" && peer?.steer && this.stateOf(id) === "busy") void this.steerQueued(id, env);
         else void this.drain(id);
       }
     }
+    const offRoster = targets.filter(id => !this.isRostered(id));
+    if (offRoster.length) this.emit({ t: "off_roster", env, peers: offRoster });
     return targets;
   }
 
+  isRostered(peer: PeerId): boolean { return this.opts.rostered?.(peer) ?? true; }
+
+  /** Explicit off-roster recipients, including unattached retained targets; broadcasts have none. */
+  offRosterRecipients(env: Envelope): PeerId[] {
+    return [...new Set(env.to ?? [])].filter(peer => peer !== env.from && !this.isRostered(peer));
+  }
+
+  /** Membership changed externally: reconsider delivery, keeping every independent hold intact. */
+  rosterChanged(peer: PeerId): void {
+    if (this.closed) return;
+    this.onQueues?.();
+    void this.drain(peer);
+  }
+
   /** Who an envelope is queued for: its `to`, or every peer but its sender. */
   audience(env: Envelope): PeerId[] {
     const known = new Set([...this.peers.keys(), ...this.queues.keys(), ...(this.journal?.list().map((d) => d.peer) ?? [])]);
-    return (env.to ?? [...this.peers.keys()]).filter((id) => id !== env.from && known.has(id));
+    return (env.to ?? [...this.peers.keys()]).filter((id) => id !== env.from && (known.has(id) || !this.isRostered(id)) && (env.to !== undefined || this.isRostered(id)));
   }
 
   /** The recipients of `env` that the silence policy holds it back from, each with why (issue #107). */
   hushed(env: Envelope): { peer: PeerId; reason: string }[] {
     if (!this.opts.silence || env.hop > MAX_HOP || env.priority === "fyi") return [];
-    return this.audience(env).flatMap((peer) => {
+    return this.audience(env).filter(peer => this.isRostered(peer)).flatMap((peer) => {
       const reason = this.opts.silence!(env, peer);
       return reason ? [{ peer, reason }] : [];
     });
@@ -728,9 +767,9 @@ export class Bus {
     finally { this.steering--; this.onQueues?.(); }
   }
 
-  /** Holds on a peer's queue, for a drain and a pull alike: recovery, an uncertain delivery, a pause (console, budget, conductor). */
+  /** Holds on a peer's queue, for a drain and a pull alike: off roster, recovery, an uncertain delivery, a pause (console, budget, conductor). */
   private held(id: PeerId): boolean {
-    return this.recoveryHeld || this.recoveryHeldPeers.has(id) || this.paused.has(id) || this.opts.deliveryHeld?.(id) === true;
+    return !this.isRostered(id) || this.recoveryHeld || this.recoveryHeldPeers.has(id) || this.paused.has(id) || this.opts.deliveryHeld?.(id) === true;
   }
 
   /** What a peer was just handed stays resolvable for `reply_to`: moved to the newest end, the stored envelope kept. */

package/src/hub/citations.ts

@@ -0,0 +1,7 @@
+/** Bounded Markdown [@key] and BibTeX entry-key example check, no fetching or model verdict. */
+export function citationKeys(markdown: string, bibliography: string): { cited: string[]; missing: string[] } {
+  if (Buffer.byteLength(markdown) > 256 * 1024 || Buffer.byteLength(bibliography) > 4 * 1024 * 1024) throw new Error("citation inputs exceed example check limits");
+  const known = new Set([...bibliography.matchAll(/@[a-zA-Z]+\s*\{\s*([^,\s{}]+)\s*,/g)].map(m => m[1]!));
+  const cited = [...new Set([...markdown.matchAll(/\[@[A-Za-z0-9_:./-]+(?:\s*;\s*@[A-Za-z0-9_:./-]+)*\]/g)].flatMap(m => [...m[0].matchAll(/@([A-Za-z0-9_:./-]+)/g)].map(k => k[1]!)))].sort();
+  return { cited, missing: cited.filter(key => !known.has(key)) };
+}

package/src/hub/conductor.ts

@@ -2,7 +2,7 @@ import { Database } from "bun:sqlite";
 import type { Task } from "./board.ts";
 import { CONDUCTOR_TOOL_NAMES } from "./hub-tools.ts";
 import { HUB, USER } from "./envelope.ts";
-import { OWNERSHIP_EVENTS } from "./tasks.ts";
+import { OWNERSHIP_EVENTS, type TaskAssignmentRole } from "./tasks.ts";
 import { PreEffectToolRefusal } from "./tool-refusal.ts";
 import { isStartablePeer, type StartablePeer, type StartMode } from "./start-mode.ts";
 import type { HubEvent } from "./events.ts";
@@ -111,7 +111,7 @@ export type ConductorStart = { peer: StartablePeer; mode: "headless" } | { peer:
 export function conductorStart(peer: unknown, mode: unknown, preview: (peer: "claude" | "codex" | "pi") => string, preEffect: boolean, startMode: (peer: StartablePeer) => StartMode): ConductorStart {
   const refuse = (text: string) => new (preEffect ? PreEffectToolRefusal : Error)(text);
   if (mode !== undefined && mode !== "headless" && mode !== "tui") throw refuse("mode must be headless or tui");
-  if (!isStartablePeer(peer)) throw refuse("only claude, codex, kimi, pi and local may be started by the conductor");
+  if (!isStartablePeer(peer)) throw refuse("only claude, codex, kimi, pi and local, plus opt-in qwen/jcode, may be started by the conductor");
   const own = startMode(peer);
   if (mode !== undefined && mode !== own) throw refuse(`${peer} starts ${own} here; a person sets a start mode (ahub settings), the conductor cannot choose one`);
   return own === "tui" ? { peer: peer as "claude" | "codex" | "pi", mode: "tui", command: preview(peer as "claude" | "codex" | "pi") } : { peer, mode: "headless" };
@@ -156,7 +156,7 @@ export interface ConductorHooks {
   task(id: number): Task | undefined;
   publicView(task: Task): Record<string, unknown>;
   /** These callbacks must call Tasks, never Board.update. */
-  assign(actor: string, id: number, peer: string): Promise<unknown>;
+  assign(actor: string, id: number, peer: string, role?: TaskAssignmentRole): Promise<unknown>;
   escalate(actor: string, id: number): Promise<unknown>;
   preview(peer: "claude" | "codex" | "pi"): string;
   /** The mode a start of this peer takes: a person's setting. */
@@ -182,18 +182,20 @@ export class Conductor {
   constructor(private readonly holds: ConductorHolds, private readonly hooks: ConductorHooks) {}
   async execute(actor: string, tool: string, args: Record<string, unknown>): Promise<unknown> {
     if (!CONDUCTOR_TOOL_NAMES.has(tool)) throw new PreEffectToolRefusal("unknown conductor tool");
+    const role = args.role ?? "owner";
+    if (tool === "hub_task_assign" && role !== "owner" && role !== "reviewer") throw new PreEffectToolRefusal("role must be owner or reviewer");
     if ((tool === "hub_task_show" || tool === "hub_task_assign") && conductorPeer(this.hooks.roles()) !== actor) {
       const id = taskId(args.id);
       const task = id === undefined ? undefined : this.hooks.task(id);
       // A task's current owner and reviewer read its public view without the role (#208); nobody else does.
-      if (task && tool === "hub_task_show" && (task.owner === actor || task.reviewer === actor)) return publicConductorTask(task, this.hooks.publicView);
+      if (task && task.state !== "backlog" && tool === "hub_task_show" && (task.owner === actor || task.reviewer === actor)) return publicConductorTask(task, this.hooks.publicView);
       // Its proposer (the first history entry) redirects it while nobody ever accepted it (#207: a decline or a release puts
       // worked tasks back in proposed); work that waits gets a reserved owner. Never over the person: a console assign or
       // reservation stands until the conductor or the console moves it, also once the hub carried it out (the hub's own
       // moves are not decisions).
-      const moved = task?.history.findLast((h) => h.by !== HUB && (OWNERSHIP_EVENTS.has(h.event) || h.event === "reserved"));
+      const moved = task?.history.findLast((h) => h.by !== HUB && (OWNERSHIP_EVENTS.has(h.event) || h.event === "reserved" || h.planning?.fields.includes("reserved")));
       const accepted = task?.history.some((h) => h.event === "accepted");
-      if (task && tool === "hub_task_assign" && task.history[0]?.by === actor && task.state === "proposed" && !accepted && moved?.by !== USER) {
+      if (task && tool === "hub_task_assign" && role === "owner" && task.history[0]?.by === actor && task.state === "proposed" && !accepted && moved?.by !== USER) {
         const peer = peerId(args.peer, true);
         if (peer !== actor) requireAssign(actor, this.hooks.capabilities(), true);
         await this.hooks.assign(actor, task.id, peer);
@@ -212,10 +214,13 @@ export class Conductor {
       if (id === undefined) throw new PreEffectToolRefusal("id must be a positive integer");
       const task = this.hooks.task(id);
       if (!task) throw new PreEffectToolRefusal(`no task #${args.id}`);
+      if (task.state === "backlog") throw new PreEffectToolRefusal("backlog is read through planner tools, not conductor task tools");
       if (tool === "hub_task_show") { const result = publicConductorTask(task, this.hooks.publicView); emit({ task: task.id }); return result; }
       if (tool === "hub_task_assign") {
         const peer = peerId(args.peer, true);
-        await this.hooks.assign(actor, task.id, peer); emit({ task: task.id, peer });
+        if (role === "reviewer") await this.hooks.assign(actor, task.id, peer, role);
+        else await this.hooks.assign(actor, task.id, peer);
+        emit({ task: task.id, peer });
       } else { await this.hooks.escalate(actor, task.id); emit({ task: task.id }); }
       // Task callbacks may return raw objects; always re-read and apply the public view.
       const updated = this.hooks.task(task.id);

package/src/hub/config-trust.ts

@@ -28,6 +28,8 @@ export const MACHINE_LOCAL = [
   "local.network_allow", // the hosts the egress proxy opens (#65)
   "terminal.open", // the command a hub-made TUI start runs to open a terminal (#269)
 ] as const;
+/** Legacy exported field list stays compatible; new policies use the complete list below. */
+export const ALL_MACHINE_LOCAL = [...MACHINE_LOCAL, "protect_instruction_files", "qwen_cmd", "jcode_cmd", "jcode_home", "jcode_provider_profile", "text_projection"] as const;
 
 /**
  * Why `.agenthub/<name>` must not set machine-local fields, or undefined when git confirms nobody committed it.
@@ -84,8 +86,8 @@ const drop = (file: Record<string, unknown>, path: string) => {
  * once resolved to the project root). A committed copy of the template sets them to defaults and asks git nothing.
  */
 export function stripUntrusted(file: Record<string, unknown>, defaults: object, cwd: string, name: string): string | undefined {
-  for (const p of MACHINE_LOCAL) if (valueAt(file, p) !== undefined && !chooses(valueAt(file, p))) drop(file, p);
-  const set = MACHINE_LOCAL.filter((p) => {
+  for (const p of ALL_MACHINE_LOCAL) if (valueAt(file, p) !== undefined && !chooses(valueAt(file, p))) drop(file, p);
+  const set = ALL_MACHINE_LOCAL.filter((p) => {
     const v = valueAt(file, p);
     return v !== undefined && JSON.stringify(v) !== JSON.stringify(valueAt(defaults, p));
   });

package/src/hub/crash.ts

@@ -47,6 +47,8 @@ export function removeSessions(stateDir: string, instanceId?: string): void {
   if (instanceId === undefined || readSessions(stateDir)?.instanceId === instanceId) rmSync(fileOf(stateDir), { force: true });
 }
 
+export const qwenSessionId = (value: unknown): value is string => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(value);
+
 const str = (v: unknown) => (typeof v === "string" && v ? v : undefined);
 
 /**
@@ -62,6 +64,13 @@ export function crashPlan(records: SessionRecord[]): { peer: string; resume?: Re
         return { peer, how: "claude: the Claude Code plugin reconnects by itself while that session is still open" };
       case "codex":
         return { peer, how: `codex: its app-server died with the hub; run ahub codex again${str(meta.threadId) ? ` (its conversation was thread ${meta.threadId})` : ""}` };
+      case "jcode":
+        return { peer, how: "jcode: native 0.94.0 load does not prove the restored id; reopen the original conversation with its native client, no automatic fresh replacement" };
+      case "qwen": {
+        const sessionId = meta.sessionId;
+        if (!qwenSessionId(sessionId)) return { peer, how: "qwen: saved ACP session identity unavailable; start it deliberately with ahub qwen" };
+        return { peer, resume: { sessionId, ...(model ? { model } : {}) }, how: "qwen: the recorded conversation can be loaded again (ACP session/load)" };
+      }
       case "kimi": {
         const sessionId = str(meta.sessionId);
         if (!sessionId) return { peer, how: "kimi: no session id was recorded; start it again with ahub kimi" };