beadcyte 0.4.0

package/src/web/store.ts

@@ -0,0 +1,1378 @@
+// The one Pinia store. Holds the raw API payload plus the reactive controls
+// state (filters, window, group mode) that the view-model derives against.
+// Later beads mount their own controls-panel state (bp-fdl), URL round-trip
+// (bp-cel), and live refresh polling (bp-1kh) into the same fields here.
+
+import { defineStore } from "pinia";
+import {
+  assembleViewModel,
+  type Filters,
+  type GroupBy,
+  type Schedule,
+  type ScheduleEntry,
+  type ViewModel,
+  type WindowSpec,
+  projectGroups,
+} from "./view-model";
+import type { ViewMode } from "./composables/url-codec";
+import {
+  ACTIVE_PROJECT_STORAGE_KEY,
+  PROJECTS_STORAGE_KEY,
+  addProject,
+  moveProject,
+  parseProjects,
+  removeProject,
+  renameProject,
+  resolveActive,
+  serializeProjects,
+  unadmittedPaths,
+  type Project,
+} from "./projects";
+import {
+  DEFAULT_REFRESH_MS,
+  REFRESH_STORAGE_KEY,
+  parseRefreshMs,
+} from "./refresh";
+import {
+  WATCHLIST_STORAGE_KEY,
+  parseWatched,
+  serializeWatched,
+  toggleWatched,
+} from "./watchlist";
+import {
+  buildBeadDetail,
+  type BeadDetail,
+  type EstimateResult,
+} from "./bead-detail";
+import {
+  computeBlockedIds,
+  computeReadyNowIds,
+  computeOverCapAssignees,
+} from "./highlights";
+import {
+  CURRENT_USER_STORAGE_KEY,
+  SHORTCUT_IDS,
+  isShortcutActive,
+  shortcutFilters,
+  type Shortcut,
+} from "./shortcuts";
+import {
+  computeTriage,
+  scorePopulation,
+  signalPopulation,
+  type ScorePopulation,
+  type SignalPopulation,
+  type TriageResult,
+} from "./triage";
+import {
+  groupProgress,
+  shipTrend,
+  type GroupProgressRow,
+  type ShipTrend,
+} from "./insights";
+// The estimator + scheduler are shared with the CLI SVG mode — pure ES
+// modules, no `bd` shell-out, safe to import into the browser bundle.
+import { buildEstimator } from "../estimator.mjs";
+import { scheduleGreedy } from "../scheduler.mjs";
+import { stageWaits } from "../stage-waits.mjs";
+import { computeVelocity, calibrateRoster } from "../velocity.mjs";
+
+export interface Bead {
+  id: string;
+  title: string;
+  description?: string | null;
+  status: string;
+  priority: number | null;
+  issue_type: string;
+  assignee: string | null;
+  parent: string | null;
+  labels: string[] | null;
+  started_at: string | null;
+  closed_at?: string | null;
+  created_at: string;
+  updated_at: string;
+  dependencies: Array<{
+    type: string;
+    depends_on_id: string;
+  }> | null;
+  /** Present in `bd list --json`; feeds triage's activity-churn signal. */
+  comment_count?: number | null;
+  metadata?: Record<string, unknown> | null;
+  /**
+   * Added by the server from its background walk of `bd history`
+   * (bp-67g.57): when the bead first entered in_review, or null when it
+   * never did. Absent until the walk has reached the bead.
+   */
+  history?: { in_review_at: string | null; assigned_at?: string | null; walked_at?: string | null } | null;
+  /** A what-if idea (bp-q56): exists only in the what-if copy of the beads. */
+  hypothetical?: boolean;
+}
+
+export interface Roster {
+  cap?: number;
+  humans: Array<{
+    handle: string;
+    cap?: number;
+    /** Do not calibrate this cap (roster.json, or a what-if). */
+    cap_fixed?: boolean;
+    labels?: string[];
+    areas?: string[];
+  }>;
+  _derived?: boolean;
+}
+
+export interface Payload {
+  generated_at: string;
+  beads: Bead[];
+  roster: Roster;
+}
+
+interface ApiResponse {
+  stale: boolean;
+  generated_at?: string;
+  beads?: Bead[];
+  roster?: Roster;
+  /** Which project the server answered for. */
+  project?: string;
+  /** How long the server's `bd` call took, in ms. */
+  took_ms?: number;
+}
+
+// The rule lives in status-filter.ts so it is reachable from a test without
+// dragging Pinia and a fetch in — the same reason window.ts exists.
+// Re-exported because store.ts is where consumers already import from.
+export { STATUSES_HIDDEN_BY_DEFAULT, defaultStatusSelection } from "./status-filter";
+import { defaultStatusSelection } from "./status-filter";
+import { nextCursor } from "./keybindings";
+import { applyOptimistic, describeOutcome, type Mutation } from "./mutations";
+import { applyChanges, diffPlans, upsertChange, ideaEstimateDays, mutationsFor, describeChange, type WhatIfChange, type PlanDiff } from "./whatif";
+
+const DEFAULT_FILTERS: Filters = {
+  types: null,
+  priorities: null,
+  // Null until the first payload arrives, because the default is "every
+  // status this repo actually has, minus the ones above" and that cannot be
+  // known before the data. `initStatusSelection` fills it in.
+  statuses: null,
+  labels: null,
+  assignees: null,
+  unblocked: null,
+};
+
+// The window presets live in window.ts so they are reachable from a test —
+// see the note there about the duplicated copy that drifted. Re-exported
+// because store.ts is where every consumer already imports them from.
+export {
+  WINDOW_PRESETS,
+  windowFromPreset,
+  type WindowPreset,
+} from "./window";
+import { windowFromPreset, WINDOW_PRESETS, type WindowPreset } from "./window";
+
+function defaultWindow(): WindowSpec {
+  return windowFromPreset("90d");
+}
+
+export interface VelocityEntry {
+  handle: string;
+  closedInWindow: number;
+  closesPerWeek: number;
+  lastClosedAt: string | null;
+}
+
+export interface VelocitySummary {
+  asOf: Date;
+  lookbackDays: number;
+  perHuman: Map<string, VelocityEntry>;
+  /** Whole-week ship buckets ending at asOf. See velocity.mjs for why the
+   *  trend's window is weeklyWeeks * 7 days rather than lookbackDays. */
+  weekly: Array<{ weekStart: Date; count: number }>;
+  weeklyTotal: number;
+  weeklyWeeks: number;
+  totalClosedInWindow: number;
+  activeCount: number;
+}
+
+interface CachedSchedule {
+  key: string;
+  schedule: Schedule;
+  estimates: Map<string, EstimateResult>;
+  velocity: VelocitySummary;
+  calibratedRoster: Roster;
+}
+
+let scheduleCache: CachedSchedule | null = null;
+
+// Recompute the velocity + estimator + scheduler only when the underlying
+// beads change. Filter/group/window changes reuse the cached schedule + per-
+// bead estimates — the point of the view-model split is that reactivity is
+// cheap.
+/** The plan for these beads and this roster: velocity, estimator, calibration, waits, schedule. Uncached. */
+function computePlan(
+  beads: Bead[],
+  rawRoster: Roster,
+  horizon: Date,
+): {
+  schedule: Schedule;
+  estimates: Map<string, EstimateResult>;
+  velocity: VelocitySummary;
+  calibratedRoster: Roster;
+} {
+
+  // Reality calibration: measure per-human throughput over the last 60
+  // days and clamp each human's WIP cap via Little's Law using the
+  // estimator's median cycle time. Humans with no shipped history keep
+  // their raw cap so brand-new teams still get a projection.
+  const velocity = computeVelocity(beads) as VelocitySummary;
+  const { estimate, stats } = buildEstimator(beads) as unknown as {
+    estimate: (bead: Bead) => EstimateResult;
+    stats: {
+      global_median_days: number;
+      median_lead_days: number;
+    };
+  };
+  const calibratedRoster = calibrateRoster(rawRoster, velocity, {
+    medianCycleDays: stats.median_lead_days || stats.global_median_days,
+  }) as Roster;
+  const estimates = new Map<string, EstimateResult>();
+  const capturingEstimate = (bead: Bead): EstimateResult => {
+    // A what-if idea carries its own size (bp-q56); everything else is the estimator's.
+    const own = ideaEstimateDays(bead);
+    const r = own !== null ? { days: own, p90: null, source: `what-if, ${(own * 24).toFixed(1)}h` } : (estimate(bead) as EstimateResult);
+    estimates.set(bead.id, r);
+    return r;
+  };
+  // The wait clock (bp-m0g): this project's own stage medians, and the
+  // estimator's lead-time median as the floor where review data is missing.
+  const waits = stageWaits(beads);
+  const result = scheduleGreedy(beads, calibratedRoster, capturingEstimate, horizon, {
+    waits,
+    minLeadDays: stats.median_lead_days || 0,
+  }) as unknown as {
+    schedule: Schedule;
+    unassignedProjection: Schedule;
+  };
+  const schedule = result.schedule;
+  for (const [id, s] of result.unassignedProjection) {
+    if (!schedule.has(id)) schedule.set(id, s);
+  }
+  // Fill in estimates for closed/deferred beads — the scheduler doesn't
+  // call the estimator on those, but the tooltip should still show the
+  // historical model's opinion.
+  for (const b of beads) {
+    if (!estimates.has(b.id)) estimates.set(b.id, estimate(b) as EstimateResult);
+  }
+  return { schedule, estimates, velocity, calibratedRoster };
+}
+
+function scheduleFor(
+  beads: Bead[],
+  rawRoster: Roster,
+  horizon: Date,
+): {
+  schedule: Schedule;
+  estimates: Map<string, EstimateResult>;
+  velocity: VelocitySummary;
+  calibratedRoster: Roster;
+} {
+  const key =
+    beads.length + ":" + beads.map((b) => b.id + "@" + b.status).join(",") +
+    "|" + JSON.stringify(rawRoster);
+  if (scheduleCache && scheduleCache.key === key) return scheduleCache;
+  scheduleCache = { key, ...computePlan(beads, rawRoster, horizon) };
+  return scheduleCache;
+}
+
+
+export type HighlightKind = "blocked" | "over-cap" | "ready-now";
+
+export const HIGHLIGHT_KINDS: HighlightKind[] = [
+  "blocked",
+  "over-cap",
+  "ready-now",
+];
+
+// Shared frozen empty set for highlight getters — lets components use
+// `.has()` without a null-check while still hitting Vue's identity-based
+// change detection (returning the same instance every time avoids spurious
+// re-renders).
+const EMPTY_SET: ReadonlySet<string> = new Set();
+
+export const useBeadsStore = defineStore("beads", {
+  state: () => ({
+    payload: null as Payload | null,
+    loading: false,
+    error: null as string | null,
+    lastFetched: null as Date | null,
+    filters: { ...DEFAULT_FILTERS } as Filters,
+    /**
+     * Normally-hidden statuses a legacy `?showClosed=`/`?includeDeferred=`
+     * link asked for, awaiting `initStatusSelection`. Not persisted to the
+     * URL — it is a one-shot translation of an old link, not state.
+     */
+    pendingLegacyStatuses: null as string[] | null,
+    window: defaultWindow(),
+    groupBy: "epic" as GroupBy,
+    /** Gantt and grid are alternative views of the same data, not
+     *  companions — only the selected one is mounted. */
+    view: "mine" as ViewMode,
+    // ── keyboard (bp-67g.45) ─────────────────────────────────────────────
+    /** The ? overlay. */
+    helpOpen: false,
+    /** The in-app changelog (bp-67g.46). */
+    changelogOpen: false,
+    /** The first-run walkthrough (bp-67g.48); App opens it once, options re-opens it. */
+    walkthroughOpen: false,
+    // ── writes (bp-ocs) ─────────────────────────────────────────────────
+    /** The quick-actions menu: which bead, and where to draw it. */
+    contextMenu: null as { id: string; x: number; y: number } | null,
+    /** The last write's outcome, for the toast. */
+    notice: null as { kind: "ok" | "error"; text: string } | null,
+    /** Ids with a write in flight, so a surface can show it. */
+    pending: [] as string[],
+    /**
+     * The order beads appear in on the active view, published by the views
+     * whose order the store cannot derive (table: its sort; mine: its
+     * sections). The gantt and grid are viewModel.rows. j/k walk this.
+     */
+    viewOrder: [] as string[],
+    /** Bumped to ask the search palette / options menu to open; they watch it. */
+    searchRequests: 0,
+    optionsRequests: 0,
+    /** Bumped by the t key; the Gantt centres its viewport on today (bp-c6q). */
+    todayRequests: 0,
+    /** The drawer's subgraph scope, here so a key can flip it (bp-67g.60 built it local). */
+    drawerSubgraphScope: "bead" as "bead" | "epic",
+    /** Personal watch list, ids in the order they were added. Deliberately
+     *  NOT part of URL state: sharing a link should share the view, not the
+     *  recipient's pins. */
+    /** Who the MINE shortcuts mean (bp-egy). Stored in this browser. */
+    currentUser: (typeof localStorage === "undefined"
+      ? null
+      : localStorage.getItem(CURRENT_USER_STORAGE_KEY)) as string | null,
+    /** A `?me=` carried by a shared link: wins for this load only. */
+    urlUser: null as string | null,
+    /** The person the incytes view is scoped to (bp-67g.43); ?who= in the URL. */
+    who: null as string | null,
+    // ── what-if (bp-q56) ─────────────────────────────────────────────────
+    /** The change set. Non-empty means every plan-reading view shows the what-if. */
+    whatIf: [] as WhatIfChange[],
+    whatIfPanelOpen: false,
+    /** The last confirm's outcome, per change (bp-2fq). */
+    whatIfReport: null as Array<{ text: string; ok: boolean; detail?: string }> | null,
+    whatIfApplying: false,
+    watched: (typeof localStorage === "undefined"
+      ? []
+      : parseWatched(localStorage.getItem(WATCHLIST_STORAGE_KEY))) as string[],
+    /** Narrow both views to watched beads (and the children of watched
+     *  epics). Session-only, like the highlight toggles. */
+    watchedOnly: false,
+
+    /** Known project locations, in the order the user arranged them. */
+    projects: (typeof localStorage === "undefined"
+      ? []
+      : parseProjects(localStorage.getItem(PROJECTS_STORAGE_KEY))) as Project[],
+    activeProjectId: (typeof localStorage === "undefined"
+      ? null
+      : localStorage.getItem(ACTIVE_PROJECT_STORAGE_KEY)) as string | null,
+    /** The directory the server was started in; seeded into an empty
+     *  registry so a first run is never blank. */
+    launchPath: null as string | null,
+    /**
+     * Registry paths the CURRENT server would not admit, keyed by path with
+     * the refusal code as the value. Populated by loadProjects()'s reconcile
+     * step, which re-registers everything the server has forgotten; whatever
+     * still fails validation lands here so the menu can say so, instead of
+     * leaving a row that 403s whenever it is clicked.
+     *
+     * Not persisted: it is a statement about this server, exactly like the
+     * allowlist it mirrors.
+     */
+    unavailableProjects: {} as Record<string, string>,
+    /** Last observed fetch duration for the active project, from the
+     *  server. Feeds the load meter, which has no honest progress of its
+     *  own to report. */
+    lastFetchMs: null as number | null,
+    /**
+     * Prior durations keyed by project path. The meter needs an expectation
+     * BEFORE the fetch returns, so remembering the last run per project is
+     * what makes a switch back determinate instead of starting blind.
+     */
+    fetchMsByProject: {} as Record<string, number>,
+    /** When the in-flight fetch started, for the meter's elapsed clock. */
+    fetchStartedAt: null as number | null,
+    /**
+     * True while a refresh is happening over data we already have. Derived
+     * rather than flagged by the caller: what decides whether to blank the
+     * view is simply whether there IS a view — a manual refresh and a
+     * polled one both leave the chart up.
+     */
+    refreshingInPlace: false,
+    /** Poll interval in ms; 0 means manual refresh only. bp-1kh acts on it. */
+    pollIntervalMs: (typeof localStorage === "undefined"
+      ? DEFAULT_REFRESH_MS
+      : parseRefreshMs(localStorage.getItem(REFRESH_STORAGE_KEY))) as number,
+    // Row cap per group before truncation. Higher than the CLI default (20)
+    // because the interactive Gantt scrolls naturally — you rarely want
+    // work hidden by default, but a ceiling still helps very large groups
+    // stay usable. Per-group expand is offered via the group header.
+    maxPerGroup: 50,
+    /**
+     * Groups where per-group row truncation is lifted (all rows visible).
+     * Kept as a plain object rather than a Set so Pinia's reactivity picks
+     * up mutations without the caller needing to reassign.
+     */
+    expandedGroups: {} as Record<string, boolean>,
+    highlights: {
+      blocked: false,
+      "over-cap": false,
+      "ready-now": false,
+    } as Record<HighlightKind, boolean>,
+    /** Draw dependency arrows between visible bars. When on, arrows render
+     *  around the hovered bead only — that's
+     *  the most useful signal and stays legible in a big project. Full-graph
+     *  arrows require the separate `showAllDependencies` opt-in. */
+    showDependencies: false,
+    /** Draw arrows for every visible blocks edge, regardless of hover. Off
+     *  by default because the arrow density gets busy fast. */
+    showAllDependencies: false,
+    /** Which bead has its detail drawer open, if any. Set via
+     *  openBead() / closeBead() and kept in sync with the URL hash by
+     *  App.vue so drawers are deep-linkable. */
+    openBeadId: null as string | null,
+  }),
+
+  getters: {
+    beads: (s): Bead[] => s.payload?.beads ?? [],
+    roster: (s): Roster | null => s.payload?.roster ?? null,
+    generatedAt: (s): string | null => s.payload?.generated_at ?? null,
+
+    /** The user the MINE shortcuts filter on: the link's if it carries one, else the stored choice. */
+    effectiveUser: (s): string | null => s.urlUser ?? s.currentUser,
+
+    /** Assignee handles present on real beads, most-used first: the options for "current user". */
+    presentAssignees(): string[] {
+      const seen = new Map<string, number>();
+      for (const b of this.beads) {
+        if (b.issue_type === "epic" || !b.assignee) continue;
+        seen.set(b.assignee, (seen.get(b.assignee) ?? 0) + 1);
+      }
+      return [...seen.entries()].sort((a, b) => b[1] - a[1]).map(([h]) => h);
+    },
+
+    /** A stored user that no longer appears in the data: renamed or departed. */
+    userIsStale(): boolean {
+      const u = this.effectiveUser;
+      return !!u && this.beads.length > 0 && !this.presentAssignees.includes(u);
+    },
+
+    /** Statuses on real beads, the same enumeration the status filter seeds from. */
+    presentStatuses(): string[] {
+      const out = new Set<string>();
+      for (const b of this.beads) if (b.issue_type !== "epic") out.add(b.status);
+      return [...out];
+    },
+
+    /** Which MINE shortcut the current filters equal, if any. Derived, never stored. */
+    activeShortcut(state): Shortcut | null {
+      const me = this.effectiveUser;
+      if (!me) return null;
+      for (const id of SHORTCUT_IDS) {
+        if (isShortcutActive(state.filters, id, me, this.presentStatuses)) return id;
+      }
+      return null;
+    },
+
+    watchedSet: (s): ReadonlySet<string> => new Set(s.watched),
+
+    /**
+     * How long the active project took last time, or null if we've never
+     * loaded it. Null is the honest answer and the meter shows an
+     * indeterminate bar for it rather than guessing.
+     */
+    expectedFetchMs(state): number | null {
+      const path = this.activeProject?.path;
+      if (!path) return null;
+      return state.fetchMsByProject[path] ?? null;
+    },
+
+    /**
+     * The selected project. Resolution order lives in projects.ts:
+     * ?project=<label>, then the stored id, then the launch directory,
+     * then the first entry — so a non-empty list always has a selection.
+     */
+    activeProject(state): Project | null {
+      const urlLabel =
+        typeof location === "undefined"
+          ? null
+          : new URLSearchParams(location.search).get("project");
+      return resolveActive(state.projects, {
+        urlLabel,
+        storedId: state.activeProjectId,
+        launchPath: state.launchPath,
+      });
+    },
+
+    /**
+     * Watched ids that still exist in the payload, paired with their bead.
+     * An id can outlive its bead (deleted, renamed, or simply out of this
+     * repo), so the header list and count are built from this rather than
+     * from the raw id list.
+     */
+    watchedBeads(state): Bead[] {
+      const byId = new Map(
+        (state.payload?.beads ?? []).map((b) => [b.id, b] as const),
+      );
+      return state.watched
+        .map((id) => byId.get(id))
+        .filter((b): b is Bead => !!b);
+    },
+
+    /**
+     * Full schedule + per-bead estimates + observed velocity + calibrated
+     * roster. Kept in a single cached getter so all consumers share one
+     * computation; callers treat every returned map as a read-only
+     * snapshot.
+     */
+    /** The real plan: the payload as bd reports it, cached. */
+    baselinePlan(state): {
+      schedule: Schedule;
+      estimates: Map<string, EstimateResult>;
+      velocity: VelocitySummary;
+      calibratedRoster: Roster;
+    } | null {
+      if (!state.payload) return null;
+      const roster = state.payload.roster ?? { humans: [] };
+      const horizon = state.window.to ?? new Date(Date.now() + 90 * 86_400_000);
+      return scheduleFor(state.payload.beads, roster, horizon);
+    },
+
+    whatIfActive(state): boolean {
+      return state.whatIf.length > 0;
+    },
+
+    /** The beads the plan is over: the what-if copy when one is active (bp-q56). */
+    planBeads(state): Bead[] {
+      if (!state.payload) return [];
+      if (state.whatIf.length === 0) return state.payload.beads;
+      return applyChanges(state.payload.beads, state.payload.roster ?? { humans: [] }, state.whatIf).beads;
+    },
+
+    /**
+     * The plan every plan-reading view uses: the baseline, or the what-if's
+     * copy run through the same pipeline. Uncached on purpose — a what-if is
+     * edited interactively and the pipeline is ~50ms.
+     */
+    scheduleWithEstimates(state): {
+      schedule: Schedule;
+      estimates: Map<string, EstimateResult>;
+      velocity: VelocitySummary;
+      calibratedRoster: Roster;
+    } | null {
+      if (!state.payload) return null;
+      if (state.whatIf.length === 0) return this.baselinePlan;
+      const applied = applyChanges(state.payload.beads, state.payload.roster ?? { humans: [] }, state.whatIf);
+      const horizon = state.window.to ?? new Date(Date.now() + 90 * 86_400_000);
+      return computePlan(applied.beads, applied.roster, horizon);
+    },
+
+    /** What the what-if moves against the baseline; null when none is active. */
+    whatIfDiff(state): PlanDiff | null {
+      if (state.whatIf.length === 0) return null;
+      const base = this.baselinePlan;
+      const plan = this.scheduleWithEstimates;
+      if (!base || !plan) return null;
+      return diffPlans(base.schedule, plan.schedule, this.planBeads, { frontierDays: 14 });
+    },
+
+    /** Observed per-human close-rate over the last 60 days. */
+    velocity(): VelocitySummary | null {
+      return this.scheduleWithEstimates?.velocity ?? null;
+    },
+
+    /**
+     * Roster with per-human WIP caps clamped to observed weekly close-rate.
+     * Consumers reach for this instead of the raw roster when they want to
+     * show "actual" projected concurrency.
+     */
+    calibratedRoster(): Roster | null {
+      return this.scheduleWithEstimates?.calibratedRoster ?? null;
+    },
+
+    /**
+     * The reactive view model. Pinia getters are cached against their
+     * reactive reads, so this only recomputes when beads, filters, window,
+     * or group mode change.
+     */
+    viewModel(state): ViewModel | null {
+      const sched = this.scheduleWithEstimates;
+      if (!state.payload || !sched) return null;
+      const expanded = new Set(
+        Object.entries(state.expandedGroups)
+          .filter(([, v]) => v)
+          .map(([k]) => k),
+      );
+      return assembleViewModel(this.planBeads, sched.schedule, {
+        groupBy: state.groupBy,
+        filters: state.watchedOnly
+          ? { ...state.filters, watchedIds: state.watched }
+          : state.filters,
+        window: state.window,
+        maxPerGroup: state.maxPerGroup,
+        expandedGroups: expanded,
+      });
+    },
+
+    /**
+     * The table view's rows (bp-67g.44): the same filtered, windowed set as
+     * viewModel — same filters, same watched-only merge, same window — with
+     * the per-group cap lifted. Truncation is a Gantt drawing affordance; a
+     * table that silently drops rows is worse than a long one. Lazy, so the
+     * second assembly costs nothing until the table is on screen.
+     */
+    tableViewModel(state): ViewModel | null {
+      const sched = this.scheduleWithEstimates;
+      if (!state.payload || !sched) return null;
+      return assembleViewModel(this.planBeads, sched.schedule, {
+        groupBy: state.groupBy,
+        filters: state.watchedOnly
+          ? { ...state.filters, watchedIds: state.watched }
+          : state.filters,
+        window: state.window,
+        maxPerGroup: Infinity,
+      });
+    },
+
+    /**
+     * Build the tooltip payload for a bead by id. Returns null if the bead
+     * or the payload isn't loaded yet. Consumers (tooltip, drawer)
+     * pass this straight to the template.
+     */
+    beadDetailFor(): (id: string) => BeadDetail | null {
+      const sched = this.scheduleWithEstimates;
+      const beads = this.planBeads;
+      const byId = new Map(beads.map((b) => [b.id, b] as const));
+      return (id: string): BeadDetail | null => {
+        const b = byId.get(id);
+        if (!b) return null;
+        return buildBeadDetail(
+          b,
+          sched?.schedule.get(id) as ScheduleEntry | undefined,
+          sched?.estimates.get(id),
+          { horizonDay: this.scheduleHorizonDay },
+        );
+      };
+    },
+
+    /**
+     * How many days past today the scheduler was asked to project.
+     *
+     * The same number scheduleWithEstimates hands scheduleGreedy, so a
+     * finish clamped to the horizon can be recognised as a bound rather
+     * than reported as a date. It moves with the window preset, which is
+     * exactly why the caveat is needed.
+     */
+    scheduleHorizonDay(state): number {
+      const horizon =
+        state.window.to ?? new Date(Date.now() + 90 * 86_400_000);
+      const today = new Date();
+      const day0 = new Date(
+        today.getFullYear(),
+        today.getMonth(),
+        today.getDate(),
+      );
+      const end = new Date(
+        horizon.getFullYear(),
+        horizon.getMonth(),
+        horizon.getDate(),
+      );
+      return Math.round((+end - +day0) / 86_400_000);
+    },
+
+    blockedBeadIds(state): ReadonlySet<string> {
+      if (!state.highlights.blocked) return EMPTY_SET;
+      return computeBlockedIds(state.payload?.beads ?? []);
+    },
+
+    readyNowBeadIds(state): ReadonlySet<string> {
+      if (!state.highlights["ready-now"]) return EMPTY_SET;
+      return computeReadyNowIds(state.payload?.beads ?? []);
+    },
+
+    overCapAssignees(state): ReadonlySet<string> {
+      if (!state.highlights["over-cap"]) return EMPTY_SET;
+      return computeOverCapAssignees(
+        state.payload?.beads ?? [],
+        state.payload?.roster ?? { humans: [] },
+      );
+    },
+
+    /**
+     * Triage score per bead — same signal set as bv --robot-triage,
+     * computed locally. Cached against the full bead array.
+     */
+    triage(state): Map<string, TriageResult> {
+      if (!state.payload) return new Map();
+      return computeTriage(state.payload.beads);
+    },
+
+    /**
+     * Per-signal spread of the triage signals across the OPEN population.
+     *
+     * Open only: that is the set triage ranks, and including closed beads
+     * would make every live bead look extreme against a mostly-dead field.
+     * Cached against the payload like `triage` itself, and read only from
+     * the drawer, so it stays off the Gantt's path.
+     */
+    triageSignalPopulation(): SignalPopulation[] {
+      const t = this.triage;
+      if (!t.size) return [];
+      const openIds = (this.payload?.beads ?? [])
+        .filter((b) => b.status !== "closed")
+        .map((b) => b.id);
+      return signalPopulation(openIds, t);
+    },
+
+    /**
+     * The composite score's own population, for the drawer's strip (bp-67g.28).
+     * Open beads only, for the reason signalPopulation gives; read only from
+     * the drawer, so triage stays lazy.
+     */
+    triageScorePopulation(): ScorePopulation {
+      const t = this.triage;
+      const openIds = t.size
+        ? (this.payload?.beads ?? []).filter((b) => b.status !== "closed").map((b) => b.id)
+        : [];
+      return scorePopulation(openIds, t);
+    },
+
+    /**
+     * Ships per week, for the summary trend. Reshapes the series
+     * computeVelocity already accumulated — nothing walks the beads again,
+     * and the trend cannot disagree with the calibration band about what
+     * counts as a ship.
+     */
+    shipTrend(): ShipTrend | null {
+      const v = this.velocity;
+      return v ? shipTrend(v.weekly) : null;
+    },
+
+    /**
+     * Groups by population for the summary chart, largest first.
+     *
+     * Derived from the view model's groups, so it respects the current
+     * group-by mode — but the quantity is `progress`, which is counted
+     * before filtering and window clipping, so the chart doesn't shrink
+     * when someone hides closed beads.
+     */
+    // Project-wide (bp-67g.36): every group over every bead, so neither the
+    // filters nor the window reach the incytes Progress block. It used to
+    // reshape viewModel.groups, which only carries groups with a visible row.
+    groupProgress(state): GroupProgressRow[] {
+      const sched = this.scheduleWithEstimates;
+      if (!state.payload || !sched) return [];
+      return groupProgress(projectGroups(state.payload.beads, sched.schedule, state.groupBy));
+    },
+
+    /** The beads in the order the active view shows them; what j/k walk. */
+    cursorOrder(state): string[] {
+      if (state.view === "gantt" || state.view === "grid") return this.viewModel?.rows.map((r) => r.beadId) ?? [];
+      if (state.view === "table" || state.view === "mine") return state.viewOrder;
+      return [];
+    },
+
+    /** The preset the current window matches, or null when it is custom. */
+    activeWindowPreset(state): WindowPreset | null {
+      const same = (a: Date | null, b: Date | null) =>
+        (a === null && b === null) || (a !== null && b !== null && Math.abs(a.getTime() - b.getTime()) < 60_000);
+      for (const p of WINDOW_PRESETS) {
+        const w = windowFromPreset(p.id);
+        if (same(state.window.from, w.from) && same(state.window.to, w.to)) return p.id;
+      }
+      return null;
+    },
+
+    /** One bead by id, or null. */
+    beadById(state): (id: string) => Bead | null {
+      const byId = new Map((state.payload?.beads ?? []).map((b) => [b.id, b] as const));
+      return (id: string) => byId.get(id) ?? null;
+    },
+
+    /** The currently-open bead (drawer target), or null. */
+    drawerBead(state): Bead | null {
+      if (!state.openBeadId || !state.payload) return null;
+      return state.payload.beads.find((b) => b.id === state.openBeadId) ?? null;
+    },
+  },
+
+  actions: {
+    async fetch() {
+      // Refreshing over existing data must not blank the chart someone is
+      // reading, whether the trigger was a timer or a button.
+      this.refreshingInPlace = !!this.payload;
+      this.loading = true;
+      this.fetchStartedAt = Date.now();
+      this.error = null;
+      // Captured before awaiting: a project switch mid-flight must not let
+      // the old project's response land on the new selection.
+      const requestedProject = this.activeProject?.path ?? null;
+      try {
+        const params = new URLSearchParams();
+        if (this.generatedAt) params.set("since", this.generatedAt);
+        if (requestedProject) params.set("project", requestedProject);
+        const qs = params.toString();
+        const res = await fetch(qs ? `/api/beads?${qs}` : "/api/beads");
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const body = (await res.json()) as ApiResponse;
+        // Discard a response for a project we've since navigated away from.
+        if ((this.activeProject?.path ?? null) !== requestedProject) return;
+        if (typeof body.took_ms === "number") {
+          this.lastFetchMs = body.took_ms;
+          if (requestedProject) {
+            this.fetchMsByProject[requestedProject] = body.took_ms;
+          }
+        }
+        if (body.stale === false) {
+          this.lastFetched = new Date();
+          return;
+        }
+        if (!body.beads || !body.generated_at) {
+          throw new Error("malformed payload from /api/beads");
+        }
+        this.payload = {
+          generated_at: body.generated_at,
+          beads: body.beads,
+          roster: body.roster ?? { humans: [] },
+        };
+        // The status filter's default depends on which statuses this repo
+        // actually has, so it can only be seeded once data exists. No-ops
+        // after the first payload and whenever a selection already stands.
+        this.initStatusSelection();
+        this.lastFetched = new Date();
+      } catch (e) {
+        this.error = String((e as Error).message ?? e);
+      } finally {
+        this.loading = false;
+        this.fetchStartedAt = null;
+        this.refreshingInPlace = false;
+      }
+    },
+
+    /**
+     * Ask the server what it was launched in and what it already trusts,
+     * then make sure the launch directory is in the registry. Without this
+     * a fresh browser shows an empty project list against a server that is
+     * perfectly happy to serve one.
+     */
+    async loadProjects() {
+      try {
+        const res = await fetch("/api/projects");
+        if (!res.ok) return;
+        const body = (await res.json()) as {
+          launch?: string;
+          projects?: string[];
+        };
+        if (!body.launch) return;
+        this.launchPath = body.launch;
+        if (!this.projects.some((p) => p.path === body.launch)) {
+          this.projects = addProject(this.projects, { path: body.launch });
+          this.persistProjects();
+        }
+
+        // Reconcile. The server's allowlist is per-process by design, so
+        // every restart leaves this registry holding paths it has forgotten
+        // — and reading one of those answers 403 with no data. Re-register
+        // them now, at boot, rather than discovering it at the click that
+        // switches to one.
+        //
+        // Re-registering rather than persisting the allowlist keeps the
+        // property that makes it per-process: inspectProject() runs again in
+        // THIS process, so a path that has moved or lost its .beads is
+        // refused now instead of being trusted from a stale file.
+        await Promise.all(
+          unadmittedPaths(this.projects, body.projects).map(async (path) => {
+            const result = await this.addProjectByPath(path);
+            if (result.ok) {
+              delete this.unavailableProjects[path];
+            } else {
+              this.unavailableProjects[path] = result.reason;
+            }
+          }),
+        );
+      } catch {
+        // Older server, or none. The app still works against the default
+        // project; the menu simply has nothing to switch between.
+      }
+    },
+
+    /**
+     * Register a path with the server and add it on success. Returns the
+     * refusal reason so the UI can say why rather than failing silently.
+     */
+    async addProjectByPath(
+      path: string,
+      label?: string,
+    ): Promise<{ ok: true } | { ok: false; reason: string }> {
+      try {
+        const res = await fetch("/api/projects", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ path }),
+        });
+        const body = (await res.json()) as {
+          ok?: boolean;
+          path?: string;
+          label?: string;
+          reason?: string;
+        };
+        if (!res.ok || !body.ok || !body.path) {
+          return { ok: false, reason: body.reason ?? `http-${res.status}` };
+        }
+        // Store the path the SERVER canonicalised, not what was typed, so
+        // later reads normalise to the same string it admitted.
+        this.projects = addProject(this.projects, {
+          path: body.path,
+          label: label || body.label,
+        });
+        delete this.unavailableProjects[body.path];
+        this.persistProjects();
+        return { ok: true };
+      } catch (e) {
+        return { ok: false, reason: String((e as Error).message ?? e) };
+      }
+    },
+
+    setPollInterval(ms: number) {
+      this.pollIntervalMs = parseRefreshMs(String(ms));
+      try {
+        localStorage.setItem(REFRESH_STORAGE_KEY, String(this.pollIntervalMs));
+      } catch {
+        /* private mode — holds for this session only */
+      }
+    },
+
+    setActiveProject(id: string) {
+      if (this.activeProjectId === id) return;
+      this.activeProjectId = id;
+      try {
+        localStorage.setItem(ACTIVE_PROJECT_STORAGE_KEY, id);
+      } catch {
+        /* private mode — holds for this session only */
+      }
+      // A different project is a different dataset: drop the payload so the
+      // views show a load state rather than the previous project's beads,
+      // and close the drawer, whose id does not exist over there.
+      this.payload = null;
+      this.openBeadId = null;
+      this.lastFetchMs = null;
+      void this.fetch();
+    },
+
+    renameProject(id: string, label: string) {
+      this.projects = renameProject(this.projects, id, label);
+      this.persistProjects();
+    },
+
+    /** Forgets a location. Nothing on disk is touched. */
+    forgetProject(id: string) {
+      const wasActive = this.activeProject?.id === id;
+      const gone = this.projects.find((p) => p.id === id);
+      if (gone) delete this.unavailableProjects[gone.path];
+      this.projects = removeProject(this.projects, id);
+      this.persistProjects();
+      if (wasActive) {
+        const fallback = resolveActive(this.projects, {
+          launchPath: this.launchPath,
+        });
+        if (fallback) this.setActiveProject(fallback.id);
+      }
+    },
+
+    moveProject(id: string, delta: number) {
+      this.projects = moveProject(this.projects, id, delta);
+      this.persistProjects();
+    },
+
+    persistProjects() {
+      try {
+        localStorage.setItem(
+          PROJECTS_STORAGE_KEY,
+          serializeProjects(this.projects),
+        );
+      } catch {
+        /* private mode — holds for this session only */
+      }
+    },
+
+    setGroupBy(g: GroupBy) {
+      this.groupBy = g;
+    },
+
+    setView(v: ViewMode) {
+      this.view = v;
+    },
+
+    toggleWatch(id: string) {
+      this.watched = toggleWatched(this.watched, id);
+      try {
+        localStorage.setItem(
+          WATCHLIST_STORAGE_KEY,
+          serializeWatched(this.watched),
+        );
+      } catch {
+        // Private mode or a full quota: the list still works for this
+        // session, it just won't survive a reload. Not worth failing over.
+      }
+      // Nothing left to narrow to.
+      if (this.watched.length === 0) this.watchedOnly = false;
+    },
+
+    toggleWatchedOnly() {
+      this.watchedOnly = !this.watchedOnly;
+    },
+
+    toggleHighlight(kind: HighlightKind) {
+      this.highlights = {
+        ...this.highlights,
+        [kind]: !this.highlights[kind],
+      };
+    },
+
+    toggleShowDependencies() {
+      this.showDependencies = !this.showDependencies;
+    },
+
+    toggleShowAllDependencies() {
+      this.showAllDependencies = !this.showAllDependencies;
+    },
+
+    openBead(id: string) {
+      this.openBeadId = id;
+      this.drawerSubgraphScope = "bead";
+    },
+
+    closeBead() {
+      this.openBeadId = null;
+    },
+
+    // ── keyboard (bp-67g.45) ─────────────────────────────────────────────
+    /** The keyboard cursor is the open drawer; see keybindings.ts. */
+    moveCursor(delta: number) {
+      const id = nextCursor(this.cursorOrder, this.openBeadId, delta);
+      if (id) this.openBead(id);
+    },
+
+    publishViewOrder(ids: string[]) {
+      this.viewOrder = ids;
+    },
+
+    openHelp() {
+      this.helpOpen = true;
+    },
+
+    closeHelp() {
+      this.helpOpen = false;
+    },
+
+    openChangelog() {
+      this.changelogOpen = true;
+    },
+
+    openWalkthrough() {
+      this.walkthroughOpen = true;
+    },
+
+    // ── writes (bp-ocs) ─────────────────────────────────────────────────
+    openContextMenu(id: string, x: number, y: number) {
+      this.contextMenu = { id, x, y };
+    },
+
+    closeContextMenu() {
+      this.contextMenu = null;
+    },
+
+    clearNotice() {
+      this.notice = null;
+    },
+
+    /**
+     * Apply a whitelisted mutation: optimistic patch, POST to /api/mutate,
+     * then the server's fresh bead — or the original back on failure — and
+     * a notice either way that carries the exact bd command. Finishes with
+     * a fetch, since the server dropped its list cache for the project.
+     */
+    async mutate(m: Mutation) {
+      const beads = this.payload?.beads;
+      if (!beads) return;
+      const i = beads.findIndex((b) => b.id === m.id);
+      if (i < 0) return;
+      const original = beads[i]!;
+      const guess = applyOptimistic(original, m, this.effectiveUser);
+      beads.splice(i, 1, guess);
+      this.pending = [...this.pending, m.id];
+      const project = this.activeProject?.path ?? null;
+      try {
+        const res = await fetch("/api/mutate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ ...m, project }),
+        });
+        const body = (await res.json().catch(() => ({}))) as { ok?: boolean; command?: string; bead?: Bead | null; error?: string };
+        // A 404 here is a server started before this route existed: Vite
+        // hot-reloads the client but middleware loads at start.
+        if (res.status === 404) {
+          throw new Error("this server predates quick actions — restart it (beadcyte stop, then beadcyte start)");
+        }
+        if (!res.ok || !body.ok) throw new Error(body.error || `HTTP ${res.status}`, { cause: body.command });
+        const j = this.payload?.beads.findIndex((b) => b.id === m.id) ?? -1;
+        if (j >= 0 && body.bead) this.payload!.beads.splice(j, 1, { ...this.payload!.beads[j]!, ...body.bead });
+        if (body.command) console.info(`beadcyte: ${body.command}`);
+        this.notice = { kind: "ok", text: `${m.id} ${describeOutcome(m)}` };
+      } catch (e) {
+        const j = this.payload?.beads.findIndex((b) => b.id === m.id) ?? -1;
+        if (j >= 0) this.payload!.beads.splice(j, 1, original);
+        const err = e as Error & { cause?: unknown };
+        if (typeof err.cause === "string") console.info(`beadcyte: failed: ${err.cause}`);
+        this.notice = { kind: "error", text: `${m.id}: ${err.message}` };
+      } finally {
+        this.pending = this.pending.filter((id) => id !== m.id);
+        setTimeout(() => {
+          if (this.notice) this.notice = null;
+        }, 6000);
+        void this.fetch();
+      }
+    },
+
+    closeWalkthrough() {
+      this.walkthroughOpen = false;
+    },
+
+    closeChangelog() {
+      this.changelogOpen = false;
+    },
+
+    requestSearch() {
+      this.searchRequests++;
+    },
+
+    requestOptions() {
+      this.optionsRequests++;
+    },
+
+    requestToday() {
+      this.todayRequests++;
+    },
+
+    setDrawerSubgraphScope(scope: "bead" | "epic") {
+      this.drawerSubgraphScope = scope;
+    },
+
+    toggleDrawerSubgraphScope() {
+      this.drawerSubgraphScope = this.drawerSubgraphScope === "bead" ? "epic" : "bead";
+    },
+
+    /**
+     * Add or remove one status from the status selection. An empty or null
+     * selection means every status, so it is materialised from the statuses
+     * present before the toggle, otherwise removing "closed" from "all"
+     * would have nothing to remove it from.
+     */
+    toggleStatusInFilter(status: string) {
+      const cur =
+        this.filters.statuses && this.filters.statuses.length ? this.filters.statuses : this.presentStatuses;
+      const next = cur.includes(status) ? cur.filter((x) => x !== status) : [...cur, status];
+      this.setFilters({ statuses: next });
+    },
+
+    toggleExpandGroup(gid: string) {
+      this.expandedGroups = {
+        ...this.expandedGroups,
+        [gid]: !this.expandedGroups[gid],
+      };
+    },
+
+    /**
+     * Seed the status filter from the data, once.
+     *
+     * Called when a payload lands. Does nothing if a selection already
+     * exists — an explicit `?status=` from the URL, or the user's own choice
+     * surviving a refresh — so this only ever supplies the first-paint
+     * default.
+     *
+     * `pendingLegacyStatuses` carries the intent of a pre-bp-67g.40 link:
+     * `?showClosed=true` has to end up selecting `closed` alongside the
+     * default set, and it cannot be honoured at URL-read time because the
+     * rest of that set is not known until the beads arrive.
+     */
+    initStatusSelection() {
+      if (this.filters.statuses !== null) return;
+      const present: string[] = [];
+      for (const b of this.beads) {
+        if (b.issue_type !== "epic") present.push(b.status);
+      }
+      const seeded = defaultStatusSelection(present, this.pendingLegacyStatuses ?? []);
+      if (seeded === null) return; // nothing to seed from yet
+      this.pendingLegacyStatuses = null;
+      this.filters = { ...this.filters, statuses: seeded };
+    },
+
+    /**
+     * Record which normally-hidden statuses a legacy URL asked for, to be
+     * applied by `initStatusSelection` once the data is known.
+     */
+    setPendingLegacyStatuses(statuses: string[]) {
+      this.pendingLegacyStatuses = statuses.length ? statuses : null;
+    },
+
+    setCurrentUser(handle: string | null) {
+      this.currentUser = handle;
+      // An explicit choice supersedes whatever the link carried in.
+      this.urlUser = null;
+      try {
+        if (handle) localStorage.setItem(CURRENT_USER_STORAGE_KEY, handle);
+        else localStorage.removeItem(CURRENT_USER_STORAGE_KEY);
+      } catch {
+        /* private mode — holds for this session only */
+      }
+    },
+
+    setWho(handle: string | null) {
+      this.who = handle;
+    },
+
+    // ── what-if (bp-q56) ─────────────────────────────────────────────────
+    addWhatIf(c: WhatIfChange) {
+      this.whatIfReport = null; // a new change supersedes the last confirm's report
+      this.whatIf = upsertChange(this.whatIf, c);
+      this.whatIfPanelOpen = true;
+    },
+
+    removeWhatIf(index: number) {
+      this.whatIf = this.whatIf.filter((_, i) => i !== index);
+    },
+
+    discardWhatIf() {
+      this.whatIf = [];
+      this.whatIfPanelOpen = false;
+    },
+
+    openWhatIfPanel() {
+      this.whatIfPanelOpen = true;
+    },
+
+    /**
+     * Close the panel. The last confirm's report goes with it: the panel
+     * stays mounted while a report exists, so a close that left the report
+     * behind left the panel behind too (owner, 2026-09-05). Staged changes
+     * stay — closing is not discarding.
+     */
+    closeWhatIfPanel() {
+      this.whatIfPanelOpen = false;
+      this.whatIfReport = null;
+    },
+
+    /**
+     * Confirm (bp-2fq): the change set becomes bd mutations, run one after
+     * another through /api/mutate — each is the same whitelisted write the
+     * quick actions use, so nothing new can be written from here. Every
+     * change gets a line in the report; a failure stops the batch there and
+     * leaves the rest staged for another try. Caps and unassigns are
+     * reported as not applied, with what to do by hand.
+     */
+    async confirmWhatIf() {
+      if (this.whatIfApplying || this.whatIf.length === 0) return;
+      this.whatIfApplying = true;
+      const titleOf = (id: string) => this.beadById(id)?.title;
+      const report: Array<{ text: string; ok: boolean; detail?: string }> = [];
+      const remaining: WhatIfChange[] = [];
+      const project = this.activeProject?.path ?? null;
+      const { skipped } = mutationsFor(this.whatIf);
+      for (const c of skipped) {
+        report.push({
+          text: describeChange(c, titleOf),
+          ok: false,
+          detail: c.kind === "cap" ? "not a bd fact: set it in .beadcyte/roster.json" : "bd has no unassign here: bd update <id> --assignee \"\"",
+        });
+      }
+      let stopped = false;
+      for (const c of this.whatIf) {
+        if (skipped.includes(c)) continue;
+        if (stopped) {
+          remaining.push(c);
+          continue;
+        }
+        const m = mutationsFor([c]).mutations[0]!;
+        try {
+          const res = await fetch("/api/mutate", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ ...m, project }),
+          });
+          const body = (await res.json().catch(() => ({}))) as { ok?: boolean; error?: string; bead?: Bead | null };
+          if (res.status === 404) throw new Error("this server predates quick actions — restart it");
+          if (!res.ok || !body.ok) throw new Error(body.error || `HTTP ${res.status}`);
+          report.push({ text: describeChange(c, titleOf), ok: true, detail: body.bead?.id && c.kind === "idea" ? `created ${body.bead.id}` : undefined });
+        } catch (e) {
+          report.push({ text: describeChange(c, titleOf), ok: false, detail: String((e as Error).message ?? e) });
+          remaining.push(c);
+          stopped = true;
+        }
+      }
+      this.whatIfReport = report;
+      this.whatIf = remaining;
+      this.whatIfApplying = false;
+      const okCount = report.filter((r) => r.ok).length;
+      this.notice = { kind: stopped ? "error" : "ok", text: `what-if: ${okCount} change${okCount === 1 ? "" : "s"} written${stopped ? ", stopped at a failure" : ""}${skipped.length ? `, ${skipped.length} not applicable` : ""}` };
+      setTimeout(() => {
+        if (this.notice) this.notice = null;
+      }, 6000);
+      void this.fetch();
+    },
+
+    /** Any assignee handle in the app leads here: incytes, scoped to that person. */
+    openPerson(handle: string) {
+      this.who = handle;
+      this.view = "incytes";
+    },
+
+    setUrlUser(handle: string | null) {
+      this.urlUser = handle;
+    },
+
+    /** Every filter back to its default; the status seed is recomputed from the data. */
+    resetFilters() {
+      const seeded = defaultStatusSelection(this.presentStatuses, []);
+      this.filters = { ...DEFAULT_FILTERS, statuses: seeded };
+    },
+
+    /**
+     * MINE shortcut (bp-egy). Replaces the whole filter state with the
+     * shortcut's; clicking the active one clears back to the defaults.
+     */
+    applyShortcut(kind: Shortcut) {
+      const me = this.effectiveUser;
+      if (!me) return;
+      if (this.activeShortcut === kind) {
+        this.resetFilters();
+        return;
+      }
+      this.filters = shortcutFilters(kind, me, this.presentStatuses);
+    },
+
+    setFilters(patch: Partial<Filters>) {
+      this.filters = { ...this.filters, ...patch };
+    },
+
+    setWindowFromPreset(preset: WindowPreset) {
+      this.window = windowFromPreset(preset);
+    },
+
+    setPriorityFilter(priorities: number[] | null) {
+      this.filters = { ...this.filters, priorities };
+    },
+
+    setWindow(w: WindowSpec) {
+      this.window = w;
+    },
+  },
+});