@bongos/core 1.19.375 → 1.19.376

package/migrations/core_227_task_created_by.sql

@@ -0,0 +1,83 @@
+-- core_227_task_created_by.sql — a task remembers who created it (task 1003278,
+-- goal 1000072, criterion legibility-sort-and-staleness).
+--
+-- THE GAP. "You can find your own work" was impossible on the task tier: tasks
+-- carried source/source_ref (which PIPELINE filed it) and shipped_by (who landed
+-- it), but nothing said which PERSON created it. A goal has had created_by since
+-- migration 160; a task had nothing, so the owner could not ask the board "what
+-- did I create" — one of the exact questions goal 1000072 exists to answer.
+--
+-- NULLABLE, NO BACKFILL, ON PURPOSE. History is honestly unattributable: the
+-- ~1,357 existing BONGOS-V1 tasks were created before this column, and guessing
+-- (from shipped_by, from a claim, from the source string) would write confident
+-- lies into an attribution column. NULL = created before attribution existed, or
+-- by a system path with no builder in the request — the same convention as
+-- goals.created_by (migration 160: "NULL = system-attributed"). The UI's filter
+-- gets a 'system / unattributed' bucket, exactly like the goals owner filter.
+--
+-- Additive + forward-safe: every existing reader either SELECTs an explicit
+-- column list or `t.*` (which tolerates a new column); nothing NOT NULL, nothing
+-- renamed (tests/migrations_forward_safe.mjs).
+--
+-- THE VIEWS MUST BE REBUILT WITH IT. A Postgres view created with `SELECT t.*`
+-- pins its column list at CREATE VIEW time — core_190's own header documents six
+-- columns that silently never reached the claim feed this way, and the Work
+-- Board's Creator filter reads created_by off exactly that feed. So this
+-- migration re-runs core_190's DROP+CREATE verbatim (no WHERE/CASE change), the
+-- same way core_190 itself repaired the 044-era views.
+
+BEGIN;
+
+ALTER TABLE tasks
+  ADD COLUMN IF NOT EXISTS created_by bigint REFERENCES builders(id);
+
+COMMENT ON COLUMN tasks.created_by IS
+  'The builder who created this task (task 1003278). NULL = created before attribution existed, or by a system path with no builder in the request — never backfilled, because a guessed attribution is a confident lie. The goals.created_by convention (migration 160).';
+
+CREATE INDEX IF NOT EXISTS idx_tasks_created_by ON tasks (created_by);
+
+-- Rebuild the two t.* views so created_by is projected (bodies identical to
+-- core_190 — the wildcard re-expands to every current column).
+
+DROP VIEW IF EXISTS claimable_tasks;
+CREATE VIEW claimable_tasks AS
+SELECT t.*,
+       pms_calibrated_minutes(t.est_minutes, t.kind) AS est_minutes_calibrated
+  FROM tasks t
+ WHERE t.status = 'ready'
+   AND t.title NOT LIKE '\_\_smoke\_\_%' ESCAPE '\'
+   AND NOT EXISTS (
+     SELECT 1 FROM task_blockers tb WHERE tb.task_id = t.id
+   )
+   AND NOT EXISTS (
+     SELECT 1 FROM claims c
+       JOIN tasks t2 ON t2.id = c.task_id
+      WHERE c.released_at IS NULL
+        AND t2.touches && t.touches
+   );
+
+DROP VIEW IF EXISTS tasks_session_fit;
+CREATE VIEW tasks_session_fit AS
+SELECT t.*,
+  CASE
+    WHEN t.automation_tag = 'overnight-safe' AND COALESCE(t.manual_degree, 5) <= 2
+         AND NOT EXISTS (SELECT 1 FROM task_blockers tb WHERE tb.task_id = t.id)
+      THEN ARRAY['autonomous','check-in','active']
+    WHEN t.automation_tag = 'live-only' OR COALESCE(t.manual_degree, 5) >= 4
+      THEN ARRAY['active']
+    ELSE ARRAY['check-in','active']
+  END AS fits_session_modes,
+  pms_calibrated_minutes(t.est_minutes, t.kind) AS est_minutes_calibrated,
+  CASE
+    WHEN t.credits_reward > 0
+     AND pms_calibrated_minutes(t.est_minutes, t.kind) IS NOT NULL
+     AND pms_calibrated_minutes(t.est_minutes, t.kind) > 0
+    THEN ROUND(t.credits_reward::numeric / pms_calibrated_minutes(t.est_minutes, t.kind), 3)
+    ELSE NULL
+  END AS credits_per_minute
+FROM tasks t;
+
+COMMIT;
+
+INSERT INTO schema_migrations (version) VALUES ('core_227_task_created_by')
+ON CONFLICT (version) DO NOTHING;

package/modules/dev-box/app/src/vendor/bongos-client.cjs

@@ -366,6 +366,8 @@ function createClient(opts = {}) {
       getGoalsInbox: (args) => request("GET", "/goals/inbox", { hasBody: false }, args),
       // POST /goals/reorder — rank: metic+archon — POST /goals/reorder
       postGoalsReorder: (args) => request("POST", "/goals/reorder", { hasBody: true }, args),
+      // GET /goals/rollups — rank: any-builder — GET /goals/rollups
+      getGoalsRollups: (args) => request("GET", "/goals/rollups", { hasBody: false }, args),
       // GET /goals/suggestions — rank: any-builder — GET /goals/suggestions
       getGoalsSuggestions: (args) => request("GET", "/goals/suggestions", { hasBody: false }, args),
     },

package/modules/hall-ui/public/goals-lib.js

@@ -84,11 +84,11 @@
     return false;
   }
 
-  // ms helpers for the goal ordering (task 1002965): updated_at moves on every
-  // task write, shipped_at folded in because a ship path can stamp it without
-  // touching updated_at.
-  const msOf = (iso) => { const t = iso ? Date.parse(iso) : NaN; return Number.isNaN(t) ? 0 : t; };
-  const taskActivityMs = (t) => Math.max(msOf(t.updated_at), msOf(t.shipped_at));
+  // ms helpers for the goal ordering (task 1002965). The DEFINITIONS moved to
+  // task-lib.js in task 1003278 so the Tasks board and the Goals page read ONE
+  // meaning of "touched"; re-exported here so this lib's API is unchanged.
+  // goals.html loads task-lib.js before this file (the render-family order).
+  const { msOf, taskActivityMs } = window.OTBTaskLib;
 
   // task 1003224 — on a LIST, a goal's subtitle is a TOOLTIP, never a second
   // visible line. The board's job there is to let someone find a goal by name;

package/modules/hall-ui/public/goals-page.js

@@ -144,37 +144,60 @@
   // Array#sort is stable in every browser this hall supports — so goals sharing
   // a timestamp (or both missing one) keep their priority order as the tiebreak.
 
-  // Fetch every task for the versions the goals span (one request each, with dep
-  // summaries) and fold into per-goal rollups. Failure-tolerant: an older server
-  // that doesn't honor include=deps just yields empty rollups and the list falls
-  // back to plain cards. Tasks come back priority-ordered, so the first `ready`
-  // one is the goal's best next pick.
+  // Per-goal rollups: readiness counters, the last-activity timestamp, and the
+  // craft set. Since task 1003278 the SERVER computes these (GET /goals/rollups),
+  // one small row per goal.
+  //
+  // WHY IT MOVED, in one number. This used to fetch every task in every version
+  // the board spans — `GET /tasks?version=…&include=deps` — and reduce them here.
+  // On the real corpus that single request measured **5,229,455 bytes for ~1,400
+  // tasks** (2026-08-25) to produce about forty counter objects. The criterion
+  // this page serves says it plainly: "~1,357 tasks on BONGOS-V1 alone. A view
+  // that does not survive that number is not a solution." It did not survive it;
+  // it just did not visibly fall over.
+  //
+  // The buckets, the activity clock and the next-ready pick are unchanged — the
+  // SQL mirrors goals-lib.js `readinessOf` exactly, and a test holds the two
+  // against each other, because a divergence would show a person different
+  // numbers depending on which surface they opened.
+  //
+  // Failure-tolerant, and deliberately NOT falling back to the old whole-version
+  // fetch: a "fallback" that quietly re-downloads 5 MB is the bug wearing a
+  // safety belt. An older server yields empty rollups and the cards render plain.
   async function loadRollups() {
     const versions = [...new Set(state.goals.map((g) => g.version_id).filter(Boolean))];
     const lists = await Promise.all(versions.map((v) =>
-      getJSON(`${API}/tasks?version=${encodeURIComponent(v)}&include=deps`)
-        .then((r) => r.tasks || []).catch(() => [])));
+      getJSON(`${API}/goals/rollups?version=${encodeURIComponent(v)}`)
+        .then((r) => r.rollups || []).catch(() => [])));
     const roll = new Map();
     const activity = new Map();
-    for (const t of lists.flat()) {
-      if (t.goal_id == null) continue;
-      const key = String(t.goal_id);
-      let r = roll.get(key);
-      if (!r) { r = { done: 0, active: 0, ready: 0, blocked: 0, backlog: 0, cut: 0, total: 0, nextReady: null }; roll.set(key, r); }
-      const bucket = readinessOf(t);
-      r[bucket] += 1;
-      if (bucket !== 'cut') r.total += 1;
-      if (bucket === 'ready' && !r.nextReady) r.nextReady = t;
-      // task 1002965 — ANY task activity counts (owner call), not just ships: a
-      // goal being worked right now should read as active before anything lands.
-      // updated_at moves on every task write (claim, status flip, edit), so it
-      // dominates in practice; shipped_at is folded in because a task can be
-      // shipped by a path that stamps it without touching updated_at.
-      const ts = taskActivityMs(t);
-      if (ts && ts > (activity.get(key) || 0)) activity.set(key, ts);
+    const disciplines = new Map(); // task 1003278 — goalId -> Set(craft)
+    for (const row of lists.flat()) {
+      const key = String(row.goal_id);
+      roll.set(key, {
+        done: row.done || 0,
+        active: row.active || 0,
+        ready: row.ready || 0,
+        blocked: row.blocked || 0,
+        backlog: row.backlog || 0,
+        cut: row.cut || 0,
+        total: row.total || 0,
+        // The row shape the renderers already expect: `nextReady` is a task-like
+        // object with an id and a title, and nothing else was ever read off it.
+        nextReady: row.next_ready_id ? { id: row.next_ready_id, title: row.next_ready_title } : null,
+      });
+      const ts = msOf(row.last_activity_at);
+      if (ts) activity.set(key, ts);
+      // The goal's CRAFT set. "Role" here is the craft axis ADR 0174 reserves the
+      // word for (engineer | artist | ideator | ui), never a goal membership —
+      // that is `membership_kind` (ADR 0177). A goal has no discipline column and
+      // must not get one: its craft set is what its tasks carry, which is why the
+      // server aggregates it rather than the goal row storing it.
+      disciplines.set(key, new Set(row.disciplines || []));
     }
     state.rollups = roll;
     state.activity = activity;
+    state.disciplines = disciplines;
   }
 
   /* ---------------- list view ---------------- */
@@ -893,6 +916,14 @@
       // task 1003276 — filled from GET /work-categories after boot
       // (populateCategoryFilter), the populateOwnerFilter pattern.
       { id: 'f-goal-category', label: 'Category', options: [{ value: '', label: '— any —' }] },
+      // task 1003278 — the craft axis (ADR 0174 reserves "role" for the crafts;
+      // a goal membership is a membership_kind, ADR 0177). Values are the
+      // disciplines a goal's tasks carry, derived in loadRollups. Staleness
+      // buckets are the shared STALE_CHOICES from task-lib.js so this page and
+      // the Tasks board offer the same lenses.
+      { id: 'f-goal-role', label: 'Craft', options: [ // ADR 0174: "role" means a craft
+        { value: '', label: '— any —' }, 'engineer', 'artist', 'ideator', 'ui'] },
+      { id: 'f-goal-stale', label: 'Age', options: window.OTBTaskLib.STALE_CHOICES },
       { id: 'f-goal-order',
         label: 'Sort',
         value: GOAL_SORTS[savedGoalSort] ? savedGoalSort : undefined,

package/modules/hall-ui/public/goals-render.js

@@ -60,6 +60,9 @@
     newest: { label: 'newest first', cmp: (a, b) => goalCreatedMs(b) - goalCreatedMs(a), stamp: (g) => ({ label: 'created', ms: goalCreatedMs(g) }) },
     oldest: { label: 'oldest first', cmp: (a, b) => goalCreatedMs(a) - goalCreatedMs(b), stamp: (g) => ({ label: 'created', ms: goalCreatedMs(g) }) },
     active: { label: 'recently active', cmp: (a, b) => goalActivityMs(b) - goalActivityMs(a), stamp: (g) => ({ label: 'last work', ms: goalActivityMs(g) }) },
+    // task 1003278 — the rot view: least-recently-touched first, on the SAME
+    // clock as 'recently active' so the two can never disagree.
+    stale: { label: 'stalest first', cmp: (a, b) => goalActivityMs(a) - goalActivityMs(b), stamp: (g) => ({ label: 'last work', ms: goalActivityMs(g) }) },
   };
   const currentGoalSort = () => GOAL_SORTS[$('#f-goal-order')?.value] || GOAL_SORTS.priority;
   function sortGoals(rows) {
@@ -93,6 +96,16 @@
       || (owner === 'none' ? g.created_by == null : String(g.created_by) === owner);
     const matchesCategory = (g) => !cat
       || (cat === 'none' ? !g.category : (g.category?.slug === cat));
+    // task 1003278 — role + staleness. A goal's role is the discipline set its
+    // tasks carry (loadRollups derives it from the per-version task fetch); its
+    // clock is the same activity timestamp the 'recently active' sort reads, so
+    // sorting and filtering can never disagree about what "touched" means.
+    const role = $('#f-goal-role')?.value || '';
+    const staleDays = $('#f-goal-stale')?.value || '';
+    const { isStale } = window.OTBTaskLib;
+    const matchesRole = (g) => !role
+      || !!(state.disciplines && state.disciplines.get(String(g.id))?.has(role));
+    const matchesStale = (g) => !staleDays || isStale(goalActivityMs(g), staleDays);
     const myId = selfId();
     const iAmMember = (g) => {
       const d = state.details.get(String(g.id));
@@ -104,6 +117,8 @@
       matchesSearch(g) &&
       matchesOwner(g) &&
       matchesCategory(g) &&
+      matchesRole(g) &&
+      matchesStale(g) &&
       (!mineOnly || iAmMember(g)));
   }
   function goalStampHtml(g) {

package/modules/hall-ui/public/task-lib.js

@@ -108,6 +108,34 @@
   // case leaked a machine code into the Goals page UI. Adding a server-side reason
   // without adding it here degrades quietly rather than loudly, so keep this in
   // step with the claim route's refusal codes.
+  // ---- staleness (task 1003278, criterion legibility-sort-and-staleness) ----
+  // ONE definition of "touched", shared by both tiers: updated_at moves on every
+  // task write (claim, status flip, edit); shipped_at is folded in because a ship
+  // path can stamp it without touching updated_at (the task-1002965 owner call,
+  // previously private to goals-lib.js — moved HERE so the Tasks board and the
+  // Goals page cannot disagree about what "untouched" means).
+  const msOf = (iso) => { const t = iso ? Date.parse(iso) : NaN; return Number.isNaN(t) ? 0 : t; };
+  const taskActivityMs = (t) => Math.max(msOf(t.updated_at), msOf(t.shipped_at));
+
+  // The staleness buckets both boards offer. A CLIENT-side vocabulary, not the
+  // project's configured stale timer (task 1003279 wires that into the sweep);
+  // these are lenses for a person browsing, and the sweep is the enforcement.
+  const STALE_CHOICES = [
+    { value: '', label: '— any age —' },
+    { value: '14', label: 'untouched 14+ days' },
+    { value: '30', label: 'untouched 30+ days' },
+    { value: '60', label: 'untouched 60+ days' },
+  ];
+  // Does this activity timestamp fall past the chosen bucket? '' = no filter.
+  // 0 (no readable timestamp at all) is treated as STALE, not fresh — a row
+  // nobody can date is exactly what a rot-hunt must not hide.
+  function isStale(activityMs, days, nowMs) {
+    const d = Number(days);
+    if (!d) return true;
+    const now = Number.isFinite(nowMs) ? nowMs : Date.now();
+    return now - activityMs >= d * 24 * 60 * 60 * 1000;
+  }
+
   function friendlyBatchReason(item) {
     switch (item && item.reason) {
       case 'TASK_NOT_FOUND': return 'no longer exists';
@@ -128,6 +156,7 @@
   }
 
   const api = {
+    msOf, taskActivityMs, STALE_CHOICES, isStale,
     priorityRank, touchesConflict, rankTagHtml, deHashRefs,
     creditsPerMinute, buildPromptForTask, friendlyBatchReason,
   };

package/modules/hall-ui/public/work.js

@@ -46,6 +46,45 @@
   } = window.OTBTaskLib;   // deHashRefs is not called here — it is used inside buildPromptForTask
   // Shared component kit (hall-kit.js, task 2166): tabs, pager, filter bar.
   const { makePager, paginate, wirePager, pagerBarHtml, makeTabs, makeFilterBar } = window.OTBKit;
+  // task 1003278 — the shared staleness vocabulary + activity clock (task-lib.js,
+  // one definition for both tiers) and the creator axis.
+  const { taskActivityMs, STALE_CHOICES, isStale } = window.OTBTaskLib;
+  // task 1003278 — Creator and Age are SERVER-side axes: the board asks the feed
+  // a narrower question rather than downloading it and reducing it here. That is
+  // the criterion's explicit branch ("if it does, the new axes filter and page
+  // SERVER-side"), and it is why changing either control re-fetches instead of
+  // just re-rendering. Every other control stays client-side over what came
+  // back, exactly as before — those narrow an already-loaded page, this narrows
+  // what gets loaded.
+  // The Backlog group, BOUNDED and server-filtered. This read measured 690,625
+  // bytes for ~298 rows on 2026-08-25 and had no ceiling at all — it is
+  // `SELECT * FROM tasks WHERE status='backlog'`, so it grew with the project
+  // forever. Its own function because Creator/Age re-fetch it, same as the
+  // claimable feed. Best-effort: on failure the section stays as it was.
+  function loadBacklog() {
+    const q = serverFilterQuery().replace(/^\?/, '&');
+    return getJSON(`${API}/tasks?status=backlog&limit=${BACKLOG_LIMIT}${q}`)
+      .then((r) => { taskState.backlog = r.tasks || []; renderBacklog(taskState.backlog); })
+      .catch(() => { /* backlog stays as it was */ });
+  }
+
+  // The last server-facing filter query we actually fetched with. Compared on
+  // every filter change to decide re-fetch vs re-render.
+  let lastServerFilterQuery = '';
+
+  function serverFilterQuery() {
+    const parts = [];
+    const creator = $('#f-creator') ? $('#f-creator').value : '';
+    const stale = $('#f-stale') ? $('#f-stale').value : '';
+    if (creator) parts.push(`created_by=${encodeURIComponent(creator === '__none__' ? 'none' : creator)}`);
+    if (stale) parts.push(`stale_days=${encodeURIComponent(stale)}`);
+    return parts.length ? `?${parts.join('&')}` : '';
+  }
+
+  // task 1003278 — the ceiling on the Backlog read. Comfortably above today's
+  // ~300 rows so nothing visibly changes now, and low enough that the page can
+  // never be asked to hold the whole table as the project grows.
+  const BACKLOG_LIMIT = 500;
   const fmtDate = (iso) => window.OTB.fmtDate(iso);
   const toast = (msg) => window.OTB.toast(msg, { duration: 2200, clear: true });
   const curLabel = (caps) => { const l = (window.__BRANDING__ && window.__BRANDING__.currency && window.__BRANDING__.currency.label) || 'credits'; return caps ? l.charAt(0).toUpperCase() + l.slice(1) : l; };
@@ -255,6 +294,11 @@
     const kFilter = $('#f-kind').value;
     const dFilter = $('#f-discipline').value;
     const nFilter = $('#f-newcomer') ? $('#f-newcomer').value : '';
+    // task 1003278 — creator + staleness. '__none__' on Creator isolates the
+    // unattributed (created before tasks.created_by existed, or by a system path)
+    // — the goals owner filter's 'system / unattributed' convention.
+    const cFilter = $('#f-creator') ? $('#f-creator').value : '';
+    const staleFilter = $('#f-stale') ? $('#f-stale').value : '';
     const sortBy = $('#f-sort').value;
     const sQuery = searchQuery();
 
@@ -267,6 +311,13 @@
       if (kFilter && t.kind !== kFilter) return false;
       if (dFilter && (t.discipline || 'unclassified') !== dFilter) return false;
       if (nFilter === 'yes' && !t.newcomer_friendly) return false;
+      // Creator + Age were applied by the SERVER (serverFilterQuery), so they are
+      // re-checked here only as a belt on a stale render — never as the primary
+      // filter. Re-applying them is cheap and keeps the view honest if a poll
+      // lands between a control change and its re-fetch.
+      if (cFilter === '__none__' && t.created_by != null) return false;
+      if (cFilter && cFilter !== '__none__' && String(t.created_by) !== cFilter) return false;
+      if (staleFilter && !isStale(taskActivityMs(t), staleFilter)) return false;
       return true;
     });
 
@@ -295,6 +346,10 @@
     } else if (sortBy === 'id') {
       // task 1830: sort by task number, ascending (lowest/oldest first).
       list = list.slice().sort((a, b) => Number(a.id) - Number(b.id));
+    } else if (sortBy === 'stale') {
+      // task 1003278: what is rotting — least-recently-touched first, on the
+      // shared activity clock (updated_at ∨ shipped_at, task-lib.js).
+      list = list.slice().sort((a, b) => taskActivityMs(a) - taskActivityMs(b));
     }
 
     const count = $('#claim-count');
@@ -405,6 +460,44 @@
     }
   }
 
+  // task 1003278: the Creator filter — options are the builders who created the
+  // tasks on the board (claimable + backlog), labelled via the directory the
+  // goals page also reads (GET /builders/directory, best-effort — 'builder #id'
+  // until it lands). '__none__' isolates the unattributed: every task created
+  // before tasks.created_by existed (core_227 deliberately backfills nothing —
+  // a guessed attribution is a confident lie), plus system paths like the
+  // newcomer restock.
+  async function populateCreatorFilter() {
+    const sel = $('#f-creator');
+    if (!sel) return;
+    const rows = [...taskState.all, ...(taskState.backlog || [])];
+    const ids = [...new Set(rows.filter((t) => t.created_by != null).map((t) => String(t.created_by)))];
+    let byId = new Map();
+    if (ids.length) {
+      try {
+        const d = await getJSON(`${API}/builders/directory`);
+        byId = new Map((d.builders || []).map((b) => [String(b.id), b]));
+      } catch (_) { /* labels fall back to builder #id */ }
+    }
+    const label = (id) => {
+      const b = byId.get(id);
+      return b ? (b.display_name || '@' + b.github_login) : `builder #${id}`;
+    };
+    sel.length = 1; // keep the leading "— any —" option
+    for (const id of ids.sort((a, b) => label(a).localeCompare(label(b)))) {
+      const opt = document.createElement('option');
+      opt.value = id;
+      opt.textContent = label(id);
+      sel.appendChild(opt);
+    }
+    if (rows.some((t) => t.created_by == null)) {
+      const opt = document.createElement('option');
+      opt.value = '__none__';
+      opt.textContent = 'system / unattributed';
+      sel.appendChild(opt);
+    }
+  }
+
   // task 1755: the Goal filter — options are the goals present on the claimable
   // feed, labeled by title (falls back to 'Goal #id' before titles load).
   // '__none__' isolates ungoaled tasks. Populated once after the feed loads.
@@ -983,7 +1076,7 @@
   // the same way loadAll does so a transient failure doesn't blank the board.
   async function refreshLive() {
     try {
-      const claimResp = await getJSON(`${API}/tasks/claimable`);
+      const claimResp = await getJSON(`${API}/tasks/claimable${serverFilterQuery()}`);
       renderInFlight(claimResp.active_claims || []);
       taskState.all = claimResp.claimable || [];
       renderClaimable();
@@ -1072,9 +1165,7 @@
 
     // task 1754: the Backlog group — not-yet-ready tasks. Best-effort + independent
     // of the claimable feed; leaves the section hidden on failure.
-    getJSON(`${API}/tasks?status=backlog`)
-      .then((r) => { taskState.backlog = r.tasks || []; renderBacklog(taskState.backlog); })
-      .catch(() => { /* backlog stays hidden */ });
+    loadBacklog();
 
     // task 1755: goal id → title map for the Goal filter (best-effort).
     taskState.goalTitles = {};
@@ -1096,7 +1187,7 @@
     // empty-but-honest (the gate also blocks active_claims, so say so).
     try {
       const [claimResp, versionsResp] = await Promise.all([
-        getJSON(`${API}/tasks/claimable`),
+        getJSON(`${API}/tasks/claimable${serverFilterQuery()}`),
         getJSON(`${API}/versions`).catch(() => ({ versions: [] })),
       ]);
       taskState.versions = versionsResp.versions || [];
@@ -1106,6 +1197,7 @@
       taskState.all = claimResp.claimable || [];
       renderClaimable();
       populateGoalFilter(); // task 1755
+      populateCreatorFilter().catch(() => {}); // task 1003278 — fire-and-forget, the owner-filter posture
       // task 2170: a shared URL's goal filter can only apply once the options
       // exist — restore it now and re-render if it changed anything.
       if (restoreUrlFilter('f-goal')) renderClaimable();
@@ -1168,6 +1260,7 @@
             { value: 'minutes', label: 'minutes (low → high)' },
             { value: 'priority', label: 'priority (P0 first)' },
             { value: 'id', label: 'task number (low → high)' },
+            { value: 'stale', label: 'stalest first (untouched longest)' },
           ],
         },
         { id: 'f-version', label: 'Version', options: [{ value: '', label: '— any —' }] },
@@ -1191,6 +1284,11 @@
           label: 'Newcomer',
           options: [{ value: '', label: '— any —' }, { value: 'yes', label: 'newcomer-friendly only' }],
         },
+        // task 1003278 — Creator options fill after the feeds land
+        // (populateCreatorFilter, the f-goal pattern); staleness buckets are the
+        // shared STALE_CHOICES so both tiers offer the same lenses.
+        { id: 'f-creator', label: 'Creator', options: [{ value: '', label: '— any —' }] },
+        { id: 'f-stale', label: 'Age', options: STALE_CHOICES },
         {
           id: 'f-fit',
           label: 'Run mode',
@@ -1203,6 +1301,20 @@
       onChange: () => {
         pagers.ready.page = 1;
         pagers.backlog.page = 1;
+        // task 1003278 — Creator and Age are answered by the SERVER, so a change
+        // to either re-fetches a narrower feed instead of re-reducing the wide
+        // one. The test is whether the SERVER-FACING QUESTION changed, not which
+        // control fired: makeFilterBar's onChange is handed every value, not the
+        // changed id (hall-kit.js:269), and comparing the query is the direct
+        // question anyway — a control that does not appear in it can never cost
+        // a round-trip, which is what keeps the other filters instant.
+        const q = serverFilterQuery();
+        if (q !== lastServerFilterQuery) {
+          lastServerFilterQuery = q;
+          refreshLive();
+          loadBacklog();
+          return;
+        }
         renderClaimable();
         renderBacklog();
       },

package/modules/ideas/inbox.js

@@ -429,6 +429,10 @@ async function routeIdeaToGoal({
       // (db.findTaskBySourceRef): one idea can only ever mint one routed task.
       source: 'idea-route',
       sourceRef: `idea-${idea.id}`,
+      // task 1003278 — the filer created this task, via the route. capturedBy is
+      // already the authenticated filer's id (never body-supplied), so routing an
+      // idea attributes the task to the person whose idea it was.
+      createdBy: capturedBy ?? null,
     }, { client });
 
     // d. The lineage row — origin='route' (ideas_003 widened the CHECK for

package/modules/lifecycle/db-tasks.js

@@ -72,6 +72,11 @@ async function createTask({
   // (requiresRank stays null for the goal vector → derived purely from touches +
   // sensitivity), so goal_id never influences the requires_rank clamp.
   goalId = null,
+  // task 1003278: WHO created it — the builder id from the authenticated request.
+  // Nullable, appended at the end (the goals bind-order convention): a system
+  // path with no builder in the request (a seed, a migration backfill) passes
+  // nothing and the row honestly reads unattributed, never guessed.
+  createdBy = null,
 }, deps = {}) { // deps.client enlists this INSERT in the CALLER'S transaction (task 1003065, BV1.R01); the argument for it is at modules/ideas/inbox.js routeIdeaToGoal
   // task 1498 / ADR 0085: every task carries a deliberate rank floor. Derive it
   // from touches + sensitivity, then let an explicit requiresRank override only
@@ -112,12 +117,12 @@ async function createTask({
                         est_minutes, est_cost_usd, manual_degree, priority,
                         automation_tag, credits_reward, source, source_ref, value_summary,
                         kind, discipline, parallel_safe, newcomer_friendly, needs_migration,
-                        security_sensitive, requires_rank, module_key, goal_id, promoted_at)
+                        security_sensitive, requires_rank, module_key, goal_id, created_by, promoted_at)
      VALUES ($1, $2, $3, $4, $5,
              $6, $7, $8, $9,
              $10, $11, $12, $13, $14,
              $15, $16, $17, $18, $19,
-             $20, $21, $22, $23,
+             $20, $21, $22, $23, $24,
              CASE WHEN $4 IN ('ready','active') THEN now() ELSE NULL END)
      RETURNING *`,
     [
@@ -144,6 +149,7 @@ async function createTask({
       requiresRankEffective,
       moduleKey ?? null,
       goalIdEffective ?? null,
+      createdBy ?? null,
     ]
   );
   // task 1677 / ADR 0096: audit each creation-time auto-assignment so the trail is
@@ -473,7 +479,7 @@ async function getTask(id) {
 }
 
 
-async function listTasks({ versionId, status, kind, discipline, goalId } = {}) {
+async function listTasks({ versionId, status, kind, discipline, goalId, createdBy, staleDays, limit, offset } = {}) {
   const params = [];
   const where = [];
   if (versionId) {
@@ -496,13 +502,44 @@ async function listTasks({ versionId, status, kind, discipline, goalId } = {}) {
     params.push(goalId);
     where.push(`goal_id = $${params.length}`);
   }
+  // task 1003278 — the creator + staleness axes, server-side. They exist HERE and
+  // not only in the browser because the board was reducing the whole table to
+  // answer them: GET /tasks?status=backlog measured 690,625 bytes on 2026-08-25,
+  // and the Goals page's whole-version read 5.2 MB. `'none'` selects the
+  // unattributed (created before tasks.created_by existed, or by a system path) —
+  // the goals owner-filter convention, and a real question ("what has no owner").
+  if (createdBy === 'none') {
+    where.push('created_by IS NULL');
+  } else if (createdBy) {
+    params.push(createdBy);
+    where.push(`created_by = $${params.length}`);
+  }
+  // Untouched for N days, on the SAME clock the clients use: max(updated_at,
+  // shipped_at) — a ship path can stamp shipped_at without touching updated_at.
+  // A row with neither is stale by construction (GREATEST of two epochs), which
+  // matches isStale()'s treatment of an undated row: a row nobody can date is
+  // what a rot-hunt must not hide.
+  if (staleDays) {
+    params.push(staleDays);
+    where.push(
+      `GREATEST(COALESCE(updated_at, 'epoch'::timestamptz), COALESCE(shipped_at, 'epoch'::timestamptz))
+         <= now() - ($${params.length}::int * INTERVAL '1 day')`
+    );
+  }
   const sql =
     `SELECT t.*, ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded,
             pms_calibrated_minutes(t.est_minutes, t.kind) AS est_minutes_calibrated
        FROM tasks t` +
     (where.length ? ` WHERE ${where.join(' AND ')}` : '') +
     ` ORDER BY priority NULLS LAST, created_at`;
-  const { rows } = await pool.query(sql, params);
+  // BOUND, not interpolated. Both call sites validate to a finite non-negative
+  // integer today, so string interpolation would not be exploitable — but a
+  // query builder that is only safe because of who happens to call it is one
+  // careless caller away from not being safe at all (raised in review).
+  let tail = '';
+  if (limit) { params.push(Number(limit)); tail += ` LIMIT $${params.length}`; }
+  if (offset) { params.push(Number(offset)); tail += ` OFFSET $${params.length}`; }
+  const { rows } = await pool.query(sql + tail, params);
   return rows;
 }
 
@@ -571,7 +608,7 @@ const SESSION_FIT_SQL = `
     END AS fits_session_modes
     FROM tasks t`;
 
-async function listClaimableTasks({ versionId = null, builderId = null, discipline = null, fit = null } = {}) {
+async function listClaimableTasks({ versionId = null, builderId = null, discipline = null, fit = null, createdBy = null, staleDays = null } = {}) {
   const params = [];
   const where = [];
   let goalJoin = '';
@@ -584,6 +621,25 @@ async function listClaimableTasks({ versionId = null, builderId = null, discipli
     params.push(discipline);
     where.push(`v.discipline = $${params.length}`);
   }
+  // task 1003278 — the SAME creator + staleness axes GET /tasks offers, so the
+  // Work Board asks the server a narrow question instead of pulling the feed and
+  // reducing it in the browser. 'none' selects the unattributed; the staleness
+  // clock is max(updated_at, shipped_at), identical to listTasks, the rollup SQL
+  // and task-lib.js — four expressions of one rule, pinned against each other by
+  // tests/goal_sort_staleness.mjs.
+  if (createdBy === 'none') {
+    where.push('v.created_by IS NULL');
+  } else if (createdBy) {
+    params.push(createdBy);
+    where.push(`v.created_by = $${params.length}`);
+  }
+  if (staleDays) {
+    params.push(staleDays);
+    where.push(
+      `GREATEST(COALESCE(v.updated_at, 'epoch'::timestamptz), COALESCE(v.shipped_at, 'epoch'::timestamptz))
+         <= now() - ($${params.length}::int * INTERVAL '1 day')`
+    );
+  }
   if (builderId) {
     params.push(builderId);
     where.push(`NOT EXISTS (