@staix/agent-hub 0.12.31 → 0.12.32

package/src/hub/tasks.ts

@@ -97,6 +97,8 @@ export interface TasksDeps {
   recordScreen?: (record: ScreenRecord) => void;
   /** Turn-free coordination (issue #107): configured and no PII task open. Asked at each use. */
   turnFree?: () => boolean;
+  /** Coordination preference captured for each newly created task; existing rows keep their initial mode. */
+  coordination?: () => boolean;
   /** Whether a peer's context path for facts is verified in its current session (issue #108). */
   capable?: (peer: PeerId) => boolean;
   /** Whether `peer` is between native turns now (issue #107): Codex not busy, Claude stopped since its last tool call. */
@@ -223,10 +225,15 @@ export class Tasks {
   private readonly knownPlanners = new Set<PeerId>();
   /** Turn-free cohorts (issue #107): who works without messages, and who integrates. */
   readonly cohorts: Cohorts;
-  private readonly sweepConfig: TaskSweepConfig;
+  private readonly coordinationModes = new Map<number, boolean>();
+  private sweepConfig: TaskSweepConfig;
   private sweeping = false;
 
   constructor(private readonly d: TasksDeps) {
+    if (d.coordination) {
+      const mode = d.coordination();
+      for (const task of d.board.list()) this.coordinationModes.set(task.id, mode);
+    }
     const backlog = d.board.list("backlog");
     for (const [peer, roles] of Object.entries(d.roles ?? {})) {
       if (!roles.includes("planner")) continue;
@@ -310,13 +317,14 @@ export class Tasks {
   /** 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;
+    const config = this.sweepConfig;
+    if (!config.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;
         if (!task.owner && this.personUnassigned(task)) continue;
-        const finding = nextSweep(task, this.sweepConfig, now, this.waitsFor(task).length === 0);
+        const finding = nextSweep(task, config, now, this.waitsFor(task).length === 0);
         if (!finding || this.waitsFor(task).length || this.isChecking(task.id) || this.silentFor(task.id)) continue;
         if (finding.kind === "ready-unassigned") {
           this.d.board.update(task.id, HUB, "idle sweep", {}, undefined, { sweep: finding });
@@ -329,7 +337,7 @@ export class Tasks {
           } else {
             const admission = this.plannerPullRecord(task)?.pull ? this.plannerAssignment(task, true) : assign(task, this.states(), this.d.routing(), { exclude: this.excluded(task), ...this.weights(task.class) });
             this.releaseNotice(`${text} Owner reassignment suggestion: ${admission.owner ?? "no eligible peer"}.`);
-            if (admission.owner && this.sweepConfig.auto_reassign && this.sweepAvailable(admission.owner)) {
+            if (admission.owner && config.auto_reassign && this.sweepAvailable(admission.owner)) {
               try { await this.assignOwner(this.d.board.get(task.id)!, HUB, { candidates: [admission.owner], event: "reassigned", reason: "idle", note: "ready-unassigned idle sweep" }); }
               catch (e) { if (!(e instanceof AssignmentUndeliveredError)) throw e; }
             }
@@ -338,7 +346,7 @@ export class Tasks {
         }
         const responsible = finding.kind === "review-pending" ? task.reviewer! : task.owner!;
         if (responsible !== USER && !this.sweepAvailable(responsible)) continue;
-        if (finding.step === 3 && finding.kind !== "review-pending" && this.sweepConfig.auto_reassign && this.plannerPullRecord(task)?.pull && !assign(task, this.states(), this.d.routing(), { exclude: [...this.excluded(task), responsible], excludeOwners: this.plannerFull(task), waitsFor: this.waitsFor(task), ...this.weights(task.class) }).owner) continue;
+        if (finding.step === 3 && finding.kind !== "review-pending" && config.auto_reassign && this.plannerPullRecord(task)?.pull && !assign(task, this.states(), this.d.routing(), { exclude: [...this.excluded(task), responsible], excludeOwners: this.plannerFull(task), waitsFor: this.waitsFor(task), ...this.weights(task.class) }).owner) 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
@@ -358,7 +366,7 @@ export class Tasks {
           const candidate = reviewer ? a.reviewer : a.owner;
           this.passedOver(task, a);
           this.d.notify(`${message} ${reviewer ? "Reviewer" : "Owner"} reassignment suggestion: ${candidate ?? "no eligible peer"}.`);
-          if (!reviewer && candidate && this.sweepConfig.auto_reassign && this.sweepAvailable(candidate)) {
+          if (!reviewer && candidate && config.auto_reassign && this.sweepAvailable(candidate)) {
             try {
               await this.assignOwner(this.d.board.get(task.id)!, HUB, { candidates: [candidate], exclude: [responsible], event: "reassigned", reason: "idle", note: `idle sweep: ${finding.kind}; from ${responsible}` });
             } catch (e) {
@@ -373,6 +381,11 @@ export class Tasks {
     return recorded;
   }
 
+  /** A validated snapshot takes effect on the next sweep, never halfway through one. */
+  configureSweep(config: TaskSweepConfig): void {
+    this.sweepConfig = taskSweepConfig(config);
+  }
+
   private sweepAvailable(peer: PeerId): boolean {
     const bus = this.d.bus;
     return bus.stateOf(peer) === "idle" && (this.d.idle?.(peer) ?? true) && !peerEntry(this.d.held?.(), peer) && !bus.queueSummary(peer).heldBy && !bus.queued(peer) && !bus.hasInFlight(peer);
@@ -934,6 +947,10 @@ export class Tasks {
     const inherited = current.drafts.map((_part, index) => (initialParentPrivate || this.isPii(current.parent)) && !deterministicPrivate[index]);
     const drafts = current.drafts.map((part, index) => ({ ...part, ...(screening ? { screeningNote: inherited[index] ? "pii: inherited" : this.screenNote(verdicts[index]) } : {}), signals: [...new Set([...initialPrivacy[index]!, ...initialParentPrivacy, ...finalSignals[index]!, ...current.parent.signals.filter(signal => ["pii", "pii_path", "urgent"].includes(signal)), ...(verdicts[index] && verdicts[index]!.label !== "clear" ? ["pii"] : [])])] }));
     const result = this.d.board.splitBacklog(id, by, revision, drafts, reason, withheld || initialReasonPrivate || this.isPii(current.parent) || !this.nameable(reason));
+    if (this.d.coordination) {
+      const mode = this.d.coordination();
+      for (const child of result.children) this.coordinationModes.set(child.id, mode);
+    }
     for (const [index, child] of result.children.entries()) {
       this.incomingBacklog.add(child.id);
       if (screening) { this.recordScreen(child.id, "task", verdicts[index], inherited[index]); if (verdicts[index]?.label === "unknown") this.releaseNotice(`task #${child.id}: the PII screen gave no verdict (${verdicts[index]!.miss}); it is handled as a PII task`); }
@@ -1029,6 +1046,7 @@ export class Tasks {
     if (external) { const prior = this.d.board.imported(external.repo, external.issue); if (prior) return prior; }
     if (reserved) this.requireCapabilities({ ...draft, signals, ...(external ? { external } : {}) }, reserved);
     let task = this.d.board.propose(by, { ...draft, plan, ...(external ? { external } : {}), ...(deps.length ? { deps } : {}), ...(reserved ? { reserved } : {}), signals, ...(backlog ? { backlog: true } : {}) });
+    if (this.d.coordination) this.coordinationModes.set(task.id, this.d.coordination());
     created?.();
     if (screening) task = this.screenedTask(task, screened);
     if (goal) this.linkNative(task, goal, by);
@@ -1912,8 +1930,10 @@ export class Tasks {
    */
   private formCohort(task: Task, hits: ReturnType<Tasks["overlapHits"]>): void {
     if (!task.owner || this.isPii(task)) return;
+    const coordinate = this.coordinationModes.get(task.id);
+    const coordinated = this.d.coordination ? hits.filter(hit => this.coordinationModes.get(hit.task.id) === coordinate) : hits;
     const before = this.cohorts.of(task.id)?.revision;
-    const joined = this.cohorts.join(task, hits.map((h) => h.task), ownerGen, handedAt);
+    const joined = this.cohorts.join(task, coordinated.map((h) => h.task), ownerGen, handedAt, !this.d.coordination || coordinate === true);
     if (!joined) return;
     const c = joined.cohort;
     if (joined.formed || c.revision !== before) {
@@ -2668,7 +2688,7 @@ export class Tasks {
     let n = 0;
     for (const t of this.d.board.list("approved")) {
       if (this.isPii(t)) continue;
-      try { this.d.memoryCheck?.(); const key = this.memoryKey(t); if (this.d.store.store.hasTask(key) && !this.d.store.store.settled(key)) { this.settleMemory(t); n++; } }
+      try { this.d.memoryCheck?.(); const key = this.memoryKey(t); if (this.d.store.store.hasTask(key) && !this.d.store.store.settled(key, { includeLegacy: true })) { this.settleMemory(t); n++; } }
       catch { /* fail-open: tried again at the next start */ }
     }
     return n;

package/src/hub/ui.ts

@@ -131,7 +131,7 @@ export function startDashboard(options: DashboardOptions) {
         }
       }
       try {
-        if (sessionOf(cookie).liveTest && !["start", "stop", "pause", "resume", "permit", "start_peer", "setting", "setting_undo", "setting_preview", "sdlc_queue", "sdlc_release"].includes(String(input.action))) {
+        if (sessionOf(cookie).liveTest && !["start", "stop", "pause", "resume", "permit", "start_peer", "setting", "setting_undo", "setting_preview", "setting_reload", "sdlc_queue", "sdlc_release"].includes(String(input.action))) {
           return reject(403, "live-test dashboard cannot write person-attributed content; use peer tools");
         }
         if (input.action === "sdlc_queue" || input.action === "sdlc_release") server.timeout(req, 35);

package/src/memory/brief.ts

@@ -45,7 +45,7 @@ export class Briefs {
   constructor(
     private readonly client: MemoryClient | undefined,
     private readonly project: string,
-    private readonly maxItems = 8,
+    private readonly maxItems: number | (() => number) = 8,
     private readonly native?: NativeBrief,
     /** 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,
@@ -53,18 +53,19 @@ export class Briefs {
   ) {}
 
   async forTask(peer: PeerId, task: BriefTask, priority: readonly NativeItem[] = []): Promise<string | undefined> {
+    const maximum = typeof this.maxItems === "function" ? this.maxItems() : this.maxItems;
     const seen = this.seen.get(peer) ?? new Set<string>();
     this.seen.set(peer, seen);
     const own: NativeItem[] = [];
     // A plan fail is task-specific guidance even when a previous task already carried it.
-    for (const item of priority) if (own.length < this.maxItems && !own.some(existing => existing.id === item.id)) own.push(item);
-    try { for (const item of this.native?.(task) ?? []) if (!seen.has(item.id) && !own.some(existing => existing.id === item.id) && own.length < this.maxItems) own.push(item); } catch { /* fail-open: the store is optional */ }
-    const found = this.client && own.length < this.maxItems ? await related(this.client, this.project, [task.title, ...(task.refs.paths ?? [])].join(" ")) : [];
+    for (const item of priority) if (own.length < maximum && !own.some(existing => existing.id === item.id)) own.push(item);
+    try { for (const item of this.native?.(task) ?? []) if (!seen.has(item.id) && !own.some(existing => existing.id === item.id) && own.length < maximum) own.push(item); } catch { /* fail-open: the store is optional */ }
+    const found = this.client && own.length < maximum ? await related(this.client, this.project, [task.title, ...(task.refs.paths ?? [])].join(" ")) : [];
     const items: BriefItem[] = [];
     for (const item of found) {
       if (seen.has(`#${item.id}`)) continue;
       items.push(item);
-      if (own.length + items.length === this.maxItems) break;
+      if (own.length + items.length === maximum) break;
     }
     if (!own.length && !items.length) return undefined;
     for (const item of own) seen.add(item.id);

package/src/pi/session.ts

@@ -4,13 +4,32 @@ import { randomUUID } from "node:crypto";
 import { realPath } from "../hub/project.ts";
 import { atomicPrivateJSON } from "../hub/recovery-store.ts";
 
+export class PiSessionUnresumable extends Error {
+  readonly code = "pi_session_unresumable";
+  constructor(readonly reason: "missing" | "outside_managed" | "invalid_header", message: string, options?: ErrorOptions) { super(message, options); }
+}
+export class PiSessionBookmarkMismatch extends Error {
+  readonly code = "pi_session_bookmark_mismatch";
+  readonly reason = "bookmark_mismatch";
+}
+function sessionReadFailure(error: unknown): never {
+  if ((error as NodeJS.ErrnoException).code === "ENOENT") throw new PiSessionUnresumable("missing", (error as Error).message, { cause: error });
+  throw error;
+}
+
 /** One validation boundary for ordinary starts and explicit preserved-history selection. */
 export function validatePiSession(stateDir: string, cwd: string, sessionFile: string, sessionId?: string): { sessionFile: string; sessionId: string } {
-  const file = realPath(sessionFile), sessions = realPath(join(stateDir, "pi-sessions"));
+  let file: string, sessions: string;
+  try { file = realPath(sessionFile); sessions = realPath(join(stateDir, "pi-sessions")); }
+  catch (error) { return sessionReadFailure(error); }
   const rel = relative(sessions, file);
-  if (!rel || rel.startsWith("..") || resolve(sessions, rel) !== file) throw new Error("Pi session file is outside the managed project session directory");
-  const header = JSON.parse(readFileSync(file, "utf8").split("\n", 1)[0]!);
-  if (header.type !== "session" || typeof header.id !== "string" || !header.id || typeof header.cwd !== "string" || realPath(header.cwd) !== realPath(cwd) || (sessionId && header.id !== sessionId)) throw new Error("Pi session header does not match the requested project/session");
+  if (!rel || rel.startsWith("..") || resolve(sessions, rel) !== file) throw new PiSessionUnresumable("outside_managed", "Pi session file is outside the managed project session directory");
+  let first: string;
+  try { first = readFileSync(file, "utf8").split("\n", 1)[0]!; } catch (error) { return sessionReadFailure(error); }
+  let header: { type?: unknown; id?: unknown; cwd?: unknown } | null;
+  try { header = JSON.parse(first); } catch (error) { throw new PiSessionUnresumable("invalid_header", (error as Error).message, { cause: error }); }
+  if (!header || header.type !== "session" || typeof header.id !== "string" || !header.id || typeof header.cwd !== "string" || realPath(header.cwd) !== realPath(cwd)) throw new PiSessionUnresumable("invalid_header", "Pi session header does not match the requested project/session");
+  if (sessionId && header.id !== sessionId) throw new PiSessionBookmarkMismatch("Pi continuity bookmark does not match the preserved session");
   return { sessionFile: file, sessionId: header.id };
 }
 

package/src/ui/index.html

@@ -319,16 +319,19 @@ async function previewSetting(row, value, out, control) {
 function settingRow(row, raise) {
   const node = el('div', undefined, 'row'), head = el('div', undefined, 'row-head'), id = 'setting-' + row.key.replaceAll('.', '-');
   const title = el('label', row.label, 'label'); title.htmlFor = id;
+  const fileValue = row.fileValue !== undefined ? row.fileValue : row.pending !== undefined ? row.pending : row.value;
   head.append(title, badge(settingText(row.value), row.group === 'Permissions' && row.value !== null && row.value !== 'ask' ? 'warn' : ''));
-  node.append(head, el('p', row.key + ' / from ' + row.source + ' / ' + (row.applies === 'live' ? 'applies at once' : row.applies === 'peer start' ? "applies at the peer's next start" : 'read at hub start') + ' / written to ' + row.file, 'meta'));
-  if (row.pending !== undefined) node.append(el('p', 'Pending restart: ' + settingText(row.pending) + ' at the next ' + (row.applies === 'peer start' ? 'peer' : 'hub') + ' start.', 'meta'));
+  node.append(head, el('p', row.key + ' / from ' + row.source + ' / ' + (row.applies === 'live' ? 'applies at once' : row.applies === 'next use' ? 'applies at next use' : row.applies === 'restart' ? 'applies after restart' : row.applies === 'peer start' ? "applies at the peer's next start" : 'read at hub start') + ' / written to ' + row.file, 'meta'));
+  node.append(el('p', 'Running: ' + settingText(row.value) + ' / File: ' + settingText(fileValue), 'meta'));
+  if (['live', 'next use', 'restart'].includes(row.applies)) node.append(el('p', 'Apply: ' + row.applies + (row.restartReason ? ' / ' + row.restartReason : ''), 'meta'));
+  if (row.pending !== undefined) node.append(el('p', ['hub start', 'peer start'].includes(row.applies) ? 'Pending restart: ' + settingText(row.pending) + ' at the next ' + (row.applies === 'peer start' ? 'peer' : 'hub') + ' start.' : 'Pending ' + row.applies + ': ' + settingText(row.pending), 'meta'));
   if (row.hint) node.append(el('p', 'Bounds: ' + row.hint, 'meta'));
   if (row.note) node.append(el('p', row.note, 'meta'));
   if (row.risk === 'raises' && !raise) node.append(el('p', 'Raising this needs a settings session: run ahub ui --settings.' + (row.floor === undefined ? '' : ' Setting it to ' + row.floor + ' works here.'), 'meta'));
   const actions = el('div', undefined, 'actions'), stored = row.file !== 'this hub run';
   let read, confirm, force;
   if (row.type === 'roles') {
-    const current = Array.isArray(row.pending) ? row.pending : Array.isArray(row.value) ? row.value : [];
+    const current = Array.isArray(fileValue) ? fileValue : [];
     const choices = [0, 1].map(index => {
       const select = el('select'); select.id = index ? id + '-second' : id;
       if (index) select.setAttribute('aria-label', row.label + ': second optional role');
@@ -338,15 +341,15 @@ function settingRow(row, raise) {
       select.value = current[index] || ''; actions.append(select); return select;
     });
     read = () => choices.map(select => select.value).filter(Boolean);
-  } else if (row.type === 'integer') {
-    const input=el('input');input.type='number';input.id=id;input.step='1';input.min=String(row.min ?? 0);input.max=String(row.max ?? Number.MAX_SAFE_INTEGER);const current=row.pending!==undefined ? row.pending : row.value;input.value=current===null ? '' : String(current);input.placeholder='Empty inherits';
+  } else if (row.type === 'integer' || row.type === 'number') {
+    const input=el('input');input.type='number';input.id=id;input.step=row.type === 'number' ? 'any' : '1';input.min=String(row.min ?? 0);input.max=String(row.max ?? Number.MAX_SAFE_INTEGER);const current=fileValue;input.value=current===null ? '' : String(current);input.placeholder='Empty inherits';
     read=()=>input.value==='' ? null : Number(input.value);actions.append(input);
   } else if (row.type === 'peers') {
-    const input = el('input'); input.type = 'text'; input.id = id; input.value = Array.isArray(row.value) ? row.value.join(', ') : ''; input.placeholder = 'peer ids, comma-separated; empty inherits'; input.autocomplete = 'off'; input.spellcheck = false;
+    const input = el('input'); input.type = 'text'; input.id = id; input.value = Array.isArray(fileValue) ? fileValue.join(', ') : ''; input.placeholder = 'peer ids, comma-separated; empty inherits'; input.autocomplete = 'off'; input.spellcheck = false;
     read = () => { const list = input.value.split(',').map((value) => value.trim()).filter(Boolean); return list.length ? list : null; };
     actions.append(input);
   } else {
-    const select = el('select'), values = row.type === 'boolean' ? ['true', 'false'] : (row.values || []), current = row.value === null ? '' : String(row.value); select.id = id;
+    const select = el('select'), values = row.type === 'boolean' ? ['true', 'false'] : (row.values || []), current = fileValue === null ? '' : String(fileValue); select.id = id;
     if (current && !values.includes(current)) { const option = el('option', current + ' (now)'); option.value = current; option.disabled = true; select.append(option); }
     for (const value of values) { const option = el('option', value); option.value = value; select.append(option); }
     if (stored) { const option = el('option', 'inherit (remove the machine-local value)'); option.value = INHERIT; select.append(option); }
@@ -391,6 +394,7 @@ function renderSettings(settings, roster = []) {
   // are rebuilt only when their own data changed, so a value being typed in one row survives a save of another.
   update('settings', settings.rows.map((row) => row.key), (target) => {
     settingSlots.clear();
+    const reload = el('div'); settingSlots.set('$reload', { node: reload, signature: null }); target.append(reload);
     const undo = el('div'); settingSlots.set('', { node: undo, signature: null }); target.append(undo);
     for (const group of SETTING_GROUPS) {
       const rows = settings.rows.filter((row) => row.group === group);
@@ -402,6 +406,18 @@ function renderSettings(settings, roster = []) {
       target.append(box);
     }
   });
+  const reloadSlot = settingSlots.get('$reload'), reloadSupported = Array.isArray(settings.pendingRestart);
+  const reloadSignature = JSON.stringify([settings.pendingRestart, managerMode && !snapshotValid]);
+  if (reloadSlot && reloadSlot.signature !== reloadSignature) {
+    reloadSlot.signature = reloadSignature; reloadSlot.node.replaceChildren();
+    if (reloadSupported) {
+      reloadSlot.node.append(button('Reload configuration', {action:'setting_reload'}));
+      if (settings.pendingRestart.length) {
+        reloadSlot.node.append(el('p', 'Pending restart', 'label'));
+        for (const pending of settings.pendingRestart) reloadSlot.node.append(el('p', pending.key + ': ' + pending.reason, 'meta'));
+      }
+    }
+  }
   const undoSlot = settingSlots.get(''), undoKey = settings.undo || '';
   if (undoSlot && undoSlot.signature !== undoKey) {
     undoSlot.signature = undoKey; undoSlot.node.replaceChildren();