@bongos/core 1.24.14 → 1.24.16

package/modules/hall-ui/public/style.css

@@ -4416,6 +4416,34 @@ a.stat-tile:hover .stat-tile__sub { color: var(--ink-soft); }
   white-space: nowrap;
 }
 
+/* ---------- the Link GitHub chip (task 1004996, github-chip.js) ----------
+   Very small and quiet on purpose: shown only to someone with no GitHub linked,
+   it is a plain link, never a banner — ideating and art go on without it. The
+   engineer's glyph says what it is for; the label folds away on a phone. */
+.gh-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  min-height: 24px;
+  min-width: 24px;
+  padding: 0 8px 0 6px;
+  border: 1px solid var(--rule);
+  border-radius: var(--radius-pill, 999px);
+  color: var(--ink-soft);
+  font-size: 12px;
+  line-height: 1;
+  text-decoration: none;
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+.gh-chip:hover { color: var(--ink); border-color: var(--ink-faint); }
+.gh-chip:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+.gh-chip svg { width: 13px; height: 13px; flex-shrink: 0; }
+@media (max-width: 640px) {
+  .gh-chip { padding: 0; justify-content: center; }
+  .gh-chip__label { display: none; }
+}
+
 .palette { position: fixed; inset: 0; z-index: 2100; }
 .palette__scrim { position: absolute; inset: 0; background: var(--scrim); }
 .palette__panel {

package/modules/hall-ui/public/task.html

@@ -59,7 +59,7 @@
 <script src="/builders/dom-utils.js?v=2026-10-25-escape"></script>
 <script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
 <script src="/builders/craft-mode.js?v=2026-10-30-market-watch"></script>
-<script src="/builders/shell.js?v=2026-10-30-market-watch-pages"></script>
+<script src="/builders/shell.js?v=2026-10-30-github-chip"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- task-detail.js still owns the #/idea/N and #/blocker/N deep-link overlay

package/modules/hall-ui/public/thinking.html

@@ -141,7 +141,7 @@
 <script src="/builders/dom-utils.js?v=2026-10-25-escape"></script>
 <script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
 <script src="/builders/craft-mode.js?v=2026-10-30-market-watch"></script>
-<script src="/builders/shell.js?v=2026-10-30-market-watch-pages"></script>
+<script src="/builders/shell.js?v=2026-10-30-github-chip"></script>
 <script src="/builders/palette.js" defer></script>
 
 <script src="/builders/idea-objects.js?v=2026-09-27-split"></script>

package/modules/hall-ui/public/tweak-editor.html

@@ -145,7 +145,7 @@
 <script src="/builders/dom-utils.js?v=2026-10-25-escape"></script>
 <script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
 <script src="/builders/craft-mode.js?v=2026-10-30-market-watch"></script>
-<script src="/builders/shell.js?v=2026-10-30-market-watch-pages"></script>
+<script src="/builders/shell.js?v=2026-10-30-github-chip"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/brand-holes.js?v=2026-09-29-aqfix"></script>
 <script src="/builders/tweak-editor-lib.js?v=2026-09-29-tw27"></script>

package/modules/hall-ui/public/watch.html

@@ -166,7 +166,7 @@
 <script src="/builders/dom-utils.js?v=2026-10-25-escape"></script>
 <script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
 <script src="/builders/craft-mode.js?v=2026-10-30-market-watch"></script>
-<script src="/builders/shell.js?v=2026-10-30-market-watch-pages"></script>
+<script src="/builders/shell.js?v=2026-10-30-github-chip"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- shared component kit (window.OTBKit) — tabs, ledger, pager (task 2166). -->

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

@@ -174,7 +174,7 @@
 <script src="/builders/dom-utils.js?v=2026-10-25-escape"></script>
 <script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
 <script src="/builders/craft-mode.js?v=2026-10-30-market-watch"></script>
-<script src="/builders/shell.js?v=2026-10-30-market-watch-pages"></script>
+<script src="/builders/shell.js?v=2026-10-30-github-chip"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- task 1004727: the ONE karma vote control every task/idea list renders -->

package/modules/ideas/blockers.js

@@ -12,11 +12,17 @@ const { pool } = require('../../src/module-api');
 // Shared by listOpenBlockers + getBlocker so the two reads can never drift
 // (task 1002459 — getBlocker used to omit this column entirely, so a
 // link-then-verify against the detail route read as a false negative).
-const BLOCKING_TASK_IDS_SQL = `COALESCE(
-              (SELECT array_agg(tb.task_id ORDER BY tb.task_id)
-                 FROM task_blockers tb WHERE tb.blocker_id = b.id),
-              ARRAY[]::bigint[]
-            ) AS blocking_task_ids`;
+// task 1004958: ONE lateral read gives both shapes — the ids (the hall reads those)
+// and the same tasks with their 2-3 word names, so a session can write
+// "task N - payout approvals" instead of a bare number.
+const BLOCKING_TASK_IDS_SQL = `COALESCE(bl.ids, ARRAY[]::bigint[]) AS blocking_task_ids,
+            COALESCE(bl.tasks, '[]'::json) AS blocking_tasks`;
+const BLOCKING_TASKS_JOIN = `LEFT JOIN LATERAL (
+         SELECT array_agg(tb.task_id ORDER BY tb.task_id) AS ids,
+                json_agg(json_build_object('id', tb.task_id, 'short_name', bt.short_name) ORDER BY tb.task_id) AS tasks
+           FROM task_blockers tb LEFT JOIN tasks bt ON bt.id = tb.task_id
+          WHERE tb.blocker_id = b.id
+       ) bl ON true`;
 
 // Optional { limit, offset } pushes the page into SQL so a small slice (the Home
 // attention inbox reads limit=5 on every load) never scans the whole open set
@@ -32,7 +38,7 @@ async function listOpenBlockers({ limit, offset } = {}) {
     `SELECT b.id, b.title, b.body_md, b.status, b.created_at,
             b.source, b.source_ref,
             ${BLOCKING_TASK_IDS_SQL}
-       FROM blockers b
+       FROM blockers b ${BLOCKING_TASKS_JOIN}
       WHERE b.status = 'open'
       ORDER BY b.id${page}`,
     params
@@ -50,7 +56,7 @@ async function getBlocker(id) {
     `SELECT b.id, b.title, b.body_md, b.status, b.created_at, b.resolved_at, b.resolved_by,
             b.resolution_note, b.source, b.source_ref,
             ${BLOCKING_TASK_IDS_SQL}
-       FROM blockers b WHERE b.id = $1`,
+       FROM blockers b ${BLOCKING_TASKS_JOIN} WHERE b.id = $1`,
     [id]
   );
   return rows[0] || null;

package/modules/lifecycle/db-claim-reads.js

@@ -21,7 +21,7 @@ async function getActiveClaimsForBuilder(builderId) {
     `SELECT c.id AS claim_id, c.task_id, c.worktree_name, c.claimed_at,
             c.head_sha, c.reserved_migration_number,
             c.release_requested_by, c.release_requested_at, c.release_requested_note,
-            t.title, t.touches, t.priority, t.credits_reward, t.version_id, t.module_key,
+            t.title, t.short_name, t.touches, t.priority, t.credits_reward, t.version_id, t.module_key,
             -- task 1003855: the craft of the claimed work. A speciality contract is
             -- craft-scoped, so the Conductor needs to know which craft is in play
             -- before it can pick the right one to inject.

package/modules/lifecycle/db-ship.js

@@ -485,7 +485,7 @@ const UNPROVABLE_STRAND_REASON = 'strand:no_branch_no_tip';
 // release it.
 async function gatingRebaseTasksForBuilder(builderId, client = pool, graceMs = UNPROVABLE_GATE_GRACE_MS) {
   const { rows } = await client.query(
-    `SELECT id, title, needs_rebase_reason, needs_rebase_at
+    `SELECT id, title, short_name, needs_rebase_reason, needs_rebase_at
        FROM tasks
       WHERE needs_rebase = true AND status = 'confirmed' AND shipped_by = $1
         AND NOT (
@@ -501,7 +501,7 @@ async function gatingRebaseTasksForBuilder(builderId, client = pool, graceMs = U
 
 async function needsRebaseTasksForBuilder(builderId, client = pool) {
   const { rows } = await client.query(
-    `SELECT id, title, needs_rebase_reason, needs_rebase_at
+    `SELECT id, title, short_name, needs_rebase_reason, needs_rebase_at
        FROM tasks
       WHERE needs_rebase = true AND status = 'confirmed' AND shipped_by = $1
       ORDER BY needs_rebase_at ASC NULLS LAST, id ASC`,

package/modules/lifecycle/db-tasks.js

@@ -24,6 +24,7 @@ const { gateOnSpecTask } = require('./goal-spec-task.js');
 const { ensureArtistReviewGoal } = require('./artist-review-goal.js');
 const { notPageMarkerSql } = require('./page-tweak-artist.js');
 const { needsFilterWhere, capabilityFeedWhere } = require('./task-needs-gate.js');
+const { deriveTaskName } = require('./task-name.js');
 
 // -------------------------------------------------------------------------
 // Tasks
@@ -270,13 +271,13 @@ 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, created_by, promoted_at, needs)
+                        security_sensitive, requires_rank, module_key, goal_id, created_by, promoted_at, needs, short_name)
      VALUES ($1, $2, $3, $4, $5,
              $6, $7, $8, $9,
              $10, $11, $12, $13, $14,
              $15, $16, $17, $18, $19,
              $20, $21, $22, $23, $24,
-             CASE WHEN $4 IN ('ready','active') THEN now() ELSE NULL END, $25)
+             CASE WHEN $4 IN ('ready','active') THEN now() ELSE NULL END, $25, $26)
      RETURNING *`,
     [
       versionId,
@@ -303,7 +304,7 @@ async function createTask({
       moduleKey ?? null,
       goalIdEffective ?? null,
       createdBy ?? null,
-      Array.isArray(needs) ? needs : [],
+      Array.isArray(needs) ? needs : [], deriveTaskName(title, description), // $26: the short name (task 1004958)
     ]
   );
   // task 1677 / ADR 0096: audit each creation-time auto-assignment so the trail is
@@ -486,7 +487,6 @@ async function updateTaskPriority(id, priority) { return updateTaskColumn(id, 'p
 // keeps on every other value_summary write.
 async function updateTaskValueSummary(id, valueSummary) { return updateTaskColumn(id, 'value_summary', valueSummary); }
 
-
 async function updateTaskDiscipline(id, discipline) { return updateTaskColumn(id, 'discipline', discipline); }
 
 // #360 / ADR 0018 + V3.R15 #239: open (or close) a task to Xenos claims by

package/modules/lifecycle/migrations/lifecycle_019_pay_type_gates.sql

@@ -0,0 +1,50 @@
+-- lifecycle_019_pay_type_gates.sql — task 1004991 (goal 1000092; ADR 0385, "Pay-type
+-- gates").
+--
+-- A pay type becomes switchable only after its gate is cleared and recorded. A
+-- gate is a short list of requirements per pay type (the list lives in
+-- modules/lifecycle/pay-type-gates.js, taken from the ADR's table); this table
+-- records, for each requirement, who said it is met, when, and the evidence they
+-- point at. The gate is cleared when every requirement's NEWEST row says 'cleared'.
+-- The instance is the project, so there is no project column: one database, one
+-- project.
+--
+-- A LIFECYCLE MIGRATION, NOT A CORE ONE: a brand-new table the lifecycle module
+-- owns (pay-type-gates.js is its only reader and writer), the lifecycle_018_pay_terms
+-- precedent.
+--
+-- RECORDS ONLY. Nothing here moves money. Clearing a requirement is a person's act
+-- (often with counsel) and the evidence column holds only a REFERENCE to it (a
+-- document title, a ticket, a processor verdict id) — never identity, tax or KYC
+-- data, which Bongos does not store.
+--
+-- APPEND-ONLY. Every clearing or revoking is a new row; the newest row per
+-- (pay_type, requirement) is current, and a row trigger refuses UPDATE and DELETE,
+-- so the table is its own audit trail. The database also refuses outright any row for
+-- eu_labour: until a later ADR enables it, no code path, however forged, can clear it.
+
+CREATE TABLE IF NOT EXISTS lifecycle_pay_type_gates (
+  id           bigserial PRIMARY KEY,
+  pay_type     text NOT NULL CHECK (pay_type IN
+                 ('cash', 'equity', 'module_share', 'credit_pool', 'non_monetary', 'self_managed')),
+  requirement  text NOT NULL CHECK (char_length(requirement) BETWEEN 1 AND 64),
+  state        text NOT NULL CHECK (state IN ('cleared', 'revoked')),
+  evidence_ref text NOT NULL CHECK (char_length(evidence_ref) BETWEEN 1 AND 500),
+  decided_by   bigint NOT NULL REFERENCES builders(id),
+  decided_at   timestamptz NOT NULL DEFAULT now()
+);
+
+-- The current state of a requirement: newest first.
+CREATE INDEX IF NOT EXISTS lifecycle_pay_type_gates_current
+  ON lifecycle_pay_type_gates (pay_type, requirement, decided_at DESC, id DESC);
+
+CREATE OR REPLACE FUNCTION lifecycle_pay_type_gates_refuse_change() RETURNS trigger AS $$
+BEGIN
+  RAISE EXCEPTION 'pay-type gates are a history: % on % is refused; record a new row instead', TG_OP, TG_TABLE_NAME
+    USING ERRCODE = 'check_violation';
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS lifecycle_pay_type_gates_append_only ON lifecycle_pay_type_gates;
+CREATE TRIGGER lifecycle_pay_type_gates_append_only BEFORE UPDATE OR DELETE ON lifecycle_pay_type_gates
+  FOR EACH ROW EXECUTE FUNCTION lifecycle_pay_type_gates_refuse_change();

package/modules/lifecycle/module.json

@@ -29,6 +29,7 @@
       "kickoff-seed",
       "rot",
       "project-settings",
+      "pay-type-gates",
       "artist-gate",
       "removal-proposals",
       "sky",

package/modules/lifecycle/pay-type-gates.js

@@ -0,0 +1,180 @@
+// modules/lifecycle/pay-type-gates.js — a pay type may be put on a task only after its
+// gate is cleared for the project (task 1004991, goal 1000092; ADR 0385 "Pay-type gates").
+//
+// A gate is a fixed list of requirements per pay type, taken from the ADR's table and
+// written down here as data. A person records each requirement as cleared (with a
+// reference to the evidence) or revoked; the gate is cleared when every requirement's
+// newest record says cleared. The pay-terms write paths ask `refuseUnclearedGates`
+// before they write, so the server refuses a pay term whose type has an open gate.
+//
+// FOUR RULES THIS FILE HOLDS:
+//   1. The list is data, not prose: REQUIREMENTS is the one place the ADR's table lives
+//      in code, and the table pins it against the pay-type list pay-terms.js accepts.
+//   2. eu_labour can never be cleared. It is not in any list a write accepts and the
+//      table's CHECK refuses a row for it, so no request, however forged, reaches a
+//      cleared state (a later ADR enables it, per ADR 0385's EU labour row).
+//   3. self_managed clears with one act, the acknowledgement that Bongos moves and
+//      guarantees nothing. Nothing else is asked of it.
+//   4. Records only. Evidence is a REFERENCE a person typed; Bongos stores no identity,
+//      tax or KYC data here, and nothing in this file moves money.
+//
+// Who may record a requirement is decided by the ROUTE (the project owner, on the
+// server — ADR 0016); who recorded it comes from the signed-in builder, never the body.
+
+const api = require('../../src/module-api');
+const { PAY_TYPES, SELF_MANAGED_LABEL } = require('./pay-terms');
+
+const NEVER_CLEARABLE = ['eu_labour'];
+const ACKNOWLEDGEMENT = 'bongos_moves_and_guarantees_nothing';
+const EVIDENCE_MAX = 500;
+
+// The machine-checkable list per pay type (ADR 0385, "Must exist first").
+const REQUIREMENTS = {
+  cash: [
+    ['processor_onboarding', 'Processor onboarding done'],
+    ['tax_details', 'Tax details collected'],
+    ['age_check', 'Age check passed'],
+    ['sanctions_screening', 'Sanctions screening done'],
+    ['signed_rule', 'Signed pay rule on file'],
+  ],
+  equity: [
+    ['counsel_approved_structure', 'The project\'s own counsel-approved structure'],
+    ['one_signature_per_grant', 'One signature per grant'],
+    ['no_percentage_fee', 'No percentage fee taken'],
+    ['wording_filter', 'Credit and valuation wording filter in force'],
+  ],
+  module_share: [
+    ['standard_module_licence', 'Standard module licence'],
+    ['takedown_contact', 'Takedown contact named'],
+    ['payee_onboarding', 'Payee onboarding done'],
+  ],
+  credit_pool: [
+    ['credit_wording_in_force', 'Credit wording rule (ADR 0385 decision 9) in force'],
+    ['model_inputs_visible', 'Model inputs visible to the people affected'],
+    ['signed_rule', 'Signed pay rule on file'],
+  ],
+  non_monetary: [
+    ['guardian_consent_13_15', 'Guardian consent for ages 13 to 15'],
+    ['no_cash_redemption', 'No cash redemption of any credit'],
+  ],
+  self_managed: [
+    [ACKNOWLEDGEMENT, 'Acknowledged: Bongos moves and guarantees nothing'],
+  ],
+};
+
+function requirementIds(payType) {
+  return (REQUIREMENTS[payType] || []).map(([id]) => id);
+}
+
+// PURE. The verdict for one pay type, from its current rows ({ requirement, state,
+// evidence_ref, decided_by, decided_at }, newest per requirement). A requirement with
+// no row, or whose newest row is revoked, is missing. Rows for requirements not in the
+// list are ignored, so a stray row can never clear a gate.
+function gateVerdict(payType, currentRows) {
+  if (NEVER_CLEARABLE.includes(payType)) {
+    return { pay_type: payType, cleared: false, never: true, requirements: [], missing: [] };
+  }
+  const byReq = new Map((currentRows || []).filter((r) => r.pay_type == null || r.pay_type === payType).map((r) => [r.requirement, r]));
+  const requirements = (REQUIREMENTS[payType] || []).map(([id, label]) => {
+    const r = byReq.get(id);
+    const met = !!r && r.state === 'cleared';
+    return {
+      requirement: id,
+      label,
+      met,
+      evidence_ref: r ? r.evidence_ref : null,
+      cleared_by: met ? r.decided_by : null,
+      cleared_at: met ? r.decided_at : null,
+    };
+  });
+  const missing = requirements.filter((x) => !x.met).map((x) => x.requirement);
+  return { pay_type: payType, cleared: requirements.length > 0 && missing.length === 0, never: false, requirements, missing };
+}
+
+// The newest row per (pay_type, requirement) for these pay types, one read.
+async function readCurrentRows(payTypes, { db } = {}) {
+  const exec = db || api.pool;
+  const { rows } = await exec.query(
+    `SELECT DISTINCT ON (pay_type, requirement) pay_type, requirement, state, evidence_ref, decided_by, decided_at
+       FROM lifecycle_pay_type_gates
+      WHERE pay_type = ANY($1::text[])
+      ORDER BY pay_type, requirement, decided_at DESC, id DESC`, [payTypes]);
+  return rows;
+}
+
+// Every pay type's verdict, for the owner's view (and the settings page).
+async function readGates({ db } = {}) {
+  const rows = await readCurrentRows(PAY_TYPES, { db });
+  const gates = PAY_TYPES.map((p) => gateVerdict(p, rows.filter((r) => r.pay_type === p)));
+  for (const p of NEVER_CLEARABLE) gates.push(gateVerdict(p, []));
+  return gates;
+}
+
+// PURE. A verdict as a non-owner may see it: met or missing per requirement, without the
+// evidence reference a person typed or who cleared it (those are the owner's own records).
+function withoutEvidence(gate) {
+  return { ...gate, requirements: gate.requirements.map(({ evidence_ref, cleared_by, cleared_at, ...rest }) => rest) };
+}
+
+// Checks a list of normalized terms against the gates. Returns null when every type
+// in it is cleared, else { code, message, pay_type, missing } for the first that is
+// not. One read however many terms there are, and none for an empty list.
+async function refuseUnclearedGates(terms, { db } = {}) {
+  const types = [...new Set((terms || []).map((t) => t.pay_type))];
+  if (!types.length) return null;
+  const rows = await readCurrentRows(types, { db });
+  for (const payType of types) {
+    const v = gateVerdict(payType, rows.filter((r) => r.pay_type === payType));
+    if (!v.cleared) {
+      return {
+        code: 'pay_type_gate_not_cleared',
+        pay_type: payType,
+        missing: v.missing,
+        message: `The ${payType} pay type is not switched on for this project: its gate is not cleared (still needed: ${v.missing.join(', ')}).`,
+      };
+    }
+  }
+  return null;
+}
+
+// PURE. Checks a request body to record one requirement. Returns { state, evidenceRef }
+// or { status, code, error }. The recorder is never read from the body.
+function normalizeGateWrite(payType, requirement, body) {
+  if (NEVER_CLEARABLE.includes(payType)) {
+    return { status: 409, code: 'pay_type_never_clearable', error: `${payType} cannot be cleared; it stays off until a later decision enables it.` };
+  }
+  if (!PAY_TYPES.includes(payType)) return { status: 404, code: 'unknown_pay_type', error: `pay type must be one of ${PAY_TYPES.join(', ')}.` };
+  if (!requirementIds(payType).includes(requirement)) {
+    return { status: 404, code: 'unknown_requirement', error: `${payType} has no such requirement; it has ${requirementIds(payType).join(', ')}.` };
+  }
+  const b = body && typeof body === 'object' && !Array.isArray(body) ? body : {};
+  const extra = Object.keys(b).filter((k) => !['state', 'evidence_ref', 'acknowledged'].includes(k));
+  if (extra.length) return { status: 400, code: 'unknown_field', error: `unknown field: ${extra.join(', ')}.` };
+  if (b.state !== 'cleared' && b.state !== 'revoked') return { status: 400, code: 'bad_state', error: 'state is "cleared" or "revoked".' };
+  if (requirement === ACKNOWLEDGEMENT && b.state === 'cleared') {
+    if (b.acknowledged !== true) {
+      return { status: 400, code: 'acknowledgement_required', error: `Send acknowledged: true. It records: ${SELF_MANAGED_LABEL}` };
+    }
+    return { state: 'cleared', evidenceRef: SELF_MANAGED_LABEL };
+  }
+  const ev = typeof b.evidence_ref === 'string' ? b.evidence_ref.trim() : '';
+  if (!ev || ev.length > EVIDENCE_MAX) {
+    return { status: 400, code: 'bad_evidence_ref', error: `evidence_ref is a reference to the evidence (or the reason, for a revoke), 1 to ${EVIDENCE_MAX} characters.` };
+  }
+  return { state: b.state, evidenceRef: ev };
+}
+
+// Appends one record. Returns the gate's new verdict for that pay type.
+async function recordRequirement({ payType, requirement, state, evidenceRef, builderId }, { db } = {}) {
+  const exec = db || api.pool;
+  await exec.query(
+    `INSERT INTO lifecycle_pay_type_gates (pay_type, requirement, state, evidence_ref, decided_by)
+     VALUES ($1, $2, $3, $4, $5)`, [payType, requirement, state, evidenceRef, builderId]);
+  const rows = await readCurrentRows([payType], { db: exec });
+  return gateVerdict(payType, rows);
+}
+
+module.exports = {
+  REQUIREMENTS, ACKNOWLEDGEMENT,
+  requirementIds, gateVerdict, readGates, refuseUnclearedGates, normalizeGateWrite, recordRequirement, withoutEvidence,
+};

package/modules/lifecycle/publish-reconciler.js

@@ -981,6 +981,34 @@ async function runCraftAchievementBackfill(deps = {}) {
   }
 }
 
+// task 1004958: name the tasks that have no short name yet — every task created
+// before names existed, and any row a path outside createTask inserted. Pure DB,
+// idempotent (it writes only `short_name IS NULL` rows), and bounded: at most
+// TASK_NAME_BATCHES batches a run, so the first run on a big board drains it in
+// one go and every later run is one indexed read that finds next to nothing.
+const TASK_NAME_BATCHES = 20;
+async function runTaskNameBackfill(deps = {}) {
+  const { logFn, errFn } = loggers(deps);
+  const tasksDb = (deps.tasksDb && typeof deps.tasksDb.backfillTaskNames === 'function')
+    ? deps.tasksDb
+    : require('./task-name-db.js');
+  const exec = deps.pool || seams.pool;
+  let named = 0;
+  try {
+    for (let i = 0, after = 0; i < TASK_NAME_BATCHES; i++) {
+      const out = await tasksDb.backfillTaskNames({ exec, after });
+      named += out.named;
+      after = out.next;
+      if (!out.scanned) break;
+    }
+    if (named) logFn(`[publish-reconciler] task names: ${named} task(s) named`);
+    return { named };
+  } catch (e) {
+    errFn(`[publish-reconciler] task name backfill (non-blocking): ${e && e.message}`);
+    return { skipped: 'error', error: e && e.message, named };
+  }
+}
+
 // The sweeps one tick fires. Each is INDEPENDENT on purpose: the cost (task 1366)
 // and criterion (task 1002069) sweeps are pure DB — no push credential — and a
 // failure in either must never touch the confirmed→shipped work.
@@ -989,7 +1017,7 @@ async function runCraftAchievementBackfill(deps = {}) {
 // between runs; none means every tick (INTERVAL_MS). The publish, cost and
 // criterion sweeps keep the tick — a strand, an unpriced session and a newly
 // satisfiable criterion are all things someone is waiting on. The promotion sweep
-// and the craft backfill run HOURLY: the ship-time triggers already promote and
+// and the craft and task-name backfills run HOURLY: the ship-time triggers already promote and
 // unlock on the event, so these are backlog drains, and a drain an hour late
 // costs nobody anything while running it every 5 minutes cost every instance
 // ~288 scans a day.
@@ -1000,6 +1028,7 @@ const SWEEPS = [
   ['criterion sweep', runCriterionSweep],
   ['promotion sweep', runPromotionSweep, HOURLY_MS],
   ['craft achievement backfill', runCraftAchievementBackfill, HOURLY_MS],
+  ['task name backfill', runTaskNameBackfill, HOURLY_MS],
 ];
 
 // buildTick — one interval round, with a per-sweep overlap guard (task 1004924).
@@ -1083,6 +1112,7 @@ module.exports = {
   runPromotionSweep,
   runCriterionSweep,
   runCraftAchievementBackfill,
+  runTaskNameBackfill,
   buildTick,
   couldBeStaleGenerated,
   describeTarget,

package/modules/lifecycle/rebase-gate.js

@@ -70,8 +70,9 @@ function splitRebaseGate(rows, { limit = gateLimit() } = {}) {
 // the hint and the CLI can say "waiting, not on you".
 function rebaseRefusalTasks(split) {
   return [
-    ...split.gating.map((t) => ({ id: t.id, title: t.title, reason: t.needs_rebase_reason })),
-    ...split.waiting.map((t) => ({ id: t.id, title: t.title, reason: t.needs_rebase_reason, waiting: true, waits_on: t.waits_on })),
+    // task 1004958: short_name rides along so every surface can write "task N - name".
+    ...split.gating.map((t) => ({ id: t.id, short_name: t.short_name || null, title: t.title, reason: t.needs_rebase_reason })),
+    ...split.waiting.map((t) => ({ id: t.id, short_name: t.short_name || null, title: t.title, reason: t.needs_rebase_reason, waiting: true, waits_on: t.waits_on })),
   ];
 }
 

package/modules/lifecycle/routes/claims.js

@@ -100,12 +100,13 @@ function taskNotReadyHint(taskId, currentStatus) {
 // task 1004788: only the FIXABLE tasks gate (rebase-gate.js); a task set aside
 // because it waits on something outside the builder is listed after them as
 // "waiting, not on you" so nobody chases it.
+const { taskRef } = require('../task-name.js'); // task 1004958
 function rebaseRequiredHint(rebaseTasks) {
   const all = rebaseTasks || [];
-  const ids = all.filter((t) => !t.waiting).map((t) => `task ${t.id}`);
+  const ids = all.filter((t) => !t.waiting).map((t) => taskRef(t.id, t.short_name));
   const waiting = all.filter((t) => t.waiting);
   const aside = waiting.length
-    ? ` Waiting, not on you (set aside; they land on their own when what they wait on clears): ${waiting.map((t) => `task ${t.id} (${t.waits_on || 'outside you'})`).join('; ')}.`
+    ? ` Waiting, not on you (set aside; they land on their own when what they wait on clears): ${waiting.map((t) => `${taskRef(t.id, t.short_name)} (${t.waits_on || 'outside you'})`).join('; ')}.`
     : '';
   return `Your queue is gated: ${ids.length} confirmed task(s) of yours are waiting to land and need you (${ids.join(', ') || 'unknown'}).${aside} Clear it with /strand-fix N (works on any machine), or bring the branch up to date with \`git merge origin/main\` and re-ship — MERGE, never rebase: server-mediated publish is append-only, and rewriting a published branch makes it un-pushable (task 1002788). /merge-mode only if this machine has a GitHub push credential. To give up on one instead, /builder-release it. If CI is simply backed up, waiting is correct: a task already landed clears the gate on its own. If main's CI is red for a reason outside your branch, the fix is still claimable: a P1 kind=infra task passes this gate (task 1004370).`;
 }

package/modules/lifecycle/routes/pay-type-gates.js

@@ -0,0 +1,59 @@
+'use strict';
+
+// modules/lifecycle/routes/pay-type-gates.js — read, and record, the gate each pay type
+// must clear before it can be put on a task (task 1004991, goal 1000092; ADR 0385
+// "Pay-type gates"). The rules live in ../pay-type-gates.js; this file is the doorway.
+//
+// GET /pay-type-gates — every pay type's gate: each requirement, whether it is met, the
+//   evidence reference, and who cleared it and when. eu_labour is listed as never clearable.
+// PUT /pay-type-gates/:payType/:requirement — body { state: 'cleared'|'revoked',
+//   evidence_ref } (or { state: 'cleared', acknowledged: true } for the self-managed
+//   acknowledgement). Appends one record; the recorder is the signed-in owner, never the
+//   body. Clearing a real gate is a person's act, so nothing here clears one by itself.
+//
+// MODULE BOUNDARY: reaches core only through `../../../src/module-api`.
+
+const express = require('express');
+const api = require('../../../src/module-api');
+const gates = require('../pay-type-gates');
+
+const log = api.logger('lifecycle');
+
+module.exports = function buildPayTypeGatesRouter() {
+  const router = express.Router();
+
+  // rank: any-builder for met/missing (the same pay information `GET /pay-terms` shows, no person's
+  // money); the evidence references and who cleared each requirement are the owner's records, so
+  // they come back for an archon only.
+  router.get('/pay-type-gates', api.requireBuilder, async (req, res) => {
+    try {
+      const all = await gates.readGates();
+      res.json({ gates: req.builder.rank === 'archon' ? all : all.map(gates.withoutEvidence) });
+    } catch (err) {
+      log.error(`GET /pay-type-gates: ${err && err.message}`);
+      res.fail('pay_type_gates_read_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  // rank: payout.approve (archon floor). Whether a pay type is legal for this project is the
+  // owner's call, often with counsel, and it is the same authority that approves payouts — no new
+  // atom is minted for it (ADR 0016: enforced here, on the server).
+  router.put('/pay-type-gates/:payType/:requirement', api.requireBuilder, api.requirePermission('payout.approve'), async (req, res) => {
+    const { payType, requirement } = req.params;
+    // Unknown fields (a forged cleared_by, say) are refused here; the values are checked by the lib.
+    if (api.validateOrRespond(req, res, { state: {}, evidence_ref: {}, acknowledged: {} })) return;
+    const parsed = gates.normalizeGateWrite(payType, requirement, req.body);
+    if (parsed.error) return res.fail(parsed.code, { status: parsed.status, message: parsed.error });
+    try {
+      const gate = await gates.recordRequirement({
+        payType, requirement, state: parsed.state, evidenceRef: parsed.evidenceRef, builderId: req.builder.id,
+      });
+      res.json({ ok: true, gate });
+    } catch (err) {
+      log.error(`PUT /pay-type-gates: ${err && err.message}`);
+      res.fail('pay_type_gates_write_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  return router;
+};

package/modules/lifecycle/routes/project-settings.js

@@ -35,6 +35,7 @@ const api = require('../../../src/module-api');
 const goalCategory = require('../goal-category');
 const autopickup = require('../autopickup');
 const payTermsLib = require('../pay-terms'); // task 1004990
+const payTypeGates = require('../pay-type-gates'); // task 1004991
 
 const log = api.logger('lifecycle');
 
@@ -551,6 +552,9 @@ module.exports = function buildProjectSettingsRouter() {
     const parsed = payTermsLib.normalizePayTerms(req.body.terms);
     if (parsed.error) return res.fail('bad_pay_terms', { status: 400, message: parsed.error });
     try {
+      // task 1004991: the project's standing terms obey the same gate as a task's (ADR 0385).
+      const gateRefusal = await payTypeGates.refuseUnclearedGates(parsed.terms);
+      if (gateRefusal) return res.fail(gateRefusal.code, { status: 409, message: gateRefusal.message });
       await payTermsLib.setPayTerms({ taskId: null, terms: parsed.terms, builderId: req.builder.id });
       const policy = await payTermsLib.readProjectPayTerms();
       res.json({ ok: true, row: payTermsRow(policy) });