@staix/agent-hub 0.12.39 → 0.12.40

package/src/hub/tasks.ts

@@ -27,6 +27,8 @@ import { assign, detectSignals, peerEntry, predictSplit, relayCandidates, type A
 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 { TaskRepositories } from "./task-repository.ts";
+import { mainCheckoutWarning } from "./main-checkout.ts";
 import { PreEffectToolRefusal } from "./tool-refusal.ts";
 import { coverageGap, renderReviewBrief, type ReviewBrief } from "./review-brief.ts";
 import { ADAPTERS, DEFAULT_REVIEW_POOL, definitionOf, familyOf } from "../adapters/registry.ts";
@@ -228,6 +230,16 @@ function cleanRefs(input: unknown): TaskRefs {
   return out;
 }
 
+/** Acceptance may correct repository metadata, never file intent or work evidence. */
+function acceptRefs(input: unknown): TaskRefs | undefined {
+  if (input == null) return undefined;
+  if (typeof input !== "object" || Array.isArray(input) || Object.keys(input).some(key => key !== "repo")) throw new PreEffectToolRefusal("accept refs may contain only repo");
+  const raw = input as Record<string, unknown>;
+  if (!Object.hasOwn(raw, "repo")) return undefined;
+  if (typeof raw.repo !== "string" || !raw.repo.trim() || raw.repo.length > 300) throw new PreEffectToolRefusal("accept refs.repo must be a bounded repository slug or path");
+  return { repo: text(raw.repo)! };
+}
+
 /** The same for a plan (issue #31): only its four lists, each of short strings. */
 function cleanPlan(input: unknown, profile: ProfileSelection = "dev"): TaskPlan {
   const r = fields(input);
@@ -248,6 +260,7 @@ const RESCREEN_MAX = 10;
  * PII handling, envelopes, briefs and memory notes are decided in one place.
  */
 export class Tasks {
+  private readonly repositories: TaskRepositories;
   private readonly incomingBacklog = new Set<number>();
   private readonly plannerBacklog = new Map<PeerId, Set<number>>();
   private readonly plannerBlockedQueue = new Map<PeerId, string>();
@@ -259,6 +272,8 @@ export class Tasks {
   private sweeping = false;
 
   constructor(private readonly d: TasksDeps) {
+    this.repositories = new TaskRepositories(d.cwd, d.repository);
+    for (const task of d.board.list()) this.warmRepository(task);
     if (d.coordination) {
       const mode = d.coordination();
       for (const task of d.board.list()) this.coordinationModes.set(task.id, mode);
@@ -685,6 +700,7 @@ export class Tasks {
       const theirs = this.places(t);
       // Blame needs the same file or symbol: a directory or `.` would contradict every approval under it. Older rows
       // were stored as written, so both sides are compared in one spelling.
+      if (mine.repositoryKey !== theirs.repositoryKey) continue;
       const file = (p: string) => normPath(p) !== "." && theirs.paths.some((q) => normPath(q) === normPath(p));
       const same = mine.paths.some(file) || mine.symbols.some((x) => theirs.symbols.includes(x));
       if (!same || this.d.board.reviews({ task: t.id }).some((r) => r.kind === "contradicted")) continue;
@@ -728,6 +744,24 @@ export class Tasks {
   private plannerFull(task: Task): PeerId[] {
     return Object.keys(this.states()).filter(peer => { const queue = this.d.bus.queueSummary(peer); return this.wip(peer, task.id) >= this.wipLimit(peer) || !!queue.heldBy || queue.needsReview > 0; });
   }
+  /**
+   * Why a planner pull finds no owner (#531), named from what the assignment saw and never from task text: the peers a
+   * lasting exclusion keeps out, a peer at its WIP limit (with wip/limit), a held queue and needs_review. Peer ids and counts
+   * only, so the text is safe for a PII task too. `route explain` reads the same `excluded()` and `plannerFull` inputs.
+   */
+  plannerRefusal(task: Task): string {
+    const parts: string[] = [];
+    const excluded = [...new Set(this.excluded(task))];
+    if (excluded.length) parts.push(`${excluded.join(", ")} declined or was escalated away from this task for good; only a person's ahub task assign lifts that`);
+    for (const peer of Object.keys(this.states())) {
+      if (excluded.includes(peer)) continue;
+      const queue = this.d.bus.queueSummary(peer), wip = this.wip(peer, task.id), limit = this.wipLimit(peer);
+      if (wip >= limit) parts.push(`${peer} WIP full (${wip}/${limit}); no eligible planner WIP capacity`);
+      else if (queue.heldBy) parts.push(`${peer} has a held queue (a delivery is held; resolve it with ahub queue list)`);
+      else if (queue.needsReview > 0) parts.push(`${peer} has ${queue.needsReview} delivery(ies) in needs_review`);
+    }
+    return parts.length ? `no peer can take the planner pull: ${parts.join("; ")}` : "no peer has eligible planner WIP capacity";
+  }
   private plannerAssignment(task: Task, reservedOnly = false): Assignment {
     const states = this.states();
     const full = this.plannerFull(task);
@@ -758,7 +792,7 @@ export class Tasks {
         })) throw new PreEffectToolRefusal("a person's P0 backlog order is retained");
       }
       const assignment = this.plannerAssignment(task);
-      if (!assignment.owner) throw new PreEffectToolRefusal("no peer has eligible planner WIP capacity");
+      if (!assignment.owner) throw new PreEffectToolRefusal(this.plannerRefusal(task));
       if (this.hasPersonReservation(task) && assignment.owner !== task.reserved) throw new PreEffectToolRefusal("a person's reservation is retained");
       return { task, owner: assignment.owner };
     };
@@ -899,6 +933,8 @@ export class Tasks {
         }
         if (patch.reserved && !definitionOf(patch.reserved, this.d.instances?.()) && !this.d.bus.knownPeers().includes(patch.reserved) && !this.d.routing().classes[task.class]?.peers.includes(patch.reserved)) throw new PreEffectToolRefusal("reserved owner is not a supported or configured peer");
         if (patch.reserved && !this.d.bus.isRostered(patch.reserved)) throw new PreEffectToolRefusal("reserved owner is off roster");
+        // #531 D3: a reservation for a peer routing leaves out for good could never be honoured. Say so, and who can lift it.
+        if (patch.reserved && this.excluded(task).includes(patch.reserved)) throw new PreEffectToolRefusal(`${patch.reserved} is excluded from this task (it declined it or was escalated away from it for good); a reservation for it can never be honoured. Only a person's ahub task assign lifts the exclusion`);
         if (patch.reserved) this.requireCapabilities(task, patch.reserved);
         const rows = new Map(this.d.board.list().map(row => [row.id, row]));
         const pending = [...(patch.deps ?? task.deps ?? [])], seen = new Set<number>();
@@ -1044,6 +1080,7 @@ export class Tasks {
     const verdicts = screenedVerdicts.map((verdict, index) => deterministicPrivate[index] ? undefined : verdict);
     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"] : [])])] }));
+    for (const draft of drafts) this.warmRepository(draft);
     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();
@@ -1238,7 +1275,7 @@ export class Tasks {
     const text = { title, detail: String(input.detail ?? "").slice(0, 8000), refs: cleanRefs(input.refs) };
     const plan = cleanPlan(input.plan, this.d.profileData ?? profile);
     // The plan reaches other owners, so a PII pattern in it makes the task a PII task like one in the detail would.
-    const screenDetail = [text.detail, external?.repo, external?.url].filter(value => value !== undefined && value !== "").join("\n");
+    const screenDetail = [text.detail, text.refs.repo, external?.repo, external?.url].filter(value => value !== undefined && value !== "").join("\n");
     const signals = this.signalsFor({ ...text, detail: [screenDetail, planText(plan)].join("\n"), plan });
     // Urgent work is handed over even when its paused owner's window resets soon (issue #36).
     if (input.urgent === true && !signals.includes("urgent")) signals.push("urgent");
@@ -1268,7 +1305,10 @@ export class Tasks {
     const draft = { ...text, class: cls, ...(selected ? { role: selected.id } : {}), ...(profile !== "dev" || given !== undefined && given !== cls || this.d.profileData && this.d.profileData !== projectProfile("dev") ? { profile, profileClass: given ?? cls, ...(profile === "dev" ? { customProfile: true as const } : {}) } : {}) };
     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);
+    this.warmRepository({ refs: draft.refs, plan });
+    const repositoryMismatch = !this.isPii({ signals }) && this.repositories.mismatch(draft.refs, plan);
     let task = this.d.board.propose(by, { ...draft, plan, ...(external ? { external } : {}), ...(deps.length ? { deps } : {}), ...(reserved ? { reserved } : {}), signals, ...(backlog ? { backlog: true } : {}) });
+    if (repositoryMismatch) this.releaseNotice(`task #${task.id}: refs and plan name different repositories; check refs.repo before editing`);
     if (this.d.coordination) this.coordinationModes.set(task.id, this.d.coordination());
     created?.();
     if (screening) task = this.screenedTask(task, screened);
@@ -1553,9 +1593,15 @@ export class Tasks {
    * Paths from refs and plan, symbols from the plan: the places a task says it touches (issue #31). Models write paths
    * absolute or relative: one inside the project is compared in its project-relative spelling.
    */
-  private places(task: Task): { paths: string[]; symbols: string[] } {
-    const paths = [...(task.refs.paths ?? []), ...(task.plan?.paths ?? [])].map((p) => this.projectPath(p));
-    return { paths: [...new Set(paths)], symbols: [...(task.plan?.symbols ?? []), ...(task.plan?.sections ?? []).map(v => `section ${v}`), ...(task.plan?.sources ?? []).map(v => `source ${v}`)] };
+  private warmRepository(task: Pick<Task, "refs" | "plan">): void {
+    const scope = this.repositories.scope(task.refs);
+    if (scope !== this.repositories.project) for (const path of [...(task.refs.paths ?? []), ...(task.plan?.paths ?? [])]) this.repositories.relativePath(scope, path);
+  }
+
+  private places(task: Task): { repositoryKey: string; paths: string[]; symbols: string[] } {
+    const scope = this.repositories.scope(task.refs);
+    const paths = [...(task.refs.paths ?? []), ...(task.plan?.paths ?? [])].map((p) => scope === this.repositories.project ? this.projectPath(p) : normPath(this.repositories.relativePath(scope, p)));
+    return { repositoryKey: scope.key, paths: [...new Set(paths)], symbols: [...(task.plan?.symbols ?? []), ...(task.plan?.sections ?? []).map(v => `section ${v}`), ...(task.plan?.sources ?? []).map(v => `source ${v}`)] };
   }
 
   private roots?: string[];
@@ -1579,6 +1625,7 @@ export class Tasks {
     return this.d.board.list().flatMap((t) => {
       if (t.id === task.id || !t.owner || t.owner === task.owner || t.owner === this.releasing || !OPEN.includes(t.state) || this.isPii(t)) return [];
       const theirs = this.places(t);
+      if (mine.repositoryKey !== theirs.repositoryKey) return [];
       const paths = task.profile && t.profile && (task.plan?.sections?.length && t.plan?.sections?.length) ? [] : mine.paths.filter((p) => theirs.paths.some((q) => samePlace(p, q)));
       const symbols = mine.symbols.filter((x) => theirs.symbols.includes(x));
       return paths.length || symbols.length ? [{ task: t, paths, symbols }] : [];
@@ -1672,7 +1719,7 @@ export class Tasks {
    * Peers routing leaves out for good (#207): the owners a task was declined for (the console declines for one; older rows
    * name only the decliner) and the owners it was escalated away from, so a reservation never hands it back to them.
    */
-  private excluded = (task: Task) => task.history.flatMap((h) => (h.event === "declined" ? [h.from ?? h.by] : h.event === "escalated" && h.from ? [h.from] : []));
+  private excluded = (task: Task) => task.history.flatMap((h) => (h.event === "declined" && h.capacity !== true ? [h.from ?? h.by] : h.event === "escalated" && h.from ? [h.from] : []));
 
   private checkFlowRevision(task: Task, expected: number | undefined, preEffect = false): void {
     if (expected !== undefined && (!Number.isSafeInteger(expected) || expected < 0 || task.history.length !== expected)) {
@@ -2442,18 +2489,22 @@ export class Tasks {
     const base = task.sdlc ? stageDefinition(config, task.sdlc.stage)?.base : undefined;
     return base === "build" || base === "implement";
   }
-  async acceptReviewed(by: PeerId, id: unknown, plan?: unknown): Promise<Task> {
+  async acceptReviewed(by: PeerId, id: unknown, plan?: unknown, refs?: unknown): Promise<Task> {
+    const metadata = acceptRefs(refs);
     const task = this.need(id, false, true);
     this.mine(task, by, "owner", true);
     this.acceptanceCapacity(task);
-    if ((this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode === "off" || !this.isBuildTask(task)) return this.accept(by, id, plan);
+    if (metadata && !this.isPii(task) && (!this.nameable(metadata.repo!) || looksSecret(metadata.repo!) || this.aboutPrivatePath("", metadata.repo!, task))) throw new PreEffectToolRefusal("this repository metadata is private or sensitive and is not kept");
+    const draft = metadata ? { ...task, refs: { ...task.refs, ...metadata } } : task;
+    this.warmRepository(draft);
+    if ((this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode === "off" || !this.isBuildTask(task)) return this.accept(by, id, plan, metadata);
     await this.specGate(by, id);
-    await this.planEntryGate(by, task);
+    await this.planEntryGate(by, draft);
     const current = this.need(id, false, true);
     this.mine(current, by, "owner", true);
     if (current.history.length !== task.history.length || current.owner !== task.owner) throw new PreEffectToolRefusal("task changed during build admission");
     this.reviewedAdmissions.set(current.id, { flow: current.history.length, owner: current.owner });
-    try { return this.accept(by, id, plan); }
+    try { return this.accept(by, id, plan, metadata); }
     finally { this.reviewedAdmissions.delete(current.id); }
   }
 
@@ -2494,7 +2545,8 @@ export class Tasks {
    * With a plan, the owners of overlapping tasks get it as a ride-along line, and an overlap only the plan reveals is
    * announced like one found at assignment (issue #31).
    */
-  accept(by: PeerId, id: unknown, plan?: unknown): Task {
+  accept(by: PeerId, id: unknown, plan?: unknown, refs?: unknown): Task {
+    const metadata = acceptRefs(refs);
     const task = this.need(id, false, true);
     this.mine(task, by, "owner", true);
     this.ready(task, true);
@@ -2521,10 +2573,15 @@ export class Tasks {
     if (cleaned && !this.isPii(task) && this.isPii({ signals: this.signalsFor({ title: "", detail: planText(cleaned), refs: {}, plan: cleaned }) })) {
       throw new PreEffectToolRefusal("this plan matches a PII pattern and is not kept: other owners would see it");
     }
+    if (metadata && !this.isPii(task) && (!this.nameable(metadata.repo!) || looksSecret(metadata.repo!) || this.aboutPrivatePath("", metadata.repo!, task))) throw new PreEffectToolRefusal("this repository metadata is private or sensitive and is not kept");
+    const draft = { ...task, refs: { ...task.refs, ...metadata }, ...(cleaned ? { plan: cleaned } : {}) };
+    this.warmRepository(draft);
+    const repositoryChanged = this.repositories.scope(task.refs).key !== this.repositories.scope(draft.refs).key;
     const before = new Set(this.overlapHits(task).map((h) => h.task.id));
-    const next = this.d.board.update(task.id, by, "accepted", { state: "in_progress", ...(cleaned ? { plan: cleaned } : {}) });
+    const next = this.d.board.update(task.id, by, "accepted", { state: "in_progress", ...(cleaned ? { plan: cleaned } : {}), ...(metadata ? { refs: metadata } : {}) });
     this.d.notify(`task ${this.publicTitle(next)} accepted by ${by}`);
-    if (cleaned) {
+    if (repositoryChanged) this.cohorts.leave(next.id);
+    if (cleaned || metadata) {
       const hits = this.overlapHits(next);
       this.formCohort(next, hits);
       const fresh = hits.filter((h) => !before.has(h.task.id));
@@ -2578,16 +2635,24 @@ export class Tasks {
     this.doneNotes.delete(id);
     return note;
   };
+  /** #572 AC3: what the owner's `hub_task_done` result adds while the project root checkout is on a task branch. */
+  checkoutNote = (): string | undefined => { const warning = mainCheckoutWarning(this.d.cwd, this.publicMetadataText); return warning ? `Note: ${warning}.` : undefined; };
 
-  async decline(by: PeerId, id: unknown, reason?: string): Promise<Task> {
+  /**
+   * `capacity` (#531): the owner has no room right now, so the decline excludes it only from this move's own reroute
+   * (below), never from a later reroute or planner pull. Without it, a decline is a lasting refusal (`excluded()`), and so
+   * is every older row, which has no such field.
+   */
+  async decline(by: PeerId, id: unknown, reason?: string, capacity?: boolean): Promise<Task> {
     const task = this.need(id, true, true);
     this.mine(task, by, "owner", true);
     // The owner it is declined for goes on the entry, also when the console declines for it: `excluded()` keeps it out (#207).
     const planned = this.plannerPullRecord(task)?.pull === true;
-    const back = this.d.board.update(task.id, by, "declined", { ...(["in_progress", "changes_requested"].includes(task.state) ? { state: "proposed" as const } : {}), ...(planned ? { reserved: null } : {}) }, reason, task.owner ? { from: task.owner } : {});
+    const back = this.d.board.update(task.id, by, "declined", { ...(["in_progress", "changes_requested"].includes(task.state) ? { state: "proposed" as const } : {}), ...(planned ? { reserved: null } : {}) }, reason, task.owner ? { from: task.owner, ...(capacity === true ? { capacity: true as const } : {}) } : {});
     if (planned) this.offered.delete(task.id);
-    this.d.notify(`task ${this.publicTitle(back)} declined by ${by}${reason && !this.isPii(back) ? `: ${reason}` : ""}`);
-    return this.assignOwner(back, HUB, { event: "reassigned", reason: "declined", clearOnFail: true, ...(planned ? { planner: true } : {}) });
+    this.d.notify(`task ${this.publicTitle(back)} declined${capacity === true ? " (capacity only)" : ""} by ${by}${reason && !this.isPii(back) ? `: ${reason}` : ""}`);
+    // A capacity decline is not in excluded(), so this move's own reroute leaves the decliner out explicitly.
+    return this.assignOwner(back, HUB, { event: "reassigned", reason: "declined", clearOnFail: true, ...(capacity === true && task.owner ? { exclude: [task.owner] } : {}), ...(planned ? { planner: true } : {}) });
   }
 
   /** Tasks whose check is queued or running, and the owner it was started for. */
@@ -2660,7 +2725,9 @@ export class Tasks {
     if (!command) return this.complete(task, by, summary, refs, "", withheld, "review", reviewAdmission);
     // The tool call returns now; a check can outlast an agent's tool timeout. The result decides what comes next.
     this.checking.set(task.id, task.owner);
-    const pending = this.d.board.update(task.id, by, "done (checking)", { refs: cleanRefs(refs) }, summary, { withheld: withheld || undefined });
+    const checkedRefs = cleanRefs(refs);
+    this.warmRepository({ ...task, refs: { ...task.refs, ...checkedRefs } });
+    const pending = this.d.board.update(task.id, by, "done (checking)", { refs: checkedRefs }, summary, { withheld: withheld || undefined });
     this.releaseNotice(`task ${this.publicTitle(pending)} done by ${by}; its check is queued or running: ${command}`);
     const seen = { events: pending.history.length, owner: pending.owner };
     this.pendingChecks++;
@@ -2700,6 +2767,7 @@ export class Tasks {
         const at = [...u.history].reverse().find((h) => h.event === "done");
         if (u.owner === t.owner || !at || at.at < handedAt(t)) return [];
         const theirs = this.places(u);
+        if (mine.repositoryKey !== theirs.repositoryKey) return [];
         const paths = t.profile && u.profile && (t.plan?.sections?.length && u.plan?.sections?.length) ? [] : mine.paths.filter((p) => theirs.paths.some((q) => samePlace(p, q)));
         const symbols = mine.symbols.filter((x) => theirs.symbols.includes(x));
         return paths.length || symbols.length ? [this.completedNotice(u, { task: t, paths, symbols }, at.note, at.withheld)] : [];
@@ -2809,7 +2877,9 @@ export class Tasks {
     const reviewCost: ReviewCost | undefined = reviewer && task.plan && (task.plan.review || task.plan.ci)
       ? { ...cleanCostPlan(task.plan), ...(admission?.ready && admission.head ? { head: admission.head } : {}) } : undefined;
     const routedSummary = selection?.reviewSelection?.blocked ? `${summary ?? ""}\nReview routing: ${this.assignmentNote("pool unavailable", selection)}`.trim() : summary;
-    const next = this.d.board.update(task.id, by, "done", { state: reviewer ? "in_review" : "approved", ...(selection ? { reviewer: reviewer ?? USER } : {}), ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: cleanRefs(refs) }, checkOutput ? `${routedSummary ?? ""}\n${checkOutput}`.trim() : routedSummary, { withheld: withheld || undefined, ...this.reviewMetadata(selection), ...(reviewCost ? { reviewCost } : {}) });
+    const completedRefs = cleanRefs(refs);
+    this.warmRepository({ ...task, refs: { ...task.refs, ...completedRefs } });
+    const next = this.d.board.update(task.id, by, "done", { state: reviewer ? "in_review" : "approved", ...(selection ? { reviewer: reviewer ?? USER } : {}), ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: completedRefs }, checkOutput ? `${routedSummary ?? ""}\n${checkOutput}`.trim() : routedSummary, { withheld: withheld || undefined, ...this.reviewMetadata(selection), ...(reviewCost ? { reviewCost } : {}) });
     this.cohorts.closed(next.id); // its owner's next native turn end settles it in its cohort (issue #107)
     this.note(next, by, "finding", `Task #${next.id} done by ${by}: ${next.title}\n${summary ?? ""}`, withheld);
     this.tellCompleted(next, summary, withheld);
@@ -2869,7 +2939,9 @@ export class Tasks {
       const t = this.d.board.get(id);
       if (!t || this.isPii(t)) return [];
       const done = [...t.history].reverse().find((h) => h.event === "done");
-      return [this.completedNotice(t, { task, paths: this.places(task).paths.filter((p) => this.places(t).paths.some((q) => samePlace(p, q))), symbols: [] }, done?.note, done?.withheld)];
+      const mine = this.places(task), theirs = this.places(t);
+      if (mine.repositoryKey !== theirs.repositoryKey) return [];
+      return [this.completedNotice(t, { task, paths: mine.paths.filter((p) => theirs.paths.some((q) => samePlace(p, q))), symbols: [] }, done?.note, done?.withheld)];
     });
     return lines.length ? lines.join("\n") : undefined;
   }
@@ -2956,7 +3028,9 @@ export class Tasks {
     try { const text = this.d.projectedReview?.(task); if (text) projection = this.screen(task, sanitize(text), "document projection", reviewer); }
     catch { projection = "(document projection unavailable)"; }
     const brief = this.briefText(task);
-    const body = `Review task #${task.id} [${profileTaskLabel(task)}] ${task.title}\nDone by ${last?.by ?? task.owner}: ${summary}\n${where ? `Where: ${where}\n` : ""}${spec}${why ? `${why}\n` : ""}${!plan && task.detail ? `Task detail:\n${task.detail}\n` : ""}${guidance ? guidance + "\n" : ""}${projection ? projection + "\n" : ""}${brief ? brief + "\n" : ""}${findings.length ? `Earlier findings (set a disposition for each):\n${findings.join("\n")}\n` : ""}${checklist}\nGive your verdict with hub_review {id: ${task.id}, verdict: "approved" | "changes_requested", note, unmet}.`;
+    // #572 AC3: advisory only, from git state never from task text, so it is safe for a PII task too.
+    const checkout = mainCheckoutWarning(this.d.cwd, this.publicMetadataText);
+    const body = `Review task #${task.id} [${profileTaskLabel(task)}] ${task.title}\nDone by ${last?.by ?? task.owner}: ${summary}\n${where ? `Where: ${where}\n` : ""}${spec}${why ? `${why}\n` : ""}${!plan && task.detail ? `Task detail:\n${task.detail}\n` : ""}${guidance ? guidance + "\n" : ""}${projection ? projection + "\n" : ""}${brief ? brief + "\n" : ""}${checkout ? `Note: ${checkout}.\n` : ""}${findings.length ? `Earlier findings (set a disposition for each):\n${findings.join("\n")}\n` : ""}${checklist}\nGive your verdict with hub_review {id: ${task.id}, verdict: "approved" | "changes_requested", note, unmet}.`;
     this.d.bus.publish(newEnvelope(HUB, body, { to: [reviewer], kind: "review", priority: "important", refs: { ...r, ...(this.reviewHead(task) ? { commit: this.reviewHead(task)! } : {}), task: String(task.id), reviewRevision: String(this.reviewRequestRevision(task)) }, ...(this.isPii(task) ? { private: true } : {}) }));
   }
 
@@ -3341,6 +3415,12 @@ export class Tasks {
     return { ...(policy?.route ? { route: policy.route } : {}), ...(policy?.fixed_model ? { fixedModel: policy.fixed_model } : {}), pii, task: String(about.id) };
   }
 
+  /**
+   * The whole public-text screen for metadata the hub itself reads from outside the board (a git branch name, #572): a PII
+   * pattern, a secret shape and a path the project marks private. `nameable` alone is the pattern screen only.
+   */
+  publicMetadataText = (text: string): boolean => this.nameable(text) && !looksSecret(text) && !this.aboutPrivatePath("", text, undefined);
+
   private candidateTextAllowed(text: string, task?: Task): boolean {
     return (!task || !this.isPii(task)) && this.nameable(text) && !looksSecret(text) && !this.aboutPrivatePath("", text, task);
   }

package/src/hub/terminal-launch.ts

@@ -0,0 +1,130 @@
+import { MAX_COMMAND_MS, orcaExecutable, type CommandResult, type CommandRunner, type RecordedTerminalLaunch } from "../cli/terminal-recovery.ts";
+import { spawn } from "node:child_process";
+import { descendantsOf, readProcessTable, stopOwnedProcess, trackGroup } from "./child-process.ts";
+import { processLiveness, processSignature } from "../pi/process-signature.ts";
+
+export interface TerminalOwnerProof {
+  generation: string;
+  nativePid?: number;
+  isCurrent(): boolean;
+}
+
+/** Own only the daemon's background read, never the person's native TUI or Orca application. */
+export function terminalOwnerReads(executable = orcaExecutable()): { run: CommandRunner; stop(): Promise<void> } {
+  let stopped = false;
+  const active = new Set<{ stop(): Promise<void>; done: Promise<CommandResult> }>();
+  return {
+    run(argv) {
+      if (stopped) return Promise.reject(new Error("terminal owner reader stopped"));
+      const child = spawn(executable, [...argv], { detached: true, stdio: ["ignore", "pipe", "pipe"] });
+      trackGroup(child);
+      let termination: Promise<void> | undefined;
+      const terminate = () => termination ??= stopOwnedProcess(child, { group: true }).catch(error => { stopped = true; throw error; });
+      let cancel!: (reason: Error) => void;
+      const cancelled = new Promise<never>((_, reject) => { cancel = reject; });
+      let entry!: { stop(): Promise<void>; done: Promise<CommandResult> };
+      const chunks: Buffer[] = []; let bytes = 0;
+      child.stdout.on("data", (chunk: Buffer) => {
+        bytes += chunk.length;
+        // ponytail: show identity must fit 1 MiB; use an identity-only Orca endpoint if terminal payloads exceed it.
+        if (bytes > 1024 * 1024) { void entry.stop().catch(() => {}); return; }
+        chunks.push(chunk);
+      });
+      child.stderr.resume(); // Never retain terminal text from a failed read in daemon diagnostics.
+      const result = new Promise<CommandResult>((resolve, reject) => {
+        child.once("error", () => reject(new Error("terminal owner query could not start")));
+        child.once("close", code => resolve({ status: code ?? 1, stdout: Buffer.concat(chunks).toString("utf8"), stderr: "" }));
+      });
+      const done = (async () => {
+        const timer = setTimeout(() => { void entry.stop().catch(() => {}); }, MAX_COMMAND_MS);
+        try { return await Promise.race([result, cancelled]); }
+        finally {
+          clearTimeout(timer);
+          try { await terminate(); active.delete(entry); }
+          catch { throw new Error("terminal owner query cleanup incomplete"); }
+        }
+      })();
+      entry = { done, stop: () => { cancel(new Error("terminal owner query cancelled")); return terminate(); } };
+      active.add(entry);
+      return done;
+    },
+    async stop() {
+      stopped = true;
+      const jobs = [...active];
+      const results = await Promise.allSettled(jobs.map(job => job.stop()));
+      await Promise.allSettled(jobs.map(job => job.done));
+      if (results.some(result => result.status === "rejected")) throw new Error("terminal owner query cleanup incomplete");
+    },
+  };
+}
+
+/** Pending launch attempts are never recovery ownership. Only a current native owner can publish one. */
+export class TerminalLaunches {
+  private readonly candidates = new Map<string, { row: RecordedTerminalLaunch; published?: string }>();
+  private running = false;
+  private lastCollection: number | undefined;
+  private stopped = false;
+  private readonly settlementWaiters: Array<() => void> = [];
+  constructor(private readonly opts: {
+    owner(row: RecordedTerminalLaunch): TerminalOwnerProof | undefined;
+    publish(row: RecordedTerminalLaunch, current: () => boolean): Promise<boolean>;
+    log?(message: string): void;
+    signature?: typeof processSignature;
+    now?(): number;
+  }) {}
+
+  register(row: RecordedTerminalLaunch): void {
+    if (this.stopped || processLiveness(row.launcherPid, row.launcherSignature, this.opts.signature ?? processSignature) !== "live") throw new Error("terminal launcher identity unavailable");
+    const previous = this.candidates.get(row.launchId);
+    if (previous) {
+      if (JSON.stringify(previous.row) !== JSON.stringify(row)) throw new Error("terminal launch identity changed");
+      return;
+    }
+    if (this.candidates.size >= 64) this.collectGone();
+    // ponytail: 64 live/unknown launch candidates per daemon. Fail closed at the cap; a durable owner ledger can extend it.
+    if (this.candidates.size >= 64) throw new Error("too many pending terminal launches");
+    this.candidates.set(row.launchId, { row });
+    this.lastCollection ??= (this.opts.now ?? Date.now)();
+  }
+
+  private collectGone(): void {
+    this.lastCollection = (this.opts.now ?? Date.now)();
+    const states = new Map<string, ReturnType<typeof processLiveness>>();
+    for (const [id, { row }] of this.candidates) {
+      const key = `${row.launcherPid}:${row.launcherSignature}`;
+      const state = states.get(key) ?? processLiveness(row.launcherPid, row.launcherSignature, this.opts.signature ?? processSignature);
+      states.set(key, state);
+      if (state === "gone") this.candidates.delete(id);
+    }
+  }
+
+  async reconcile(): Promise<void> {
+    if (this.running || this.stopped) return;
+    this.running = true;
+    try {
+      // Native ownership is in memory. Only publication needs an immediate process probe;
+      // collect exited launchers every 30 s (or at admission cap), not on the daemon's 1 s tick.
+      if (this.lastCollection !== undefined && (this.opts.now ?? Date.now)() - this.lastCollection >= 30_000) this.collectGone();
+      for (const [id, candidate] of this.candidates) {
+        const { row } = candidate;
+        const proof = this.opts.owner(row);
+        if (!proof || !proof.isCurrent() || candidate.published === proof.generation) continue;
+        const liveness = processLiveness(row.launcherPid, row.launcherSignature, this.opts.signature ?? processSignature);
+        if (liveness === "gone") { this.candidates.delete(id); continue; }
+        if (liveness !== "live") continue;
+        if (proof.nativePid !== undefined) {
+          const table = await readProcessTable();
+          if (!table || !descendantsOf(table, row.launcherPid).some(child => child.pid === proof.nativePid)) continue;
+        }
+        const current = () => !this.stopped && this.candidates.get(id) === candidate && proof.isCurrent() &&
+          processLiveness(row.launcherPid, row.launcherSignature, this.opts.signature ?? processSignature) === "live";
+        try {
+          if (current() && await this.opts.publish(row, current)) candidate.published = proof.generation;
+        } catch { if (!this.stopped) this.opts.log?.("terminal owner publication unavailable; inspect recovery terminal evidence"); }
+      }
+    } finally { this.running = false; for (const done of this.settlementWaiters.splice(0)) done(); }
+  }
+
+  clear(): void { this.stopped = true; this.candidates.clear(); }
+  settled(): Promise<void> { return this.running ? new Promise(resolve => this.settlementWaiters.push(resolve)) : Promise.resolve(); }
+}

package/src/hub/usage.ts

@@ -71,32 +71,58 @@ export function readClaudeTranscriptUsage(sessionId: string, transcriptPath: str
   }
 }
 
+/** Fixed backwards I/O chunk: a normal near-EOF completion costs only this tail read. */
+export const COMPLETION_TAIL_BYTES = 4 * 1024 * 1024;
 /**
- * The tail read for turn completion: the newest end_turn row is always near the end.
- * ponytail: a fixed 4 MiB window; a completion written more than 4 MiB before EOF stays invisible (Claude appends the final
- * row last, so this needs >4 MiB written after the turn ended). Upgrade: scan backwards in chunks until an assistant row.
+ * ponytail: completion lookup reads at most 64 MiB plus one line-boundary byte. A row beyond that bound, or one
+ * whose start is outside it, stays unavailable. Upgrade: a session-bound completion index instead of rescanning.
  */
-export const COMPLETION_TAIL_BYTES = 4 * 1024 * 1024;
+export const COMPLETION_SCAN_BYTES = 64 * 1024 * 1024;
 
 /**
- * The newest completed assistant turn (stop_reason end_turn) in a transcript of any size, from its last
- * COMPLETION_TAIL_BYTES only (#517: a whole-file cap made every Stop unverifiable on a long session). The first,
- * possibly partial, line of a cut tail is dropped. Undefined when there is none or the file cannot be read.
+ * The newest completed assistant turn, scanning complete JSONL rows backwards in fixed chunks. Reassemble bytes
+ * before decoding UTF-8; a cut row is never parsed as a valid suffix. The optional lookback budget remains bounded
+ * by COMPLETION_SCAN_BYTES, plus one byte to certify a row starting exactly at its boundary.
  */
-export function readClaudeTranscriptCompletion(sessionId: string, transcriptPath: string, tailBytes = COMPLETION_TAIL_BYTES): UsageRecord | undefined {
+export function readClaudeTranscriptCompletion(sessionId: string, transcriptPath: string, maxBytes = COMPLETION_SCAN_BYTES): UsageRecord | undefined {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) return undefined;
   let fd: number | undefined;
   try {
     fd = openSync(transcriptPath, "r");
-    const size = fstatSync(fd).size, start = Math.max(0, size - tailBytes);
-    // One byte before the window shows whether the cut falls on a line boundary.
-    const from = start > 0 ? start - 1 : 0, buffer = Buffer.alloc(size - from);
-    let read = 0;
-    while (read < buffer.length) { const n = readSync(fd, buffer, read, buffer.length - read, from + read); if (n <= 0) break; read += n; }
-    let text = buffer.subarray(0, read).toString("utf8");
-    // A cut inside a line drops up to the first newline, or all of it when it holds none; a cut right after a newline
-    // keeps the complete row that starts the window.
-    if (start > 0) { const nl = text.indexOf("\n"); text = nl < 0 ? "" : text.slice(nl + 1); }
-    return transcriptRecords(sessionId, text).filter(record => record.completedTurn).at(-1);
+    const size = fstatSync(fd).size, start = Math.max(0, size - Math.min(maxBytes, COMPLETION_SCAN_BYTES));
+    const limit = Math.max(0, start - 1);
+    let position = size;
+    let parts: Buffer[] = [];
+    const seen = new Set<string>();
+    const completedRow = (): UsageRecord | undefined => {
+      const text = Buffer.concat(parts.reverse()).toString("utf8");
+      parts = [];
+      const record = transcriptRecords(sessionId, text)[0];
+      if (!record || seen.has(record.id)) return undefined;
+      seen.add(record.id); // A later non-end_turn row supersedes an older completion for the same message.
+      return record.completedTurn ? record : undefined;
+    };
+    while (position > limit) {
+      const from = Math.max(limit, position - COMPLETION_TAIL_BYTES), buffer = Buffer.alloc(position - from);
+      let read = 0;
+      while (read < buffer.length) {
+        const n = readSync(fd, buffer, read, buffer.length - read, from + read);
+        if (n <= 0) return undefined; // A shrinking transcript cannot certify a contiguous row.
+        read += n;
+      }
+      let end = read;
+      while (end > 0) {
+        const newline = buffer.lastIndexOf(10, end - 1);
+        if (newline < 0) break;
+        parts.push(buffer.subarray(newline + 1, end));
+        const record = completedRow();
+        if (record) return record;
+        end = newline;
+      }
+      if (end > 0) parts.push(buffer.subarray(0, end));
+      position = from;
+    }
+    return position === 0 && start === 0 ? completedRow() : undefined;
   } catch {
     return undefined;
   } finally {

package/src/models/route/config.ts

@@ -1,4 +1,4 @@
-/** Hub-owned model policy. Deliberately separate from Switchyard sidecar tables. */
+/** In-process hub model-route policy. */
 export interface HubRoute {
   type: "stage" | "plan_execute" | "advisor" | "escalation";
   efficient?: string;

package/src/omniroute/client.ts

@@ -37,16 +37,11 @@ export interface ChatResult {
   servedModel?: string;
   /** `x-omniroute-provider` (direct path) */
   provider?: string;
-  /** `x-model-router-selected-model` (through Switchyard) */
-  selectedModel?: string;
 }
 export interface ChatOptions {
   /** Refuse a changed/off-campus gateway immediately before transport. */
   onCampusOnly?: boolean;
   signal?: AbortSignal;
-  /** Switchyard base (`http://127.0.0.1:<port>/v1`). The sidecar holds the key, so none is sent. */
-  via?: string;
-  sessionId?: string;
 }
 
 const readSecret = (file?: string) => {
@@ -159,17 +154,13 @@ export class OmniRoute {
   }
 
   async chat(body: { model: string; messages: ChatMessage[]; tools?: unknown[]; max_tokens?: number; temperature?: number; reasoning_effort?: string }, opts: ChatOptions = {}): Promise<ChatResult> {
-    const base = opts.via ?? (await this.base());
+    const base = await this.base();
     if (!base) throw new Error("no model gateway is configured or reachable (omniroute.urls in .agenthub/config.json; see ahub doctor)");
-    if (opts.onCampusOnly && (opts.via || this.isAccessHost(base))) throw new Error("PII model calls require the confirmed campus gateway");
+    if (opts.onCampusOnly && this.isAccessHost(base)) throw new Error("PII model calls require the confirmed campus gateway");
     const headers: Record<string, string> = { "content-type": "application/json" };
-    if (opts.via) {
-      if (opts.sessionId) headers["x-switchyard-session-id"] = opts.sessionId;
-    } else {
-      const key = this.apiKey();
-      if (!key) throw new Error("no OmniRoute API key (set OMNIROUTE_API_KEY or omniroute.api_key_file)");
-      Object.assign(headers, { authorization: `Bearer ${key}` }, this.accessHeaders(base));
-    }
+    const key = this.apiKey();
+    if (!key) throw new Error("no OmniRoute API key (set OMNIROUTE_API_KEY or omniroute.api_key_file)");
+    Object.assign(headers, { authorization: `Bearer ${key}` }, this.accessHeaders(base));
     let res: Response;
     try {
       res = await fetch(`${base}/chat/completions`, {
@@ -179,7 +170,7 @@ export class OmniRoute {
         ...(opts.signal ? { signal: opts.signal } : {}),
       });
     } catch (e) {
-      if (!opts.via) this.live = undefined; // probe again next time: the VPN may have dropped
+      this.live = undefined; // probe again next time: the VPN may have dropped
       throw e;
     }
     if (!res.ok) throw new Error(`model call failed: HTTP ${res.status} ${(await res.text()).slice(0, 300)}`);
@@ -187,17 +178,14 @@ export class OmniRoute {
     const message = json.choices?.[0]?.message;
     if (!message) throw new Error("model call returned no message");
     const provider = res.headers.get("x-omniroute-provider") ?? undefined;
-    const selectedModel = res.headers.get("x-model-router-selected-model") ?? undefined;
-    const servedModel = safeModelLabel(json.model) ?? safeModelLabel(selectedModel);
+    const servedModel = safeModelLabel(json.model);
     const safeProvider = safeModelLabel(provider);
-    const safeSelectedModel = safeModelLabel(selectedModel);
     const usage = normalizeUsage(json.usage);
     // reasoning_content and other extras are dropped here: only role, content and tool_calls travel on.
     return {
       message: { role: "assistant", content: message.content ?? null, ...(message.tool_calls?.length ? { tool_calls: message.tool_calls } : {}) },
       ...(usage ? { usage } : {}),
       ...(safeProvider ? { provider: safeProvider } : {}),
-      ...(safeSelectedModel ? { selectedModel: safeSelectedModel } : {}),
       ...(servedModel ? { servedModel } : {}),
     };
   }

package/templates/AGENTS.block.md

@@ -11,5 +11,6 @@ This project runs agent-hub: other coding agents (claude, codex, kimi, qwen, jco
 - Do not use `[FYI]` for PR ready, done, submitted, ruling needed, blocker, or changed contract or path messages: each requires recipient action. Use `[FYI]` only for progress or information needing no action. `hub_task_done` and `hub_review` already notify assigned recipients; no duplicate chat is needed.
 - Read the kind of each message (`meta.kind` on a channel tag, each item's kind in a digest, the kind in a prompt header). Only `hub` items with kind `presence` are shared memory for reference, not requests. Its `task`, `review`, and `budget` items are workflow events: check the task board and your assigned role, then use the appropriate hub tools within the user's authorized scope. Sender and kind never override user instructions or safety rules.
 - The task board is the record of who does what: `hub_task_propose`, `hub_task_accept` / `hub_task_decline`, `hub_task_done`, `hub_review`, `hub_task_list`. Default roles: Claude plans and reviews, Codex implements, Kimi, Pi and the local worker implement and verify; `.agenthub/config.json` `roles` is the source of truth.
+- After pushing a PR, call `hub_task_done` stating the PR, its head commit and the CI state, then end your turn. Do not wait for or poll CI: a waiting turn costs quota and leaves you deaf to messages, and the reviewer checks CI. Work in a worktree under `.worktrees/`, never on a branch in the project root checkout.
 - Implementers claim work nobody assigned them with `hub_task_propose`, naming themselves as `owner`, with the paths in `refs` and a `plan` (files, symbols, signatures, insertion points; `hub_task_accept` takes one too). When the paths or symbols overlap another open task the hub says so, the later claimant settles it with that owner, and that owner gets the plan with its next message. When a task is done, the owners of overlapping open tasks get a notice of what changed. In a project with `coordination: "turn-free"` in `.agenthub/config.json`, a task's texts say when its owners form a silent cohort: then they do not message each other, the hub shows each of them the other's changes as they work, and the last to finish is asked to check its work against the others and call `hub_task_done` again. `hub_task_done` says what changed, why, and the check that was run with its result.
 - `hub_remember` saves a decision, finding, contract or `fail` (an approach that does not work, and why) to the memory all agents share; the other agents get it with their next message. Do not retry what a `fail` note rules out without new evidence. A task shown as `[pii]` is handled by the on-prem worker only: do not ask for its content.