@staix/agent-hub 0.13.0 → 0.14.0

package/src/hub/tasks.ts

@@ -4,7 +4,8 @@ import { publicTestIntegrity, readTestIntegrity, testIntegrityBlockers, type Tes
 import { completePlanInventory, planConformance, planConformanceBlockers, planFingerprint, type PlanConformance } from "./plan-conformance.ts";
 import { RELEASE_TRAIN_HISTORY_LIMIT, releaseTrainData, releaseTrainReadiness, releaseMetrics } from "./sdlc-release.ts";
 import { cleanCostPlan, costMetrics, type CostPlan, type ReviewCost } from "./cost-governance.ts";
-import { specRefs } from "./spec-read.ts";
+import { qualifiedTitleRepos, siblingTitleRefs, specRefs } from "./spec-read.ts";
+import { sdlcMetrics, type BandResult, type MetricTask, type MetricsReport } from "./sdlc-metrics.ts";
 import type { InstancesConfig } from "./instances.ts";
 import { composeRememberText } from "./memory-fail.ts";
 import { VERSION } from "../version.ts";
@@ -892,11 +893,11 @@ export class Tasks {
     }
     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 {
+  private plannerAssignment(task: Task, reservedOnly = false, routing: Routing = this.d.routing()): Assignment {
     const states = this.states();
     const full = this.plannerFull(task);
     // Preview the To Do transition without routing or offering the persisted backlog row.
-    return assign({ ...task, state: "proposed" }, states, this.d.routing(), { exclude: this.excluded(task), excludeOwners: full, ...(reservedOnly && task.reserved && !this.excluded(task).includes(task.reserved) ? { candidates: [task.reserved], namedOwner: task.reserved } : {}), waitsFor: this.waitsFor(task), ...this.weights(task.class, task) });
+    return assign({ ...task, state: "proposed" }, states, routing, { exclude: this.excluded(task), excludeOwners: full, ...(reservedOnly && task.reserved ? { candidates: [task.reserved], namedOwner: task.reserved } : {}), waitsFor: this.waitsFor(task), ...this.weights(task.class, task) });
   }
 
   async pullPlanned(by: PeerId, input: { id: number; revision: number; reason: string }): Promise<Task> {
@@ -921,14 +922,25 @@ export class Tasks {
           return !!competing && (competing.rank < order.rank || competing.rank === order.rank && competing.id < order.id);
         })) throw new PreEffectToolRefusal("a person's P0 backlog order is retained");
       }
-      const assignment = this.plannerAssignment(task);
-      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");
+      if (task.reserved && this.excluded(task).includes(task.reserved)) throw new PreEffectToolRefusal(this.plannerRefusal(task));
+      const assignment = this.plannerAssignment(task, !!task.reserved);
+      if (!assignment.owner) {
+        const refusal = task.reserved ? `reserved peer ${task.reserved} cannot take the planner pull: ${assignment.refusals?.find(row => row.role === "owner" && row.peer === task.reserved)?.reason ?? "not eligible"}; ${this.plannerRefusal(task)}` : this.plannerRefusal(task);
+        throw new PreEffectToolRefusal(`${this.hasPersonReservation(task) ? "a person's reservation is retained; " : ""}${refusal}`);
+      }
       return { task, owner: assignment.owner };
     };
     const initial = validate(), withheld = await this.withholds("note", input.reason, initial.task);
     authorized();
     const current = validate();
+    if (current.task.reserved) {
+      return this.assignOwner(current.task, by, { candidates: [current.owner], namedOwner: current.owner, planner: true, refuseNamed: "pre",
+        plannerPull: { revision: input.revision, note: input.reason.trim(), withheld, guard: () => {
+          authorized();
+          const checked = validate();
+          if (checked.task.history.length !== current.task.history.length || checked.owner !== current.owner) throw new PreEffectToolRefusal("planner pull changed during admission");
+        } } });
+    }
     const pulled = this.d.board.pullPlanned(current.task.id, by, current.owner, input.revision, input.reason.trim(), withheld);
     this.planningRecorded({ by, task: pulled.id, fields: ["pull", "reserved"], revision: pulled.planningRevision! });
     return pulled;
@@ -1443,6 +1455,7 @@ export class Tasks {
     if (this.d.coordination) this.coordinationModes.set(task.id, this.d.coordination());
     created?.();
     if (screening) task = this.screenedTask(task, screened);
+    task = this.linkOnWrite(task); // #723
     if (goal) this.linkNative(task, goal, by);
     if (triaged) task = this.d.board.update(task.id, "hub", "triaged", {}, `class ${cls} named by the hub's model`);
     if (defaulted) task = this.d.board.update(task.id, "hub", "class defaulted", {}, "class implement for a claim without one");
@@ -1855,7 +1868,9 @@ export class Tasks {
       const task = this.d.board.get(target);
       if (!task) throw new Error(`no task #${target}`);
       if (isClosedTaskState(task.state)) return [...workflow, `task ${this.publicTitle(task)} (${task.state}): closed; not routed`];
-      const a = assign(task, this.states(), routing, { exclude: this.excluded(task), excludeOwners: this.plannerPullRecord(task)?.pull ? this.plannerFull(task) : [], waitsFor: this.waitsFor(task), ...this.weights(task.class, task) });
+      const planned = task.state === "backlog" && !!task.reserved || this.plannerPullRecord(task)?.pull === true;
+      const a = planned ? this.plannerAssignment(task, true, routing)
+        : assign(task, this.states(), routing, { exclude: this.excluded(task), waitsFor: this.waitsFor(task), ...this.weights(task.class, task) });
       // The split trace is for the pair the record is about: the task's owner when it has one (issue #109).
       return [...workflow, `task ${this.publicTitle(task)} (${task.state}, owner ${task.owner ?? "none"}${task.reserved ? `, reserved for ${task.reserved}` : ""})`, ...(task.profileClass ? [`profile class ${profileTaskLabel(task)}`] : []), ...(task.role ? [`task role ${task.role} (guidance only)`] : []), "if it were assigned now:", ...a.trace, ...(this.splitShadow(task, task.owner ?? a.owner)?.trace ?? [])];
     }
@@ -1943,14 +1958,17 @@ export class Tasks {
   }
 
   /** `override`: a person's explicit assign, which past refusals do not block and which drops an agent's reservation (#207). */
-  private async assignOwner(task: Task, by: PeerId, opts: { candidates?: PeerId[]; namedOwner?: PeerId; event?: string; note?: string; reason?: TaskMoveReason; clearOnFail?: boolean; exclude?: PeerId[]; context?: string; contextWithheld?: boolean; claim?: boolean; override?: boolean; roster?: boolean; planner?: boolean; expectedFlowRevision?: number; refuseNamed?: "pre" | "plain" } = {}): Promise<Task> {
-    if (task.state === "backlog") throw new PreEffectToolRefusal(`task #${task.id}: pull backlog work before assigning it`);
+  private async assignOwner(task: Task, by: PeerId, opts: { candidates?: PeerId[]; namedOwner?: PeerId; event?: string; note?: string; reason?: TaskMoveReason; clearOnFail?: boolean; exclude?: PeerId[]; context?: string; contextWithheld?: boolean; claim?: boolean; override?: boolean; roster?: boolean; planner?: boolean; expectedFlowRevision?: number; refuseNamed?: "pre" | "plain"; plannerPull?: { revision: number; note: string; withheld: boolean; guard: () => void } } = {}): Promise<Task> {
+    if (task.state === "backlog" && !opts.plannerPull) throw new PreEffectToolRefusal(`task #${task.id}: pull backlog work before assigning it`);
     const mode = (this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode;
     let stagedClaimGap: string | undefined;
     if (mode !== "off" && this.isBuildTask(task)) {
       const gap = task.sdlc?.planReview ? await this.planReviewGap(task) : "plan not reviewed since proposal";
       const current = this.d.board.get(task.id);
-      if (!current || !this.ownerAssignmentCurrent(task, current)) return current ?? task;
+      if (!current || !this.ownerAssignmentCurrent(task, current)) {
+        if (opts.plannerPull) throw new PreEffectToolRefusal("planner pull changed during admission");
+        return current ?? task;
+      }
       task = current; // Reviewer-only and quiet bookkeeping updates do not supersede ownership authority.
       if (gap) {
         this.releaseNotice(`task ${this.publicTitle(current)}: ${gap}; planner: call hub_planner_groom then hub_plan_review`);
@@ -1967,9 +1985,10 @@ export class Tasks {
     const waits = this.waitsFor(task);
     const plannedMove = opts.planner || this.plannerPullRecord(task)?.pull === true && (by === HUB || opts.roster) && (opts.reason !== "manual" || opts.roster);
     const plannerFull = plannedMove ? this.plannerFull(task) : [];
-    const a = assign(task, this.states(), this.d.routing(), { exclude: [...(opts.override ? [] : this.excluded(task)), ...(opts.exclude ?? []), ...(opts.event === "escalated" && task.owner ? [task.owner] : [])], excludeOwners: plannerFull, ...(opts.candidates ? { candidates: opts.candidates } : {}), waitsFor: waits, ...this.weights(task.class, task), ...(opts.namedOwner ? { namedOwner: opts.namedOwner } : {}) });
+    const a = assign(opts.plannerPull ? { ...task, state: "proposed" } : task, this.states(), this.d.routing(), { exclude: [...(opts.override ? [] : this.excluded(task)), ...(opts.exclude ?? []), ...(opts.event === "escalated" && task.owner ? [task.owner] : [])], excludeOwners: plannerFull, ...(opts.candidates ? { candidates: opts.candidates } : {}), waitsFor: waits, ...this.weights(task.class, task), ...(opts.namedOwner ? { namedOwner: opts.namedOwner } : {}) });
 
     if (waits.length) {
+      if (opts.plannerPull) throw new PreEffectToolRefusal("planner pull waits for dependency approval");
       this.releaseNotice(`task ${this.publicTitle(task)} waits for ${waits.map((id) => `#${id}`).join(", ")}; it is offered once they are approved`);
       return task;
     }
@@ -1995,7 +2014,13 @@ export class Tasks {
     // A person's explicit assign replaces an agent's reservation (#207). Only a refusal keeps the owner it moves away from
     // out for good: a reviewer's rejections or an escalation by hand, never the hub's own move after a failed delivery.
     const lasting = opts.event === "escalated" && task.owner && (opts.reason === "rejections" || opts.reason === "manual");
-    const next = this.d.board.update(task.id, by, opts.event ?? "assigned", { owner: a.owner, reviewer: a.reviewer ?? null, ...(opts.roster && task.state === "in_progress" ? { state: "proposed" as const } : {}), ...(opts.event === "escalated" ? { rejections: 0 } : {}), ...(opts.override && task.reserved ? { reserved: null } : {}) }, this.assignmentNote(`${opts.note ?? `to ${a.owner}`}${passed}`, a), { ...this.reviewMetadata(a), ...(profile ? { profile } : {}), ...(opts.reason ? { reason: opts.reason } : {}), ...(lasting ? { from: task.owner! } : {}) }, opts.expectedFlowRevision);
+    opts.plannerPull?.guard();
+    const assignmentNote = this.assignmentNote(`${opts.note ?? `to ${a.owner}`}${passed}`, a);
+    const assignmentExtra = { ...this.reviewMetadata(a), ...(profile ? { profile } : {}), ...(opts.reason ? { reason: opts.reason } : {}), ...(lasting ? { from: task.owner! } : {}) };
+    const next = opts.plannerPull
+      ? this.d.board.pullAssigned(task.id, by, a.owner, opts.plannerPull.revision, opts.plannerPull.note, opts.plannerPull.withheld, a.reviewer ?? null, assignmentNote, assignmentExtra, task.history.length)
+      : this.d.board.update(task.id, by, opts.event ?? "assigned", { owner: a.owner, reviewer: a.reviewer ?? null, ...(opts.roster && task.state === "in_progress" ? { state: "proposed" as const } : {}), ...(opts.event === "escalated" ? { rejections: 0 } : {}), ...(opts.override && task.reserved ? { reserved: null } : {}) }, assignmentNote, assignmentExtra, opts.expectedFlowRevision);
+    if (opts.plannerPull) this.planningRecorded({ by, task: next.id, fields: ["pull", "reserved"], revision: next.planningRevision! });
     // What calibration reads (issue #109): routing chose the first owner (no single named candidate, no claim; not an
     // escalation, relay or reassignment of work already begun), and the work overlaps another owner's task not started
     // yet. For the record only. Work routed back to its proposer is left out, as its observations are (by === owner).
@@ -2009,6 +2034,11 @@ export class Tasks {
     // The cohort record formed just below reads it, and so does `route explain` while that turn lasts.
     if (opts.claim && a.owner === by && this.d.bus.peers.get(by)?.state === "busy") this.sent.set(handOver(next, by), by);
     try {
+      if (opts.plannerPull && task.offer) {
+        const prior = { ...task, owner: task.offer.owner };
+        this.withdrawRoleRequest(prior, next, "owner");
+        this.releaseNotice(`task #${next.id}: stale offer withdrawal failed`, () => this.d.bus.withdraw(task.offer!.envelopeId));
+      }
       if (by === USER && opts.event === "reassigned") this.withdrawRoleRequest(task, next, "owner");
       const hits = this.overlapHits(next);
       this.formCohort(next, hits);
@@ -2379,6 +2409,25 @@ export class Tasks {
     if (by !== USER && task[role] !== by) throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id}: only its ${role} (${task[role] ?? "none"}) or the console user can do that`);
   }
 
+  /**
+   * #723: link the issue a task names the moment it is proposed or accepted, in advise and enforce, so the lifecycle never
+   * waits for a groom. It is a local parse with no GitHub read, and it never refuses or fails the write it follows.
+   */
+  private linkOnWrite(task: Task): Task {
+    try { return (this.d.sdlc?.config().mode ?? "off") === "off" ? task : this.linkIssue(task); }
+    catch { return task; }
+  }
+
+  /**
+   * #723: a title that qualifies another repository (`agent-mem#13`, `owner/repo#N`) while `refs.repo` is absent cannot link
+   * (the identity needs the repository), so the proposer is told to set it. Advice only; a PII task gets none.
+   */
+  refsRepoHint(task: Task): string | undefined {
+    if (this.isPii(task) || task.refs.repo || task.sdlc?.issue || (this.d.sdlc?.config().mode ?? "off") === "off") return undefined;
+    const names = qualifiedTitleRepos(task.title);
+    return names.length ? `task #${task.id}: the title names ${names.join(", ")}; set refs.repo to that repository (owner/name) so its issue links and the lifecycle shows it` : undefined;
+  }
+
   /** #694: write the one issue the task itself names (the plan-review source) into its lifecycle receipt, once; never relinks. */
   private linkIssue(task: Task): Task {
     if (this.isPii(task) || task.sdlc?.issue) return task;
@@ -2428,12 +2477,16 @@ export class Tasks {
     let issues: number[];
     try { issues = specRefs(task, repository); }
     catch { throw new PreEffectToolRefusal("plan review issue identity unavailable"); }
+    // #723: a title that qualifies the sibling repository `refs.repo` names (`agent-mem#13`) is a local parse, never a read.
+    // A sibling shorthand next to a bare #N is two identities, refused below, never the bare one alone.
+    issues = [...new Set([...issues, ...siblingTitleRefs(task.title, task.refs.repo)])];
     if (issues.length > 1) throw new PreEffectToolRefusal("plan review needs one explicit issue identity");
     return issues[0] ? { repo: repository, issue: issues[0] } : undefined;
   }
 
   async groomingDigest(by: PeerId): Promise<Record<string, unknown>> {
     this.planningAuthority(by);
+    this.backfillIssueLinks(by); // #723: first, bounded, before the slow reads
     const included = (task: Task) => !isClosedTaskState(task.state) || task.state === "cancelled" && task.history.some(entry => !!entry.supersededBy);
     const snapshot = this.d.board.list().filter(included), issues = new Map<string, PlanIssueMetadata>(), attempted = new Set<string>();
     const deadline = performance.now() + 4_000;
@@ -2473,17 +2526,114 @@ export class Tasks {
     const digest = plannerGrooming(visible, { repository: this.d.repository ?? `path:${realPath(this.d.cwd)}`,
       limits: Object.fromEntries(peers.map(peer => [peer, this.wipLimit(peer)])), wip: Object.fromEntries(peers.map(peer => [peer, this.wip(peer)])),
       states, issues, reviewedIssues, acceptedIssues, blockers });
-    // #694: backfill lifecycle issue links after every authority check, with their own bound (not the metadata-read
-    // budget): each call links up to 32 open tasks that still lack one, so later tasks are reached on later calls.
-    if ((this.d.sdlc?.config().mode ?? "off") !== "off") {
-      let linked = 0;
-      for (const task of this.d.board.list()) {
-        if (linked >= 32) break;
-        if (isClosedTaskState(task.state) || task.sdlc?.issue || this.isPii(task)) continue;
-        if (this.linkIssue(task) !== task) linked++;
+    return { ...digest, truncated: digest.truncated || incomplete, ...(current.some(task => this.isPii(task)) ? { privateTasks: "withheld" } : {}) };
+  }
+
+  /**
+   * #694, #723: backfill lifecycle issue links with their own bounds, run first and apart from the slow metadata reads and
+   * the digest, so a groom that later times out has still linked. Each call links up to 32 open tasks that still lack one
+   * within a one-second budget, so later tasks are reached on later calls. A local parse; a failure skips that task only.
+   */
+  private backfillCursor = 0;
+  private backfillIssueLinks(by: PeerId): number {
+    if ((this.d.sdlc?.config().mode ?? "off") === "off") return 0;
+    // ponytail: 32 links and 1 s per call; raise both only with a measured groom time on a 400-task board.
+    const deadline = performance.now() + 1_000;
+    let linked = 0, i = 0;
+    const list = this.d.board.list(), n = list.length;
+    // The scan resumes where the last call stopped, so rows that never link cannot hold later ones back.
+    for (; i < n; i++) {
+      if (linked >= 32 || performance.now() >= deadline) break;
+      const task = list[(this.backfillCursor + i) % n]!;
+      if (isClosedTaskState(task.state) || task.sdlc?.issue || this.isPii(task)) continue;
+      this.planningAuthority(by);
+      try { if (this.linkIssue(task) !== task) linked++; } catch { /* one task never stops the rest */ }
+    }
+    this.backfillCursor = n ? (this.backfillCursor + i) % n : 0;
+    return linked;
+  }
+
+  /**
+   * #481 S7: the SDLC metrics from board history, read-only. Private tasks are counted as withheld and read for nothing else; PR
+   * readbacks are not made here (the cost report owns them), so merge time and same-head reruns read `unknown` unless given.
+   * Detection never calls a model and the report writes nothing.
+   */
+  sdlcMetrics(by: PeerId, since?: unknown, merged?: { mergedAt?: Record<number, number>; ciReruns?: Record<number, number | null> }): MetricsReport {
+    this.planningAuthority(by);
+    if (by !== USER && this.d.privateTurn?.(by)) throw new PreEffectToolRefusal("metrics unavailable during private work");
+    let cutoff: number | undefined;
+    if (since !== undefined && since !== null && since !== "") {
+      cutoff = typeof since === "number" ? since : /^\d+$/.test(String(since)) ? Number(since) : Date.parse(String(since));
+      if (!Number.isFinite(cutoff) || cutoff < 0) throw new PreEffectToolRefusal("since must be a time (YYYY-MM-DD or an ISO timestamp) or milliseconds");
+    }
+    const rows = this.d.board.list();
+    const tasks: MetricTask[] = rows.map(task => ({ id: task.id, private: this.isPii(task), history: task.history.map(entry => ({ at: entry.at, event: entry.event,
+      ...(entry.reviewCost?.head ? { requestHead: entry.reviewCost.head } : {}), ...(entry.reviewFindings?.head ? { verdictHead: entry.reviewFindings.head } : {}) })) }));
+    const visibleIds = new Set(rows.filter(task => !this.isPii(task)).map(task => task.id));
+    const byKind: Record<string, number> = {};
+    for (const stall of this.stalled()) if (visibleIds.has(stall.task)) byKind[stall.cause.kind] = (byKind[stall.cause.kind] ?? 0) + 1;
+    const stalls = { open: Object.values(byKind).reduce((sum, n) => sum + n, 0), byKind, doneWithoutWrites: rows.filter(task => visibleIds.has(task.id) && task.history.findLast(entry => entry.event === "done")?.noWrites).length };
+    return sdlcMetrics(tasks, { ...(cutoff !== undefined ? { since: cutoff } : {}), ...(this.d.sdlc?.config().bands ? { bands: this.d.sdlc.config().bands } : {}), stalls, ...(merged ?? {}) });
+  }
+
+  /**
+   * #481 S7: act on the band tiers, deterministically and once per breach episode. An episode is a run of non-ok values for one metric
+   * (`BandResult.episode`, derived from history), so a sustained shift is one episode however many tasks finish inside it. `log` is one
+   * hub notice, `diagnose` one read-only `triage` backlog task and `propose` one `plan` backlog card naming the metric and its evidence.
+   * A metric with an open band card (a backlog or open task whose detail carries its key) writes nothing more, so a value that grows
+   * from diagnose to propose inside one episode does not add a second card. Held while the hub is stopping, recovering or has a
+   * storage error, like every host writer. The text is fixed words, numbers and task ids, never task text, and no GitHub issue is
+   * created. Returns the task ids created.
+   */
+  /**
+   * Whether `proposeFromBands` would run now, and a signature of what it would read. The daemon timer records a board revision only for a
+   * pass that ran, and re-runs when the signature changes (a reload that enables bands or edits them on an idle board).
+   */
+  bandsState(): { ready: boolean; signature: string } {
+    const config = this.d.sdlc?.config();
+    const configured = !!config && config.mode !== "off" && !!config.bands && Object.keys(config.bands).length > 0;
+    return { ready: configured && !this.d.sweepHeld?.() && !this.d.bus.isRecoveryHeld && !this.d.bus.storageError, signature: configured ? JSON.stringify([config!.mode, config!.bands]) : "" };
+  }
+
+  proposeFromBands(by: PeerId = HUB): number[] {
+    const config = this.d.sdlc?.config();
+    if (!config || config.mode === "off" || !config.bands || !Object.keys(config.bands).length) return [];
+    if (this.d.sweepHeld?.() || this.d.bus.isRecoveryHeld || this.d.bus.storageError) return [];
+    if (by !== HUB && by !== USER) this.planningAuthority(by);
+    const report = this.sdlcMetrics(by === HUB ? USER : by);
+    if (report.bands === "off") return [];
+    const rows = this.d.board.list();
+    const bandRows = rows.filter(row => row.history[0]?.by === HUB && row.detail?.startsWith("Band breach key: "));
+    const keyOf = (row: Task) => row.detail!.split("\n")[0]!.slice("Band breach key: ".length);
+    const seen = new Set(bandRows.map(keyOf));
+    // A card counts as open while its task is not closed: the planner has not yet decided on it.
+    const open = new Set(bandRows.filter(row => !isClosedTaskState(row.state)).map(row => keyOf(row).split(":")[0]!));
+    const created: number[] = [];
+    for (const band of report.bands as BandResult[]) {
+      if (band.tier === "ok" || band.lastTask === null || band.episode === null) continue;
+      const key = `${band.metric}:#${band.episode}`;
+      if (band.tier === "log") {
+        const marker = `${key}:log`;
+        if (!open.has(band.metric) && this.d.board.recordBandNotice(marker)) this.releaseNotice(`sdlc band: ${band.metric} is ${band.reason}; last value ${band.last} on task #${band.lastTask}`);
+        continue;
       }
+      if (seen.has(`${key}:propose`) || seen.has(`${key}:diagnose`) || open.has(band.metric)) continue;
+      const tier = band.tier === "propose" ? "propose" : "diagnose";
+      const full = `${key}:${tier}`;
+      const evidence = `metric ${band.metric}; newest value ${band.last} on task #${band.lastTask}; episode began at task #${band.episode}; baseline mean ${band.mean}, deviation ${band.sd} over ${band.baseline} tasks; ${band.reason}`;
+      const diagnose = tier === "diagnose";
+      const title = diagnose ? `Diagnose SDLC metric ${band.metric}: read-only triage` : `Review SDLC metric ${band.metric}: control band breach`;
+      const detail = `Band breach key: ${full}\n${evidence}\n${diagnose
+        ? "Read-only triage for the planner: inspect the recent task histories behind this metric and report what changed. Do not edit files, branches or the board."
+        : "Backlog card for the planner: decide whether this breach needs a process change. It names the metric and its evidence; it opens no GitHub issue."}`;
+      const draft = { title, detail, refs: {} };
+      const signals = this.signalsFor(draft);
+      if (this.isPii({ signals }) || !this.candidateTextAllowed(`${title}\n${detail}`)) continue;
+      const proposal = this.d.board.propose(HUB, { ...draft, class: diagnose ? "triage" : "plan", backlog: true, signals });
+      this.incomingBacklog.add(proposal.id); seen.add(full); open.add(band.metric); created.push(proposal.id);
     }
-    return { ...digest, truncated: digest.truncated || incomplete, ...(current.some(task => this.isPii(task)) ? { privateTasks: "withheld" } : {}) };
+    for (const id of created) this.releaseNotice(`task #${id}: SDLC control band breach proposed in the backlog`);
+    return created;
   }
 
   /** S10 read-only planner report; S7 owns rolling bands and automatic board proposals. */
@@ -2997,7 +3147,7 @@ export class Tasks {
     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 } : {}), ...(metadata ? { refs: metadata } : {}) });
+    const next = this.linkOnWrite(this.d.board.update(task.id, by, "accepted", { state: "in_progress", ...(cleaned ? { plan: cleaned } : {}), ...(metadata ? { refs: metadata } : {}) })); // #723: refs.repo may have just arrived
     this.captureOwnerAcceptance(next);
     this.d.notify(`task ${this.publicTitle(next)} accepted by ${by}`);
     if (repositoryChanged) this.cohorts.leave(next.id);

package/src/hub/ui.ts

@@ -25,6 +25,9 @@ const TICKET_MS = 60_000;
 const SESSION_MS = 60 * 60_000;
 /** How long a session opened by `ahub ui --settings` may change settings that raise authority; it stays an ordinary session after. */
 export const SETTINGS_MS = 15 * 60_000;
+/** The page's view names (index.html DASHBOARD_VIEWS): the only values a snapshot request's `view` may carry to a project hub. */
+export const DASHBOARD_VIEWS = ["board", "office", "stream", "agents", "message", "memory", "settings"] as const;
+export const dashboardView = (value: unknown): typeof DASHBOARD_VIEWS[number] | undefined => (DASHBOARD_VIEWS as readonly unknown[]).includes(value) ? value as typeof DASHBOARD_VIEWS[number] : undefined;
 const LIMIT = 64;
 const secret = () => randomBytes(32).toString("hex");
 

package/src/hub/usage-rollup.ts

@@ -65,6 +65,10 @@ export interface TotalRow { peer: string; tokens: Counter; withoutCache: Counter
 /** `unknownPeers`: the peers whose figure is unknown, which the overall figure then leaves out (so it is `partial`, a lower bound, never a sum that treats them as 0). */
 export interface TotalResult { since: string | null; peers: TotalRow[]; overall: { tokens: Counter; withoutCache: Counter; cacheRead: Counter }; unknownPeers: { tokens: string[]; withoutCache: string[]; cacheRead: string[] } }
 
+/** `empty`: no record at all for that UTC day (a gap), shown as an empty column and never as a zero. */
+export interface DailyRow { day: string; peers: Record<string, Counter>; total: Counter; empty?: true }
+export interface DailyResult { days: DailyRow[]; peers: string[] }
+
 const sum = (a: number | null, b: number | null): number | null => a === null ? b : b === null ? a : a + b;
 const counter = (value: number | null, n: number, source: UsageSource = "native"): Counter => n > 0 && value !== null ? { value, source } : { value: null, source: "unknown" };
 
@@ -350,6 +354,60 @@ export class UsageRollup {
       unknownPeers: { tokens: unknownPeers(r => r.tokens), withoutCache: unknownPeers(r => r.withoutCache), cacheRead: unknownPeers(r => r.cacheRead) } };
   }
 
+  /**
+   * Daily tokens per peer for the last `days` calendar UTC days up to `now`, stacked for the dashboard Usage view (#683 U4).
+   * For each day and peer, tokens is native when reported, counted increments when available, otherwise unknown. A day inside
+   * the window with no record is an `empty` row (a gap the chart shows), and the window never starts before the first record.
+   */
+  daily(days = 14, now: number = Date.now()): DailyResult {
+    const raw = this.db.query(`SELECT day, peer, SUM(total) AS total, SUM(total_n) AS total_n FROM usage_rollup GROUP BY day, peer ORDER BY day ASC`).all() as any[];
+    const counted = this.db.query(`SELECT day, peer, SUM(tokens) AS tokens, SUM(increments) AS increments FROM token_rollup GROUP BY day, peer ORDER BY day ASC`).all() as any[];
+    const usageMap = new Map<string, { total: number; total_n: number }>();
+    for (const r of raw) usageMap.set(`${r.day}\0${r.peer}`, { total: r.total, total_n: r.total_n });
+    const countMap = new Map<string, { tokens: number; increments: number }>();
+    for (const r of counted) countMap.set(`${r.day}\0${r.peer}`, { tokens: r.tokens, increments: r.increments });
+
+    const allDays = [...new Set([...raw.map(r => r.day as string), ...counted.map(r => r.day as string)])].sort();
+    const allPeers = [...new Set([...raw.map(r => r.peer as string), ...counted.map(r => r.peer as string)])].sort();
+    // The last `days` calendar days ending today, clipped to the first day that has any record.
+    const dayMs = 86_400_000, today = new Date(now).toISOString().slice(0, 10);
+    const sliceDays: string[] = [];
+    if (allDays.length) for (let i = Math.max(1, Math.min(days, 366)) - 1; i >= 0; i--) {
+      const day = new Date(Date.parse(today + "T00:00:00Z") - i * dayMs).toISOString().slice(0, 10);
+      if (day >= allDays[0]!) sliceDays.push(day);
+    }
+
+    const resultDays: DailyRow[] = [];
+    for (const d of sliceDays) {
+      const peerCounters: Record<string, Counter> = {};
+      const knownCounters: Counter[] = [];
+      for (const p of allPeers) {
+        const u = usageMap.get(`${d}\0${p}`);
+        const c = countMap.get(`${d}\0${p}`);
+        let counterVal: Counter = { value: null, source: "unknown" };
+        if (u && u.total_n > 0) {
+          counterVal = counter(u.total, u.total_n);
+        } else if (c && c.increments > 0) {
+          counterVal = { value: c.tokens, source: "count" };
+        }
+        peerCounters[p] = counterVal;
+        if (counterVal.value !== null) knownCounters.push(counterVal);
+      }
+      let dayTotal: Counter = { value: null, source: "unknown" };
+      if (knownCounters.length > 0) {
+        const sumVal = knownCounters.reduce((acc, cur) => acc + cur.value!, 0);
+        const source: UsageSource = knownCounters.length !== allPeers.length
+          ? "partial"
+          : knownCounters.every(cur => cur.source === "native")
+          ? "native"
+          : "count";
+        dayTotal = { value: sumVal, source };
+      }
+      resultDays.push({ day: d, peers: peerCounters, total: dayTotal, ...(!allDays.includes(d) ? { empty: true as const } : {}) });
+    }
+    return { days: resultDays, peers: allPeers };
+  }
+
   /** Every roll-up row, in key order, for the rebuild-equals-incremental test. */
   dump(): unknown {
     const all = (table: string, order: string) => this.db.query(`SELECT * FROM ${table} ORDER BY ${order}`).all();