beadcyte 0.4.0

package/src/web/keybindings.ts

@@ -0,0 +1,200 @@
+// keybindings.ts — the one table of keyboard shortcuts (bp-67g.45).
+//
+// Everything the keyboard does is declared here and nowhere else: the
+// composable that listens (composables/useKeyboard.ts) matches against this
+// table, and the ? overlay (components/ShortcutsOverlay.vue) is generated
+// from it, so the guide cannot drift from the bindings.
+//
+// THE CURSOR (decided before any key was bound). There is no separate
+// "focused row". The keyboard cursor IS the open drawer: j and k move the
+// drawer to the next or previous bead in the active view's order, and open
+// it on the first or last bead when it is closed. Pin, copy and the subgraph
+// scope act on the open bead. Hover stays what it is — a transient tooltip —
+// and the views mark the open bead's row, so exactly one thing ever looks
+// selected. The app used to have a third notion, the Gantt's focus mode; it
+// was removed (bp-6tn), which is what made this reconciliation possible.
+//
+// THE CONVENTION. Single letters, no modifier — vim's j/k where the habit
+// exists, digits for the view tabs — because this is a tool people keep
+// open, and reaching for a chord every time is the tax that stops shortcuts
+// being used. The cost is collision with typing, so no binding fires while
+// an input, textarea, select or contenteditable has focus (isTypingTarget),
+// which also covers the search palette and the options menu's fields. The
+// only chord is ⌘K / Ctrl+K, kept because it is what every tool means by
+// "search"; / opens the same palette for the modifier-averse.
+
+export type KeyGroup =
+  | "View and navigation"
+  | "Drawer and selection"
+  | "Filters and toggles"
+  | "Appearance"
+  | "Search and help";
+
+export const KEY_GROUPS: readonly KeyGroup[] = [
+  "View and navigation",
+  "Drawer and selection",
+  "Filters and toggles",
+  "Appearance",
+  "Search and help",
+];
+
+export type KeyAction =
+  | "view-mine"
+  | "view-gantt"
+  | "view-grid"
+  | "view-table"
+  | "view-incytes"
+  | "cycle-group"
+  | "cycle-window"
+  | "today"
+  | "next-bead"
+  | "prev-bead"
+  | "open-first"
+  | "close"
+  | "toggle-watch"
+  | "toggle-scope"
+  | "copy-id"
+  | "actions"
+  | "hl-blocked"
+  | "hl-over-cap"
+  | "hl-ready-now"
+  | "toggle-deps"
+  | "clear-filters"
+  | "toggle-closed"
+  | "cycle-theme"
+  | "cycle-style"
+  | "options"
+  | "search"
+  | "help";
+
+/** A key as KeyboardEvent.key reports it, plus the modifiers that must be held. */
+export interface KeyChord {
+  key: string;
+  ctrl?: boolean;
+  meta?: boolean;
+}
+
+export interface KeyBinding {
+  action: KeyAction;
+  chords: readonly KeyChord[];
+  label: string;
+  group: KeyGroup;
+}
+
+export const KEYBINDINGS: readonly KeyBinding[] = [
+  // ── View and navigation ──────────────────────────────────────────────────
+  { action: "view-mine", chords: [{ key: "1" }], label: "mine view", group: "View and navigation" },
+  { action: "view-gantt", chords: [{ key: "2" }], label: "gantt view", group: "View and navigation" },
+  { action: "view-grid", chords: [{ key: "3" }], label: "grid view", group: "View and navigation" },
+  { action: "view-table", chords: [{ key: "4" }], label: "table view", group: "View and navigation" },
+  { action: "view-incytes", chords: [{ key: "5" }], label: "incytes view", group: "View and navigation" },
+  { action: "cycle-group", chords: [{ key: "g" }], label: "cycle group by", group: "View and navigation" },
+  { action: "cycle-window", chords: [{ key: "w" }], label: "cycle the window preset", group: "View and navigation" },
+  { action: "today", chords: [{ key: "t" }], label: "back to today: the ±90d window, scrolled to today", group: "View and navigation" },
+  { action: "next-bead", chords: [{ key: "j" }], label: "next bead — moves the drawer down the view", group: "View and navigation" },
+  { action: "prev-bead", chords: [{ key: "k" }], label: "previous bead", group: "View and navigation" },
+  // ── Drawer and selection ─────────────────────────────────────────────────
+  { action: "open-first", chords: [{ key: "Enter" }], label: "open the drawer on the first bead in view", group: "Drawer and selection" },
+  { action: "close", chords: [{ key: "Escape" }], label: "close: a menu, this overlay, the changelog, the drawer, then the walkthrough", group: "Drawer and selection" },
+  { action: "toggle-watch", chords: [{ key: "p" }], label: "pin / unpin the open bead (watch list)", group: "Drawer and selection" },
+  { action: "toggle-scope", chords: [{ key: "s" }], label: "subgraph scope: this bead / whole epic", group: "Drawer and selection" },
+  { action: "copy-id", chords: [{ key: "c" }], label: "copy the open bead's id", group: "Drawer and selection" },
+  { action: "actions", chords: [{ key: "a" }], label: "actions on the open bead: claim, assign, spec:ready, label, defer", group: "Drawer and selection" },
+  // ── Filters and toggles ──────────────────────────────────────────────────
+  { action: "hl-blocked", chords: [{ key: "b" }], label: "highlight blocked", group: "Filters and toggles" },
+  { action: "hl-over-cap", chords: [{ key: "o" }], label: "highlight over-cap", group: "Filters and toggles" },
+  { action: "hl-ready-now", chords: [{ key: "r" }], label: "highlight ready-now", group: "Filters and toggles" },
+  { action: "toggle-deps", chords: [{ key: "d" }], label: "dependency arrows", group: "Filters and toggles" },
+  { action: "clear-filters", chords: [{ key: "x" }], label: "clear all filters", group: "Filters and toggles" },
+  { action: "toggle-closed", chords: [{ key: "z" }], label: "show / hide closed beads", group: "Filters and toggles" },
+  // ── Appearance ───────────────────────────────────────────────────────────
+  { action: "cycle-theme", chords: [{ key: "m" }], label: "cycle light / dark / system", group: "Appearance" },
+  { action: "cycle-style", chords: [{ key: "y" }], label: "cycle the named style", group: "Appearance" },
+  { action: "options", chords: [{ key: "," }], label: "open the options menu", group: "Appearance" },
+  // ── Search and help ──────────────────────────────────────────────────────
+  { action: "search", chords: [{ key: "k", meta: true }, { key: "k", ctrl: true }, { key: "/" }], label: "search", group: "Search and help" },
+  { action: "help", chords: [{ key: "?" }], label: "this overlay", group: "Search and help" },
+];
+
+/** The convention, stated once, for the overlay to print. */
+export const KEY_CONVENTION =
+  "Single letters, no modifier. Nothing fires while you are typing in a field. ⌘K / Ctrl+K is the one chord, because that is what every tool means by search.";
+
+export interface KeyEventLike {
+  key: string;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  altKey: boolean;
+}
+
+/**
+ * The binding this key event triggers, or null. `key` is compared as the
+ * browser reports it, so "?" and "J" already carry their shift; ctrl and meta
+ * must match the chord exactly, and alt never matches anything — an
+ * alt-letter is the browser's or the OS's.
+ */
+export function matchBinding(e: KeyEventLike): KeyBinding | null {
+  if (e.altKey) return null;
+  for (const b of KEYBINDINGS) {
+    for (const c of b.chords) {
+      if (c.key === e.key && !!c.ctrl === e.ctrlKey && !!c.meta === e.metaKey) return b;
+    }
+  }
+  return null;
+}
+
+export interface TargetLike {
+  tagName?: string;
+  isContentEditable?: boolean;
+}
+
+/** Is the key going into a field? Then it is text, not a command. */
+export function isTypingTarget(t: TargetLike | null | undefined): boolean {
+  if (!t) return false;
+  const tag = (t.tagName ?? "").toUpperCase();
+  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || t.isContentEditable === true;
+}
+
+const KEY_NAMES: Record<string, string> = {
+  Escape: "Esc",
+  Enter: "Enter",
+  " ": "Space",
+  ArrowUp: "↑",
+  ArrowDown: "↓",
+};
+
+/** "⌘K" on a Mac, "Ctrl+K" elsewhere, "?" for a plain key. */
+export function formatChord(c: KeyChord, mac: boolean): string {
+  const name = KEY_NAMES[c.key] ?? (c.key.length === 1 ? c.key.toUpperCase() : c.key);
+  const mods: string[] = [];
+  if (c.meta) mods.push(mac ? "⌘" : "Meta+");
+  if (c.ctrl) mods.push(mac ? "⌃" : "Ctrl+");
+  return mods.join("") + name;
+}
+
+/**
+ * The chords to SHOW for a binding on this platform: the meta chord on a
+ * Mac, the ctrl chord elsewhere, never both — the other one still works.
+ */
+export function chordsToShow(b: KeyBinding, mac: boolean): KeyChord[] {
+  return b.chords.filter((c) => !(mac ? c.ctrl : c.meta));
+}
+
+/** The table grouped for the overlay, in declared order within each group. */
+export function bindingsByGroup(): Array<{ group: KeyGroup; bindings: KeyBinding[] }> {
+  return KEY_GROUPS.map((group) => ({ group, bindings: KEYBINDINGS.filter((b) => b.group === group) }));
+}
+
+/**
+ * Where the cursor goes. With nothing open (or the open bead not in view),
+ * a step down lands on the first bead and a step up on the last; otherwise
+ * it moves and stops at the ends rather than wrapping — wrapping is how a
+ * held key laps the list without the reader noticing.
+ */
+export function nextCursor(order: readonly string[], current: string | null, delta: number): string | null {
+  if (order.length === 0) return null;
+  const i = current ? order.indexOf(current) : -1;
+  if (i < 0) return delta > 0 ? order[0] : order[order.length - 1];
+  const n = Math.min(order.length - 1, Math.max(0, i + delta));
+  return order[n];
+}

package/src/web/load-meter.ts

@@ -0,0 +1,72 @@
+// load-meter.ts — how far along a load appears to be.
+//
+// There is no real progress to report. Measured on a 558-bead repo, the
+// `bd` subprocess is ~860ms of a ~945ms load — about 90% — and it emits
+// nothing while it runs. `bd list --json` produces one blob with no
+// incremental mode, and pre-counting with `bd stats` measured 1.02s against
+// the 0.86s fetch it would describe, so buying a count costs more than the
+// thing being measured.
+//
+// So the only honest determinate signal is HISTORY: how long this same
+// project took last time. That makes the bar an estimate, and it has to
+// behave like one — labelled as such, and degrading to indeterminate when
+// the run outlasts the expectation instead of parking at 99% and lying.
+
+/** Never claim completion from an estimate; the response decides that. */
+export const MAX_ESTIMATED_PCT = 92;
+
+export interface MeterState {
+  /** 'determinate' only when a prior measurement exists AND still holds. */
+  mode: "determinate" | "indeterminate";
+  /** 0-92 when determinate; null otherwise. */
+  pct: number | null;
+  /** True once the load has outlasted its estimate. */
+  overrun: boolean;
+}
+
+export function meterState(
+  elapsedMs: number,
+  expectedMs: number | null,
+): MeterState {
+  const elapsed = Number.isFinite(elapsedMs) && elapsedMs > 0 ? elapsedMs : 0;
+
+  // No history, or a nonsense history, means no honest percentage.
+  if (
+    expectedMs === null ||
+    !Number.isFinite(expectedMs) ||
+    expectedMs <= 0
+  ) {
+    return { mode: "indeterminate", pct: null, overrun: false };
+  }
+
+  if (elapsed >= expectedMs) {
+    // The estimate has been disproved by the run itself. Stop pretending to
+    // know and say so, rather than creeping toward a completion we can't
+    // observe.
+    return { mode: "indeterminate", pct: null, overrun: true };
+  }
+
+  return {
+    mode: "determinate",
+    pct: Math.min(MAX_ESTIMATED_PCT, (elapsed / expectedMs) * 100),
+    overrun: false,
+  };
+}
+
+/** "1.4s" / "820ms" — the elapsed counter that runs regardless of mode. */
+export function formatElapsed(ms: number): string {
+  if (!Number.isFinite(ms) || ms < 0) return "0ms";
+  return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+/** "updated 12s ago" / "updated 4m ago". Null when never loaded. */
+export function formatAge(ms: number | null): string | null {
+  if (ms === null || !Number.isFinite(ms) || ms < 0) return null;
+  const s = Math.floor(ms / 1000);
+  if (s < 5) return "updated just now";
+  if (s < 60) return `updated ${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `updated ${m}m ago`;
+  const h = Math.floor(m / 60);
+  return h < 24 ? `updated ${h}h ago` : `updated ${Math.floor(h / 24)}d ago`;
+}

package/src/web/main.ts

@@ -0,0 +1,20 @@
+// Import order IS the cascade: tokens define, styles-alt overrides per
+// family, app.css sets globals, and component <style> blocks land after
+// these because their modules load later.
+import "./tokens.css";
+import "./styles-alt.css";
+import "./styles-ported.css";
+import "./app.css";
+
+import { createApp } from "vue";
+import { createPinia } from "pinia";
+import App from "./App.vue";
+import { useTheme } from "./composables/useTheme";
+
+// Sync Vue's reactive theme state with what index.html's pre-paint script
+// already put on <html>.
+useTheme().init();
+
+const app = createApp(App);
+app.use(createPinia());
+app.mount("#app");

package/src/web/markdown.ts

@@ -0,0 +1,14 @@
+// markdown.ts — the one markdown renderer (bp-67g.46).
+//
+// Bead descriptions and the changelog both come from trusted local sources
+// — our own bd DB, and a file generated from it and shipped in the package —
+// so marked runs with no sanitizer between it and v-html. If either source
+// ever becomes untrusted, DOMPurify goes HERE, once, not in each consumer.
+
+import { marked } from "marked";
+
+marked.setOptions({ gfm: true, breaks: false });
+
+export function renderMarkdown(src: string): string {
+  return marked.parse(src) as string;
+}

package/src/web/mine.ts

@@ -0,0 +1,137 @@
+// mine.ts — the sections of the "mine" view (bp-egy): what should I be
+// doing, and what is going on around my work.
+//
+// Everything here is about one person, the current user, and is a list, not
+// a chart: several small sets at once, which no single filter on the Gantt or
+// grid can show together. The readiness rule is highlights.ts's, shared with
+// the ready-now overlay and the MINE quick filters; this module only adds the
+// "whose" clauses and the relationships the filters cannot express — who is
+// holding the bead that blocks yours, and whose work you are holding up.
+//
+// "Assigned to me" means the bead's own assignee field. The scheduler's
+// inferred assignments appear separately as suggestions, marked as such,
+// because a guess about who might take a bead is not the same as a bead that
+// is yours.
+//
+// Pure: beads in, sections out. No store, no DOM.
+
+import type { Bead } from "./store";
+import type { Schedule } from "./view-model";
+import type { TriageResult } from "./triage";
+import { FINISHED_STATUSES, hasOpenBlocker, isReadyCore } from "./highlights.ts";
+
+/** A bead that stands in the way of one of mine, and who holds it. */
+export interface BlockerRef {
+  id: string;
+  title: string;
+  status: string;
+  holder: string | null;
+}
+
+/** One of my live beads that cannot move yet. */
+export interface WaitingItem {
+  bead: Bead;
+  blockers: BlockerRef[];
+}
+
+/** Someone else's live bead that one of mine is holding up. */
+export interface HoldingItem {
+  bead: Bead;
+  /** My open beads it depends on. */
+  via: Bead[];
+}
+
+export interface MineModel {
+  /** Assigned to me, approved, not already moving, every blocker closed. */
+  ready: Bead[];
+  /** Unassigned and ready, and the scheduler would route them to me. */
+  suggested: Bead[];
+  inProgress: Bead[];
+  inReview: Bead[];
+  /** My live beads with an open blocker, and who holds each blocker. */
+  waitingOnOthers: WaitingItem[];
+  /** Other people's live beads blocked by an open bead of mine. */
+  waitingOnMe: HoldingItem[];
+  /** The watch list, in watch order, whatever the status. */
+  watching: Bead[];
+}
+
+export interface MineOptions {
+  schedule?: Schedule | null;
+  triage?: Map<string, TriageResult> | null;
+  watched?: readonly string[] | null;
+}
+
+const isEpic = (b: Bead) => b.issue_type === "epic";
+const isLive = (b: Bead) => !FINISHED_STATUSES.includes(b.status);
+
+export function buildMineModel(
+  beads: Bead[],
+  me: string,
+  opts: MineOptions = {},
+): MineModel {
+  const byId = new Map(beads.map((b) => [b.id, b] as const));
+  const triage = opts.triage ?? null;
+  const schedule = opts.schedule ?? null;
+
+  // Priority first (P0 before P4, unset counts as P4), then triage score,
+  // then id so the order is stable when neither separates two beads.
+  const byUrgency = (a: Bead, b: Bead) => {
+    const pa = a.priority ?? 4;
+    const pb = b.priority ?? 4;
+    if (pa !== pb) return pa - pb;
+    const ta = triage?.get(a.id)?.score ?? 0;
+    const tb = triage?.get(b.id)?.score ?? 0;
+    if (ta !== tb) return tb - ta;
+    return a.id.localeCompare(b.id);
+  };
+  // Most recently touched first, for the sets that are already moving.
+  const byRecency = (a: Bead, b: Bead) => b.updated_at.localeCompare(a.updated_at) || a.id.localeCompare(b.id);
+
+  const mine = beads.filter((b) => !isEpic(b) && b.assignee === me);
+
+  const ready = mine.filter((b) => isReadyCore(b, byId)).sort(byUrgency);
+  const inProgress = mine.filter((b) => b.status === "in_progress").sort(byRecency);
+  const inReview = mine.filter((b) => b.status === "in_review").sort(byRecency);
+
+  const suggested = beads
+    .filter(
+      (b) =>
+        !isEpic(b) &&
+        !b.assignee &&
+        schedule?.get(b.id)?.synthetic_assignee === true &&
+        schedule?.get(b.id)?.assignee === me &&
+        isReadyCore(b, byId),
+    )
+    .sort(byUrgency);
+
+  const waitingOnOthers: WaitingItem[] = mine
+    .filter((b) => isLive(b) && hasOpenBlocker(b, byId))
+    .sort(byUrgency)
+    .map((bead) => ({
+      bead,
+      blockers: (bead.dependencies ?? [])
+        .filter((d) => d.type === "blocks")
+        .map((d) => byId.get(d.depends_on_id))
+        .filter((dep): dep is Bead => !!dep && dep.status !== "closed")
+        .map((dep) => ({ id: dep.id, title: dep.title, status: dep.status, holder: dep.assignee })),
+    }));
+
+  const waitingOnMe: HoldingItem[] = beads
+    .filter((b) => !isEpic(b) && b.assignee !== me && isLive(b))
+    .map((bead) => ({
+      bead,
+      via: (bead.dependencies ?? [])
+        .filter((d) => d.type === "blocks")
+        .map((d) => byId.get(d.depends_on_id))
+        .filter((dep): dep is Bead => !!dep && dep.assignee === me && dep.status !== "closed"),
+    }))
+    .filter((h) => h.via.length > 0)
+    .sort((a, b) => byUrgency(a.bead, b.bead));
+
+  const watching = (opts.watched ?? [])
+    .map((id) => byId.get(id))
+    .filter((b): b is Bead => !!b);
+
+  return { ready, suggested, inProgress, inReview, waitingOnOthers, waitingOnMe, watching };
+}

package/src/web/mutations.ts

@@ -0,0 +1,21 @@
+// mutations.ts — the client side of writing to the tracker (bp-ocs). The
+// whitelist, the argv and the optimistic patch are src/mutate.mjs's, shared
+// with the server; this file only types them for the app.
+
+import { applyOptimistic, describeMutation, describeOutcome, DEFER_CHOICES, READY_LABEL, MUTATION_ACTIONS } from "../mutate.mjs";
+
+export type MutationAction = (typeof MUTATION_ACTIONS)[number];
+
+export interface Mutation {
+  action: MutationAction;
+  id: string;
+  label?: string;
+  until?: string;
+  assignee?: string;
+  priority?: number;
+  title?: string;
+  type?: string;
+  labels?: string[];
+}
+
+export { applyOptimistic, describeMutation, describeOutcome, DEFER_CHOICES, READY_LABEL, MUTATION_ACTIONS };

package/src/web/person.ts

@@ -0,0 +1,102 @@
+// person.ts — one person's picture, for the incytes view (bp-67g.43).
+//
+// The mine view answers "what should I be doing" for the current user with
+// actionable lists. This answers "how is this person doing, and what is on
+// their plate" for ANYONE, from the project's angle, and it reuses what the
+// app already computes rather than growing person-shaped copies:
+//
+//   - the ship trend is the person's weekly series from computeVelocity, in
+//     the project's buckets, through the same shipTrend() the project uses;
+//   - progress is projectGroups() over the beads recorded as theirs;
+//   - current, ready and likely-next come from buildMineModel() for that
+//     handle — the same rules the mine view applies to you — and "likely
+//     next" is exactly the scheduler's affinity routing (synthetic), shown
+//     as a projection, never as work they have;
+//   - roster details are what calibrateRoster stashed: the raw cap, the
+//     calibrated cap and the derivation string, and whether the roster was
+//     authored or derived from assignees.
+//
+// Pure: the shapes and the sentences are testable without a store.
+
+import type { Bead } from "./store";
+import { buildMineModel, type MineModel, type MineOptions } from "./mine.ts";
+import { shipTrend, type ShipTrend, type ShipWeekPoint } from "./insights.ts";
+
+export interface RosterHumanLike {
+  handle: string;
+  cap?: number;
+  labels?: string[];
+  areas?: string[];
+  _rawCap?: number;
+  _closesPerWeek?: number;
+  _hoursPerWeek?: number;
+  _closedInWindow?: number;
+  _capDerivation?: string;
+}
+
+export interface PersonRoster {
+  handle: string;
+  cap: number | null;
+  rawCap: number | null;
+  /** "Little: 4.4/wk × 2.4d" or "raw (no history)", as calibrateRoster wrote it. */
+  derivation: string | null;
+  closesPerWeek: number;
+  hoursPerWeek: number;
+  closedInWindow: number;
+  labels: string[];
+  areas: string[];
+  /** True when nobody wrote a roster: the caps are defaults, not decisions. */
+  derivedRoster: boolean;
+}
+
+export function personRoster(handle: string, roster: { humans?: RosterHumanLike[]; _derived?: boolean } | null): PersonRoster {
+  const h = roster?.humans?.find((x) => x.handle === handle);
+  return {
+    handle,
+    cap: h?.cap ?? null,
+    rawCap: h?._rawCap ?? h?.cap ?? null,
+    derivation: h?._capDerivation ?? null,
+    closesPerWeek: h?._closesPerWeek ?? 0,
+    hoursPerWeek: h?._hoursPerWeek ?? 0,
+    closedInWindow: h?._closedInWindow ?? 0,
+    labels: h?.labels ?? [],
+    areas: h?.areas ?? [],
+    derivedRoster: !!roster?._derived,
+  };
+}
+
+/** "cap 5 → 1 (Little: 4.4/wk × 2.4d)", "cap 5 (raw, no history)", or "no cap on record". */
+export function describeCap(r: PersonRoster): string {
+  if (r.cap === null) return "no cap on record";
+  const moved = r.rawCap !== null && r.rawCap !== r.cap;
+  const how = r.derivation ? ` (${r.derivation})` : "";
+  return moved ? `cap ${r.rawCap} → ${r.cap}${how}` : `cap ${r.cap}${how}`;
+}
+
+/** The sentence the pane prints about where the roster came from. */
+export function rosterProvenanceNote(r: PersonRoster): string {
+  return r.derivedRoster
+    ? "No roster file: this person was derived from bead assignees, so the cap is a default and the affinities are empty — nobody decided them."
+    : "From .beadcyte/roster.json — the cap and affinities were authored.";
+}
+
+/** The person's ship trend, or null when velocity has never seen them ship. */
+export function personShipTrend(
+  handle: string,
+  velocity: { weekly: ShipWeekPoint[]; perHuman: Map<string, { weekly?: number[] }> } | null,
+): ShipTrend | null {
+  if (!velocity) return null;
+  const mine = velocity.perHuman.get(handle)?.weekly;
+  if (!mine) return null;
+  return shipTrend(velocity.weekly.map((w, i) => ({ weekStart: w.weekStart, count: mine[i] ?? 0 })));
+}
+
+/** The beads recorded as this person's — real assignments, not the scheduler's guesses. */
+export function beadsAssignedTo(beads: readonly Bead[], handle: string): Bead[] {
+  return beads.filter((b) => b.assignee === handle);
+}
+
+/** Current, ready and likely-next, by the mine view's own rules, for anyone. */
+export function personWork(beads: Bead[], handle: string, opts: MineOptions): MineModel {
+  return buildMineModel(beads, handle, opts);
+}

package/src/web/projects-text.ts

@@ -0,0 +1,15 @@
+// projects-text.ts — how a server refusal is phrased for a person.
+//
+// The server returns codes (src/projects.mjs REFUSAL) so the wording lives
+// with the UI rather than in the API. Each says what to do about it, not
+// just what went wrong — the user typed a path and needs to know whether to
+// fix the path, pick a different directory, or check permissions.
+
+export const REFUSAL_TEXT: Record<string, string> = {
+  "not-absolute": "Use an absolute path, starting with /.",
+  missing: "Nothing exists at that path.",
+  "not-a-directory": "That's a file, not a directory.",
+  "no-beads":
+    "No .beads directory here — this isn't a beads project. Try the repo root.",
+  "not-readable": "That directory isn't readable by the server process.",
+};