@staix/agent-hub 0.12.15 → 0.12.16

package/src/hub/tasks.ts

@@ -8,6 +8,7 @@ import { assign, detectSignals, LOCAL, PI, predictSplit, type Assignment, type R
 import { ExecutionBudget, type ExecutionBudgetConfig, type ExecutionBudgetDecision, type ExecutionBudgetStatus, type ExecutionUnit } from "./execution-budget.ts";
 import { Cohorts, MAX_REQUESTS, type Cohort, type Completion } from "./cohorts.ts";
 import { realPath } from "./project.ts";
+import { nextSweep, taskSweepConfig, type TaskSweepConfig, type SweepRecord } from "./task-sweep.ts";
 
 export interface TasksDeps {
   board: Board;
@@ -68,6 +69,9 @@ export interface TasksDeps {
   recordSplit?: (task: number, prediction: SplitPrediction, where: "routing" | "cohort") => void;
   /** A cohort formed, changed or was lifted (issue #107), for the record: the benchmark's treatment check reads it. */
   recordCohort?: (cohort: { id: number; event: "formed" | "joined" | "lifted"; silent: boolean; tasks: number[]; owners: PeerId[] }) => void;
+  sweep?: TaskSweepConfig;
+  /** Shutdown or coordinator work holds task sweeps too. */
+  sweepHeld?: () => boolean;
 }
 
 const ESCALATE_AFTER = 2;
@@ -80,7 +84,7 @@ const DEMOTE_AT = 1.5;
 const CONTRADICTION_WINDOW_MS = 7 * 86_400_000;
 const OPEN: Task["state"][] = ["proposed", "in_progress", "changes_requested"];
 /** Board events that leave a task where its completion check found it; any other event means it moved on meanwhile. */
-const QUIET_EVENTS = new Set(["answer", "reviewer changed"]);
+const QUIET_EVENTS = new Set(["answer", "reviewer changed", "idle sweep"]);
 
 /** A project path as one spelling (#67): no leading `./`, no repeated or trailing `/`; the root is `.`. */
 export const normPath = (p: string) => p.replace(/^(\.\/)+/, "").replace(/\/{2,}/g, "/").replace(/\/+$/, "") || ".";
@@ -134,8 +138,11 @@ const planText = (plan: TaskPlan = {}) => PLAN_KEYS.filter((k) => plan[k]?.lengt
 export class Tasks {
   /** Turn-free cohorts (issue #107): who works without messages, and who integrates. */
   readonly cohorts: Cohorts;
+  private readonly sweepConfig: TaskSweepConfig;
+  private sweeping = false;
 
   constructor(private readonly d: TasksDeps) {
+    this.sweepConfig = taskSweepConfig(d.sweep);
     this.cohorts = new Cohorts({
       silence: (owners) => this.turnFree() && owners.every((p) => p !== USER && p !== HUB && (this.d.capable?.(p) ?? false)),
       idle: (peer) => this.d.idle?.(peer) ?? false,
@@ -157,6 +164,55 @@ export class Tasks {
 
   isPii = (task: Pick<Task, "signals">) => task.signals.includes("pii") && this.d.routing().constraints.pii === "local_only";
 
+  /** Task-owned, default-off between-turn ladder. Persist before sending so restart cannot repeat a step. */
+  async sweep(now = Date.now()): Promise<{ task: number; finding: SweepRecord }[]> {
+    const recorded: { task: number; finding: SweepRecord }[] = [];
+    if (!this.sweepConfig.enabled || this.sweeping || this.d.sweepHeld?.() || this.d.bus.isRecoveryHeld || this.d.bus.storageError) return recorded;
+    this.sweeping = true;
+    try {
+      for (const task of this.d.board.list()) {
+        if (this.d.sweepHeld?.() || this.d.bus.isRecoveryHeld || this.d.bus.storageError) break;
+        const finding = nextSweep(task, this.sweepConfig, now);
+        if (!finding || this.waitsFor(task).length || this.isChecking(task.id) || this.silentFor(task.id)) continue;
+        const responsible = finding.kind === "review-pending" ? task.reviewer! : task.owner!;
+        if (responsible !== USER && !this.sweepAvailable(responsible)) continue;
+        const title = this.publicTitle(task);
+        const message = `Task ${title}: ${finding.kind}, idle escalation ${finding.step}/3.`;
+        // Only identifiers, kind and step are kept in the ladder event. A crash after this write and before publish
+        // leaves the notice unpublished or uncertain; the durable-delivery journal owns any delivery retries.
+        this.d.board.update(task.id, HUB, "idle sweep", {}, undefined, { sweep: finding });
+        recorded.push({ task: task.id, finding });
+        if (finding.step === 1) {
+          this.sweepNotice(task, responsible, `${message} Check its current state with hub_task_list and accept, complete or review your assigned work.`);
+        } else if (finding.step === 2) {
+          this.d.notify(message);
+          for (const [peer, roles] of Object.entries(this.d.roles ?? {})) {
+            if (peer !== responsible && roles.includes("planner") && this.sweepAvailable(peer)) this.sweepNotice(task, peer, `${message} The assigned ${finding.kind === "review-pending" ? "reviewer" : "owner"} has not recorded fresh task activity; check the board before coordinating.`);
+          }
+        } else {
+          const reviewer = finding.kind === "review-pending";
+          const a = assign(task, this.states(), this.d.routing(), { exclude: [...this.declined(task), responsible], waitsFor: this.waitsFor(task), ...(reviewer ? { candidates: [], notReviewer: task.owner ?? undefined } : {}), ...this.weights(task.class) });
+          const candidate = reviewer ? a.reviewer : a.owner;
+          this.d.notify(`${message} ${reviewer ? "Reviewer" : "Owner"} reassignment suggestion: ${candidate ?? "no eligible peer"}.`);
+          if (!reviewer && candidate && this.sweepConfig.auto_reassign && this.sweepAvailable(candidate)) {
+            await this.assignOwner(this.d.board.get(task.id)!, HUB, { candidates: [candidate], exclude: [responsible], event: "reassigned", note: `idle sweep: ${finding.kind}; from ${responsible}` });
+          }
+        }
+      }
+    } finally { this.sweeping = false; }
+    return recorded;
+  }
+
+  private sweepAvailable(peer: PeerId): boolean {
+    const bus = this.d.bus;
+    return bus.stateOf(peer) === "idle" && (this.d.idle?.(peer) ?? true) && !this.d.held?.()[peer] && !bus.queueSummary(peer).heldBy && !bus.queued(peer) && !bus.hasInFlight(peer);
+  }
+
+  private sweepNotice(task: Task, peer: PeerId, body: string): void {
+    if (peer === USER) this.d.notify(body);
+    else this.d.bus.publish(newEnvelope(HUB, body, { to: [peer], kind: "task", refs: { task: String(task.id) } }));
+  }
+
   configureExecutionBudget = (config: ExecutionBudgetConfig): ExecutionBudgetStatus | undefined => {
     if (!this.d.executionBudget) return undefined;
     if (config.kind === "task" && (!config.taskId || !this.d.board.get(config.taskId))) throw new Error(`task #${config.taskId ?? "?"} does not exist`);

package/src/models/relay.ts

@@ -324,6 +324,11 @@ function sseResponse(response: Response, release: () => void, onModel?: (model:
 
 const copyRecord = (record: RelayRequestRecord): RelayRequestRecord => ({ ...record, ...(record.requestUsage ? { requestUsage: { ...record.requestUsage } } : {}), ...(record.toolSurface ? { toolSurface: { ...record.toolSurface, names: [...record.toolSurface.names] } } : {}) });
 
+/** Pure advertised alias list, also used by no-start launch previews. */
+export function relayModelIds(options: Pick<ModelRelayOptions, "enableHubAuto" | "mlx" | "mlxAlias" | "allowedDGXmodels">): string[] {
+  return [...new Set([...(options.enableHubAuto ? ["hub/auto"] : []), ...(options.mlx ? [options.mlxAlias ?? "mlx/fast"] : []), ...Object.keys(options.allowedDGXmodels)])];
+}
+
 export async function startModelRelay(options: ModelRelayOptions): Promise<ModelRelay> {
   const host = options.host ?? "127.0.0.1";
   assertLoopback(host);
@@ -331,7 +336,7 @@ export async function startModelRelay(options: ModelRelayOptions): Promise<Model
   const mlxAlias = options.mlxAlias ?? "mlx/fast";
   const dgxMaxInputTokens = options.dgxMaxInputTokens ?? 262_144;
   const defaultBackend = options.defaultBackend ?? (options.mlx ? { kind: "mlx", alias: mlxAlias } : { kind: "dgx", alias: "dgx/coding" });
-  const models = [...new Set([...(options.enableHubAuto ? ["hub/auto"] : []), ...(options.mlx ? [mlxAlias] : []), ...Object.keys(options.allowedDGXmodels)])];
+  const models = relayModelIds(options);
   const autoRoute = options.enableHubAuto ? new AutoRouteSelector(options, defaultBackend, mlxAlias, estimateInputTokens) : undefined;
   let mlx: MlxHandle | undefined;
   let mlxStarting: Promise<MlxHandle> | undefined;

package/src/pi/launch.ts

@@ -0,0 +1,20 @@
+import { join } from "node:path";
+import type { PiOptions, PiModelDescriptor, PiTuiLaunch } from "../adapters/pi.ts";
+
+const modelFor = (backend: PiOptions["backend"], models: PiModelDescriptor[]): string => {
+  const ids = models.map((m) => m.id);
+  const find = (needle: string) => ids.find((id) => id === needle) ?? needle;
+  if (backend === "mlx") return find("mlx/fast");
+  if (backend === "dgx") return find("dgx/coding");
+  if (ids.includes("hub/auto")) return "hub/auto";
+  return find(ids.find((id) => id === "dgx/coding") ? "dgx/coding" : ids.find((id) => id === "mlx/fast") ?? "dgx/coding");
+};
+
+/** Pure native launch; bridge/relay setup and session validation remain with the adapter. */
+export function buildPiLaunch(opts: Pick<PiOptions, "stateDir" | "cmd" | "mode" | "backend" | "model" | "relay" | "tools" | "preamble" | "maxSteps" | "sessionFile" | "sessionId">, inherited: NodeJS.ProcessEnv, extension: string, bridgePort: number | string, bridgeToken: string): PiTuiLaunch {
+  const env: NodeJS.ProcessEnv = { ...inherited, PI_CODING_AGENT_DIR: join(opts.stateDir, "pi"), AGENTHUB_PI_BRIDGE_URL: `http://127.0.0.1:${bridgePort}`, AGENTHUB_PI_BRIDGE_TOKEN: bridgeToken, AGENTHUB_PI_OWNER_TOKEN: bridgeToken, AGENTHUB_PI_RELAY_URL: opts.relay.url, AGENTHUB_PI_RELAY_TOKEN: opts.relay.token, AGENTHUB_PI_MODELS: JSON.stringify(opts.relay.models), AGENTHUB_PI_TOOLS: JSON.stringify(opts.tools), AGENTHUB_PI_MAX_STEPS: String(opts.maxSteps ?? 30) };
+  const args = [ ...(opts.mode === "headless" ? ["--mode", "rpc"] : []), "--provider", "agent-hub-local", "--model", opts.model ?? modelFor(opts.backend, opts.relay.models), "--models", opts.relay.models.map((model) => `agent-hub-local/${model.id}`).join(","), "--no-builtin-tools", "--no-skills", "--no-prompt-templates", "--no-extensions", "--extension", extension, ...(opts.preamble ? ["--append-system-prompt", opts.preamble] : []), "--session-dir", join(opts.stateDir, "pi-sessions")];
+  if (opts.sessionFile) args.push("--session", opts.sessionFile); else if (opts.sessionId) args.push("--session-id", opts.sessionId);
+  const command = opts.cmd ?? ["pi"];
+  return { cmd: command[0]!, args: [...command.slice(1), ...args], env };
+}

package/src/ui/index.html

@@ -205,6 +205,12 @@ function render(snapshot) {
     if (!Object.keys(snapshot.budget).length) return empty(target, 'No usage readings yet. Usage appears when a peer reports it.');
     for (const [peer, budget] of Object.entries(snapshot.budget)) {
       const row = el('div', undefined, 'row'); row.append(el('div', peer, 'label'));
+      const context = budget.context;
+      if (context) {
+        const pct = context.used === null ? null : Math.round(context.used * 100);
+        row.append(el('p', 'Context: ' + (pct === null ? 'unknown' : pct + '% used') + ' (' + context.freshness + ')' + (context.source ? ' / ' + context.source : '') + (context.measuredAt !== null ? ' / measured ' + time(context.measuredAt) : ''), 'meta'));
+        if (pct !== null) { const bar = el('progress'); bar.max = 1; bar.value = context.used; bar.setAttribute('aria-label', peer + ' context usage'); row.append(bar); }
+      }
       if (budget.paused) { const line = el('p', 'Paused: ' + budget.paused.reason + ' / resets ', 'meta'), stamp = el('span'); stamp.dataset.ts = budget.paused.resetsAt; stamp.title = time(budget.paused.resetsAt); stamp.textContent = rel(budget.paused.resetsAt); line.append(stamp); row.append(line); }
       if (!budget.windows.length) row.append(el('p', 'No usage windows reported.', 'meta'));
       for (const window of budget.windows) {