982f51f · e3c4f7f · e00c14a · 42fc628 · 27abc4b · 3506587
@@ -0,0 +1,12 @@
# The Later gate in plain sight (#8700)
The Later gate (`Later gate: …`, read by `core/pillars.ts`) holds work back from the crew. A person is told so where they look:
- **Home** says, per repository you write, `N issues are held behind the Later gate in <repo>, set by <who> <when>` (`web/studio/held.ts`), and the line opens `/:owner/:name/held`.
- **A held issue** says so at its top, with **Lift** (`web/pages/gate.ts`). Lift is `liftHold` (`actions/gate.ts`): the issue stops waiting for the gate, and its `Later` label goes with it. The MCP `lift` tool is the same action.
- **The label and the gate are one thing.** Giving an issue `Later` puts it behind the gate; taking `Later` off lifts it (`followLabel`, called from `setIssueLabels`). The other direction, an edge changing the label, was already `actions/pillars.ts`.
- **The pass over the lot** (`/:owner/:name/held`, MCP `held`, the terminal's held screen) reads titles only, with no model and no run (`core/gate_triage.ts`). Unchosen ideas are dropped, not tracked (Shape Up): every held issue is a candidate to close, grouped by the word its titles share most. Only one the crew found done on main starts ticked; **unticked is keep**. An issue that open work waits for says so on its row, because closing it parks that work (`dropped` holds dependents). One button closes the ticked (`applyGateReview`). The form carries a digest of the candidates shown (`reviewDigest`, their sorted numbers); if the gate holds other issues when it is applied, it refuses and closes nothing. An agent may read the proposal and never applies it.
- **Closed ones stay findable.** The apply writes the `issue.gate_reviewed` event after each close, and a comment note beside it. The event, not the note, is the marker (`closedByReview`): it is the review's only while it is newer than the issue's last close and reopen, and a comment cannot forge it. Each is listed under "Closed by the review" on the held page and shows **Revive** at its top. Revive (the same `lift` action) lets it out from behind the gate and reopens it as one outcome: the hold is checked first, and a reopen that fails puts the hold back.
- **The terminal** has the same page: `h` on a repository's issues, or "Held by the Later gate" in the palette (`tui/screens/held.ts`). `space` ticks, `A` closes the ticked, `l` lifts or revives. It reads and acts through the same functions, so a reader is refused in the same words and a private repository is not found; the web hears each write as the close, reopen and unblock events it already follows.
Not done: snoozing an issue until a date or until new activity; merging duplicates; a per-issue "keep" verdict beyond leaving the box unticked.
@@ -0,0 +1,79 @@
/**
 * The Later gate, in plain sight (#8700): lifting what it holds, and keeping
 * the `Later` label and the gate one thing. The gate is an edge (the issue
 * waits for the gate issue) and the label is that edge made visible
 * (`actions/pillars.ts` writes the label when the edge changes); this is the
 * other direction, so a person who sets or removes the label by hand changes
 * the edge too, and lifting by either road reads the same.
 */
import type { App } from "../app.ts";
import { closedByReview, gateHolding, gateOf } from "../core/gate_hold.ts";
import type { Issue, Label } from "../core/issues.ts";
import { isStructural, LATER, pillarsOf } from "../core/pillars.ts";
import type { Repo } from "../core/repos.ts";
import type { User } from "../core/users.ts";
import { err, ok, type Result } from "../kernel/result.ts";
import { isMirror } from "../origins/write-through.ts";
import type { DependencyError } from "../core/dependencies.ts";
import type { AccessError } from "./access.ts";
import { linkIssue, unlinkIssue } from "./dependencies.ts";
import { setIssueState } from "./issues.ts";
/** Whether a label set carries the `Later` label. */
export const hasLater = (labels: readonly Pick<Label, "name">[]): boolean =>
  labels.some((l) => l.name.toLowerCase() === LATER.toLowerCase());
/**
 * Let the issue go from behind the gate: it waits for the gate no more, and
 * its `Later` label goes with it. One the gate review closed is reopened as
 * part of it: an idea that matters comes back with one tap. The hold is
 * checked first, and a reopen that fails puts the hold back, so the answer
 * is the whole outcome. One action, the same for a person and an agent;
 * whoever may link may lift.
 */
export function liftHold(
  app: App,
  actor: User | undefined,
  repo: Repo,
  issue: Issue,
): Result<Issue, AccessError | "not_held"> {
  const revive = closedByReview(app.db, issue);
  const gate = revive ? gateOf(app.db, repo, issue) : gateHolding(app.db, repo, issue);
  if (gate === undefined) return err("not_held");
  const lifted = unlinkIssue(app, actor, repo, issue, gate);
  if (!lifted.ok) return lifted;
  if (!revive) return ok(issue);
  const reopened = setIssueState(app, actor, repo, issue, "open");
  if (!reopened.ok) {
    linkIssue(app, actor, repo, issue, gate);
    return err(reopened.error === "unauthorized" || reopened.error === "not_found" ? reopened.error : "forbidden");
  }
  return ok(reopened.value);
}
/**
 * Labels were just replaced by hand. Giving an issue `Later` puts it behind
 * the gate; taking `Later` off lifts it. Nothing happens where the
 * repository has no gate, for the issue is the plan's own furniture, or for
 * a mirror (its labels are its origin's). A link or unlink that fails is
 * returned, so the caller never leaves the label and the gate apart.
 */
export function followLabel(
  app: App,
  actor: User,
  repo: Repo,
  issue: Issue,
  before: readonly Pick<Label, "name">[],
  after: readonly Pick<Label, "name">[],
): Result<void, AccessError | DependencyError> {
  const was = hasLater(before);
  const is = hasLater(after);
  if (was === is || issue.kind !== "issue" || isMirror(app, repo)) return ok(undefined);
  const set = pillarsOf(app.db, repo);
  if (set.gate === undefined || isStructural(set, issue.id)) return ok(undefined);
  const holding = gateHolding(app.db, repo, issue) !== undefined;
  if (is && !holding) return linkIssue(app, actor, repo, issue, set.gate);
  if (!is && holding) return unlinkIssue(app, actor, repo, issue, set.gate);
  return ok(undefined);
}
@@ -0,0 +1,118 @@
/**
 * The one-time pass over what the Later gate holds (#8700): the candidates
 * (`core/gate_triage.ts`) read for a repository, and applied on one approval.
 * Applying closes what the person ticked; what they left unticked stays
 * behind the gate. A closed issue keeps a "Gate review:" note and the
 * `issue.gate_reviewed` event only this path writes, which is how it is found
 * again and revived (`liftHold`). The approval carries a digest of the
 * candidates the person read; if the gate holds other issues now, the apply
 * refuses. A person approves — an agent may read the proposal and never
 * apply it.
 */
import { createHash } from "node:crypto";
import type { App } from "../app.ts";
import { alreadyDone } from "../core/done_on_main.ts";
import { heldIssues, REVIEW_NOTE } from "../core/gate_hold.ts";
import { startsTicked, triage, type Theme, type Triaged } from "../core/gate_triage.ts";
import { getIssue } from "../core/issues.ts";
import { pillarsOf } from "../core/pillars.ts";
import { canWrite, type Repo } from "../core/repos.ts";
import type { User } from "../core/users.ts";
import { err, ok, type Result } from "../kernel/result.ts";
import { addComment, setIssueState } from "./issues.ts";
export interface GateReview {
  readonly themes: readonly Theme[];
  /** Every held issue as a candidate to close. */
  readonly changes: readonly Triaged[];
  /** The numbers that start ticked: what the crew found done on main. */
  readonly ticked: readonly number[];
  /** Names the candidates shown; the apply must carry it back. */
  readonly digest: string;
  readonly held: number;
}
/** A short name for a set of issue numbers, whatever their order. */
export function reviewDigest(numbers: readonly number[]): string {
  const sorted = [...numbers].sort((a, b) => a - b).join(",");
  return createHash("sha256").update(sorted).digest("hex").slice(0, 16);
}
/** How many open issues wait for each of these, in one read. */
function waitingOn(app: App, ids: readonly string[]): Map<string, number> {
  const out = new Map<string, number>();
  if (ids.length === 0) return out;
  const rows = app.db
    .query<{ blocked_by_id: string; n: number }, string[]>(
      `SELECT d.blocked_by_id, COUNT(*) AS n FROM issue_dependency d
         JOIN issue ON issue.id = d.issue_id
        WHERE issue.state = 'open' AND d.blocked_by_id IN (${ids.map((_, i) => `?${i + 1}`).join(",")})
        GROUP BY d.blocked_by_id`,
    )
    .all(...ids);
  for (const r of rows) out.set(r.blocked_by_id, r.n);
  return out;
}
/** What the gate holds, triaged by title: one read. */
export function reviewGate(app: App, repo: Repo): GateReview | undefined {
  const set = pillarsOf(app.db, repo);
  if (set.gate === undefined) return undefined;
  const held = heldIssues(app.db, repo, set);
  const ids = held.map((i) => i.id);
  const done = alreadyDone(app.db, ids);
  const waiting = waitingOn(app, ids);
  const themes = triage(
    held.map((i) => ({ number: i.number, title: i.title, waiting: waiting.get(i.id) ?? 0 })),
    new Set(held.filter((i) => done.has(i.id)).map((i) => i.number)),
  );
  const changes = themes.flatMap((t) => t.items);
  return {
    themes,
    changes,
    ticked: changes.filter(startsTicked).map((c) => c.number),
    digest: reviewDigest(changes.map((c) => c.number)),
    held: held.length,
  };
}
export type ApplyError = "not_found" | "forbidden" | "stale";
/**
 * Apply the approval the person gave: `approved` are the issue numbers they
 * ticked and `digest` names the candidates they read. If the gate holds other
 * issues now, or an approved one is not a candidate, the whole is refused, so
 * a person never approves what they did not read. Returns how many closed.
 */
export function applyGateReview(
  app: App,
  actor: User,
  repo: Repo,
  approved: readonly number[],
  digest: string | undefined,
): Result<number, ApplyError> {
  if (actor.kind === "agent" || !canWrite(app.db, repo, actor)) return err("forbidden");
  const review = reviewGate(app, repo);
  if (review === undefined) return err("not_found");
  if (digest !== review.digest) return err("stale");
  const proposed = new Map(review.changes.map((c) => [c.number, c.verdict]));
  if (!approved.every((n) => proposed.has(n))) return err("stale");
  let closed = 0;
  for (const number of new Set(approved)) {
    const issue = getIssue(app.db, repo.id, number);
    const verdict = proposed.get(number)!;
    if (issue === undefined || issue.state !== "open") continue;
    if (!setIssueState(app, actor, repo, issue, "closed", { reason: verdict.reason }).ok) continue;
    // The marker follows the close, never the other way: a failed close leaves none.
    app.bus.append({
      kind: "issue.gate_reviewed",
      repoId: repo.id,
      actorId: actor.id,
      payload: { number: issue.number },
    });
    addComment(app, actor, repo, issue, `${REVIEW_NOTE}closed: ${verdict.why}. Revive it from the held page to bring it back.`);
    closed++;
  }
  return ok(closed);
}
@@ -68,6 +68,7 @@
import {
} from "../origins/import.ts";
import { err, ok, type Result } from "../kernel/result.ts";
import { clearFirst } from "../core/first.ts";
import { followLabel } from "./gate.ts";
import { inheritPillar } from "./pillars.ts";
import {
  requireParticipant,
@@ -705,6 +706,7 @@
export function setIssueLabels(
    if (!label) return err("unknown_label");
    if (!resolved.some((l) => l.id === label.id)) resolved.push(label);
  }
  const before = labelsFor(app.db, issue.id);
  writeLabels(
    app.db,
    issue.id,
@@ -716,6 +718,13 @@
export function setIssueLabels(
    actorId: writer.value.id,
    payload: { number: issue.number, labels: resolved.map((l) => l.name) },
  });
  // `Later` is the Later gate made visible: changing the label changes the gate.
  const followed = followLabel(app, writer.value, repo, issue, before, resolved);
  if (!followed.ok) {
    // The label and the gate move together or not at all.
    writeLabels(app.db, issue.id, before.map((l) => l.id));
    return err("forbidden");
  }
  return ok(labelsFor(app.db, issue.id));
}
@@ -38,6 +38,7 @@
const READER_KINDS: ReadonlySet<string> = new Set([
  "issue.labeled",
  "issue.first",
  "issue.closed",
  "issue.gate_reviewed",
  "issue.commented",
  "usage.delta",
  "issue.raised",
@@ -0,0 +1,159 @@
/**
 * What the Later gate holds (#8700): the open issues that wait behind it, who
 * set the gate and when, read from the same edges `core/pillars.ts` reads.
 * Nothing is stored. The gate is the plan's own issue, so "who set it" is its
 * author and "when" is the day it was opened.
 */
import type { Database } from "bun:sqlite";
import { getIssue, type Issue } from "./issues.ts";
import { isStructural, pillarsOf, type Pillars } from "./pillars.ts";
import type { Repo } from "./repos.ts";
export interface GateHold {
  readonly gate: Issue;
  /** Open issues waiting behind the gate, not counting the plan's furniture. */
  readonly held: number;
  /** Who opened the gate. */
  readonly by: string;
  /** When it was opened, an ISO instant. */
  readonly since: string;
}
/** The open issues waiting behind the gate, newest first, the plan's furniture left out. */
export function heldIssues(
  db: Database,
  repo: Repo,
  set: Pillars,
  limit = 500,
): Issue[] {
  if (set.gate === undefined) return [];
  const rows = db
    .query<{ number: number }, [string, string, number]>(
      `SELECT issue.number FROM issue_dependency d
         JOIN issue ON issue.id = d.issue_id
        WHERE d.blocked_by_id = ?1 AND issue.repo_id = ?2
          AND issue.kind = 'issue' AND issue.state = 'open' AND issue.sealed = 0
        ORDER BY issue.number DESC LIMIT ?3`,
    )
    .all(set.gate.id, repo.id, limit + 8);
  const out: Issue[] = [];
  for (const row of rows) {
    const issue = getIssue(db, repo.id, row.number);
    if (issue !== undefined && !isStructural(set, issue.id)) out.push(issue);
    if (out.length === limit) break;
  }
  return out;
}
/** How many open issues wait behind the gate: one read. */
export function countHeld(db: Database, repo: Repo, set: Pillars): number {
  if (set.gate === undefined) return 0;
  const structural = [
    ...set.pillars.map((p) => p.umbrella.id),
    ...(set.later === undefined ? [] : [set.later.id]),
  ];
  const row = db
    .query<{ n: number }, string[]>(
      `SELECT COUNT(*) AS n FROM issue_dependency d
         JOIN issue ON issue.id = d.issue_id
        WHERE d.blocked_by_id = ?1 AND issue.repo_id = ?2
          AND issue.kind = 'issue' AND issue.state = 'open' AND issue.sealed = 0
          ${structural.length === 0 ? "" : `AND issue.id NOT IN (${structural.map((_, i) => `?${i + 3}`).join(",")})`}`,
    )
    .get(set.gate.id, repo.id, ...structural);
  return row?.n ?? 0;
}
/** The repository's gate hold, or nothing where there is no gate or it holds nothing. */
export function gateHold(db: Database, repo: Repo): GateHold | undefined {
  const set = pillarsOf(db, repo);
  if (set.gate === undefined) return undefined;
  const held = countHeld(db, repo, set);
  if (held === 0) return undefined;
  return {
    gate: set.gate,
    held,
    by: set.gate.authorName,
    since: set.gate.createdAt,
  };
}
/** The gate this issue waits behind, open or closed, if it does. */
export function gateOf(
  db: Database,
  repo: Repo,
  issue: Issue,
): Issue | undefined {
  if (issue.kind !== "issue") return undefined;
  const set = pillarsOf(db, repo);
  if (set.gate === undefined || isStructural(set, issue.id)) return undefined;
  const row = db
    .query<{ one: number }, [string, string]>(
      "SELECT 1 AS one FROM issue_dependency WHERE issue_id = ?1 AND blocked_by_id = ?2",
    )
    .get(issue.id, set.gate.id);
  return row === null ? undefined : set.gate;
}
/** The gate this open issue waits behind, if it does. */
export function gateHolding(
  db: Database,
  repo: Repo,
  issue: Issue,
): Issue | undefined {
  return issue.state === "open" ? gateOf(db, repo, issue) : undefined;
}
/** The note a gate review leaves on an issue it closed (`actions/gate_review.ts`). */
export const REVIEW_NOTE = "Gate review: ";
/**
 * The event only the review's apply path writes, right after the close. An
 * issue is "closed by the review" while it is the latest of this, a close and
 * a reopen on that issue: a comment cannot forge it, and a reopen followed by
 * a manual close does not read as the review's.
 */
export const GATE_REVIEWED = "issue.gate_reviewed"; // also named in `actions/gate_review.ts` and `core/event_audience.ts`
/** The newest event of a kind on `issue` (a row of `issue`), by rowid; each reads the event index by equality. */
const newest = (kind: string): string =>
  `COALESCE((SELECT MAX(e.rowid) FROM event e
    WHERE e.repo_id = issue.repo_id AND e.kind = '${kind}'
      AND json_extract(e.payload, '$.number') = issue.number), 0)`;
/** The SQL that says whether the review closed `issue`: its event is newer than the issue's last close and reopen. */
const BY_REVIEW = `(${newest(GATE_REVIEWED)} > ${newest("issue.closed")} AND ${newest(GATE_REVIEWED)} > ${newest("issue.reopened")})`;
/** Whether the gate review closed this issue, so it can be found and revived. */
export function closedByReview(db: Database, issue: Issue): boolean {
  if (issue.state !== "closed") return false;
  return (
    db
      .query<{ one: number }, [string]>(
        `SELECT 1 AS one FROM issue WHERE id = ?1 AND ${BY_REVIEW}`,
      )
      .get(issue.id) !== null
  );
}
/** The issues the gate review closed that are still behind the gate, newest first. */
export function reviewedClosed(
  db: Database,
  repo: Repo,
  set: Pillars,
  limit = 300,
): Issue[] {
  if (set.gate === undefined) return [];
  const rows = db
    .query<{ number: number }, [string, string, number]>(
      `SELECT issue.number FROM issue_dependency d
         JOIN issue ON issue.id = d.issue_id
        WHERE d.blocked_by_id = ?1 AND issue.repo_id = ?2
          AND issue.kind = 'issue' AND issue.state = 'closed' AND issue.sealed = 0
          AND ${BY_REVIEW}
        ORDER BY issue.number DESC LIMIT ?3`,
    )
    .all(set.gate.id, repo.id, limit);
  return rows.flatMap((r) => getIssue(db, repo.id, r.number) ?? []);
}
@@ -0,0 +1,89 @@
/**
 * A one-time look at what the Later gate holds (#8700), from titles alone:
 * no model, no run, nothing stored. Unchosen ideas are dropped, not tracked
 * (Shape Up): every held issue is a candidate to close, and only one the
 * crew found done on main starts ticked; the rest are the person's to tick,
 * and one that open work waits for is flagged, for closing it parks that
 * work. Unticked is keep. A closed one stays findable and one tap revives
 * it. The lot is grouped by theme, the word its titles share most. Nothing
 * here changes an issue (`actions/gate_review.ts` applies the approval).
 */
export interface Held {
  readonly number: number;
  readonly title: string;
  /** Open issues that wait for this one: closing it parks them. */
  readonly waiting: number;
}
export interface Verdict {
  readonly kind: "close";
  readonly why: string;
  readonly reason: "done" | "dropped";
}
export interface Triaged {
  readonly number: number;
  readonly title: string;
  readonly waiting: number;
  readonly verdict: Verdict;
}
export interface Theme {
  readonly name: string;
  readonly items: readonly Triaged[];
}
const STOP = new Set(
  "a an and are as at be by for from has have how in is it its of on or that the this to was we with when what who which not no can do does your you our new add make use used using into out up per via issue issues".split(
    " ",
  ),
);
/** Lowercase words of three letters or more, the stop words left out. */
export function words(text: string): string[] {
  return (text.toLowerCase().match(/[a-z][a-z0-9]{2,}/g) ?? []).filter(
    (w) => !STOP.has(w),
  );
}
/** Whether a candidate starts ticked: only one the crew found done on main. */
export const startsTicked = (t: Triaged): boolean => t.verdict.reason === "done";
/** A theme needs this many issues; a word on fewer is not a theme. */
export const THEME_MIN = 3;
/** Themes shown; the rest go under `OTHER`. */
export const THEMES_MAX = 8;
export const OTHER = "Other";
/** The candidate close for each held issue, under the theme its title belongs to. */
export function triage(
  held: readonly Held[],
  done: ReadonlySet<number> = new Set(),
): Theme[] {
  const sets = new Map(held.map((h) => [h.number, new Set(words(h.title))]));
  // A theme is a word many titles share: each issue goes under the commonest
  // of its words that is common enough, ties to the shorter, then alphabetical.
  const freq = new Map<string, number>();
  for (const s of sets.values()) for (const w of s) freq.set(w, (freq.get(w) ?? 0) + 1);
  const chosen = [...freq]
    .filter(([, n]) => n >= THEME_MIN)
    .sort((a, b) => b[1] - a[1] || a[0].length - b[0].length || a[0].localeCompare(b[0]))
    .slice(0, THEMES_MAX)
    .map(([w]) => w);
  const groups = new Map<string, Triaged[]>(chosen.map((w) => [w, []]));
  const other: Triaged[] = [];
  for (const h of held) {
    const verdict: Verdict = done.has(h.number)
      ? { kind: "close", why: "the crew found it done on main", reason: "done" }
      : { kind: "close", why: "not chosen: an idea that matters comes back", reason: "dropped" };
    const row = { number: h.number, title: h.title, waiting: h.waiting, verdict };
    const theme = chosen.find((w) => sets.get(h.number)!.has(w));
    if (theme === undefined) other.push(row);
    else groups.get(theme)!.push(row);
  }
  const out = [...groups]
    .filter(([, items]) => items.length > 0)
    .map(([name, items]) => ({ name, items }));
  return other.length === 0 ? out : [...out, { name: OTHER, items: other }];
}
@@ -57,6 +57,12 @@
export const ASKING: Readonly<Record<string, Asking>> = {
  model_grant: { does: "give an account a monthly model grant", undo: () => "`model_grant` with `usdPerMonth: 0` takes it back" },
  model_ceiling: { does: "cap an account's model spend", undo: () => "`model_ceiling` with both `null` clears it" },
  limits: { does: "change one of the forge's limits", undo: () => "`limits` with `value: \"\"` restores the default" },
  // Closing the Later gate's unchosen ideas in one go; reading its proposal asks nothing.
  held: {
    does: "close the issues the Later gate review proposed to close",
    asks: (a) => a["apply"] !== undefined,
    undo: () => "`lift` on each issue revives it",
  },
  // Secrets and credentials.
  secrets: { does: "set or remove a sealed secret", asks: not("action", "list") },
  app_env: { does: "set or unset an app's variable", asks: not("action", "list") },
@@ -0,0 +1,50 @@
import { applyGateReview, reviewGate } from "../../../actions/gate_review.ts";
import { THREAD_SAYS } from "../../../actions/thread_words.ts";
import { good, bad, type Tool, APP_ARG, planRepo, isAnswer } from "../shared.ts";
export const tool: Tool = {
  name: "held",
  doc: "`{ app, apply? }`: what the Later gate holds, grouped by theme, with each as a candidate to close, from titles alone; `apply: [numbers], digest` (a person's token; the numbers to close, and the `digest` the read gave) does it, refused if what the gate holds has moved; only `done` ones are in `approve`; `lift` revives a closed one",
  description: "What the Later gate holds, and one proposed pass over it.",
  inputSchema: {
    type: "object",
    properties: {
      app: APP_ARG,
      apply: { type: "array", items: { type: "integer", minimum: 1 }, maxItems: 1000 },
      digest: { type: "string", maxLength: 64 },
    },
    required: ["app"],
  },
  writes: true,
  run(ctx, user, args) {
    const repo = planRepo(ctx, user, args);
    if (isAnswer(repo)) return repo;
    const apply = args["apply"];
    if (apply !== undefined) {
      if (!Array.isArray(apply) || !apply.every((n) => Number.isInteger(n) && n > 0))
        return bad("invalid_apply", "apply is the list of issue numbers the proposal names");
      const done = applyGateReview(ctx.app, user, repo, apply as number[], typeof args["digest"] === "string" ? args["digest"] : undefined);
      if (!done.ok)
        return bad(
          done.error,
          done.error === "stale"
            ? "what the gate holds changed since you read it; read it again"
            : done.error === "forbidden"
              ? THREAD_SAYS.planForbidden
              : "there is no Later gate here",
        );
      return good({ says: `Closed ${done.value}.` });
    }
    const review = reviewGate(ctx.app, repo);
    if (review === undefined) return bad("not_found", "there is no Later gate here");
    return good({
      says: `${review.held} held; ${review.ticked.length} found done on main.`,
      themes: review.themes.map((t) => ({
        theme: t.name,
        issues: t.items.map((i) => ({ number: i.number, title: i.title, waiting: i.waiting, ...i.verdict })),
      })),
      approve: review.ticked,
      digest: review.digest,
    });
  },
};
@@ -65,6 +65,7 @@
export { tool as forges } from "./forges.ts";
export { tool as forks } from "./forks.ts";
export { tool as front_page } from "./front_page.ts";
export { tool as health } from "./health.ts";
export { tool as held } from "./held.ts";
export { tool as here } from "./here.ts";
export { tool as hold } from "./hold.ts";
export { tool as hooks } from "./hooks.ts";
@@ -74,6 +75,7 @@
export { tool as issue_teams } from "./issue_teams.ts";
export { tool as issues } from "./issues.ts";
export { tool as labels } from "./labels.ts";
export { tool as land_past_gate } from "./land_past_gate.ts";
export { tool as lift } from "./lift.ts";
export { tool as limb } from "./limb.ts";
export { tool as limits } from "./limits.ts";
export { tool as make_it_yours } from "./make_it_yours.ts";
@@ -0,0 +1,31 @@
import { liftHold } from "../../../actions/gate.ts";
import { THREAD_SAYS } from "../../../actions/thread_words.ts";
import { good, bad, type Tool, APP_ARG, planRepo, issueArg, isAnswer } from "../shared.ts";
export const tool: Tool = {
  name: "lift",
  doc: "`{ app, issue }`: let an issue out from behind the Later gate, as the page's Lift does; its `Later` label goes with it, and the answer carries the issue's URL",
  description: "Lift an issue out from behind the Later gate.",
  inputSchema: {
    type: "object",
    properties: { app: APP_ARG, issue: { type: "integer", minimum: 1 } },
    required: ["app", "issue"],
  },
  writes: true,
  run(ctx, user, args) {
    const repo = planRepo(ctx, user, args);
    if (isAnswer(repo)) return repo;
    const issue = issueArg(ctx, repo, args, "issue");
    if ("ok" in issue) return issue;
    const lifted = liftHold(ctx.app, user, repo, issue);
    if (!lifted.ok)
      return bad(
        lifted.error,
        lifted.error === "not_held" ? `#${issue.number} is not behind the Later gate.` : THREAD_SAYS.planForbidden,
      );
    return good({
      says: `#${issue.number} is lifted from behind the Later gate.`,
      url: `${ctx.url.origin}/${repo.ownerName}/${repo.name}/issues/${issue.number}`,
    });
  },
};
@@ -266,6 +266,7 @@
import { appNowFragment } from "../web/studio/now.ts";
import { appStateFragment } from "../web/studio/previews.ts";
import { changesList, tellsList } from "../web/studio/lists.ts";
import { dependencySubmit } from "../web/pages/thread.ts";
import { heldApply, heldPage, liftHoldSubmit } from "../web/pages/gate.ts";
import {
  assigneeSubmit,
  labelsSubmit,
@@ -1020,6 +1021,9 @@
export function buildRouter(): Router<Handler> {
    "/:owner/:name/issues/:number/dependencies",
    dependencySubmit,
  );
  router.add("POST", "/:owner/:name/issues/:number/lift", liftHoldSubmit);
  router.add("GET", "/:owner/:name/held", heldPage);
  router.add("POST", "/:owner/:name/held/apply", heldApply);
  router.add("GET", "/:owner/:name/map", mapPage);
  router.add("POST", "/:owner/:name/issues/:number/first", firstSubmit);
  router.add("GET", "/:owner/:name/milestones", milestonesPage);
@@ -73,6 +73,7 @@
import { keeperScreen } from "./screens/keeper.ts";
import { releasesScreen } from "./screens/releases.ts";
import { mayRead } from "../release/gate.ts";
import { fileHoldsPrompt } from "./screens/fileholds.ts";
import { heldScreen } from "./screens/held.ts";
import { stalledScreen } from "./screens/stalled.ts";
import { issuesScreen, newIssueScreen } from "./screens/issues.ts";
import { limbsScreen } from "./screens/limbs.ts";
@@ -109,6 +110,12 @@
const REPO_VERBS: readonly {
    title: "Issues in a repository",
    open: (f, ctx, repo) => issuesScreen(f, ctx, local(f, repo), "issue"),
  },
  {
    // What the Later gate holds, as /held shows it: reading is the repository's own.
    id: "held",
    title: "Held by the Later gate",
    open: (f, ctx, repo) => heldScreen(f, ctx, repo),
  },
  {
    id: "pulls",
    title: "Pull requests in a repository",
@@ -0,0 +1,161 @@
/**
 * What the Later gate holds, from the terminal (#8700): the held page's twin.
 * The same reads (`reviewGate`, `reviewedClosed`) and the same actions
 * (`liftHold`, `applyGateReview`) the page and the MCP tools use, so who may
 * see and who may change is theirs: a repository the viewer cannot read is
 * not found, and only a writer who is not an agent applies. The list is live;
 * a change to what the gate holds resets the ticks, so what is approved is
 * always what is shown.
 *
 *   space  tick or untick a candidate     A  close the ticked
 *   l      lift (or revive, on a closed)  enter  open the issue
 */
import { liftHold } from "../../actions/gate.ts";
import { applyGateReview, reviewGate, type GateReview } from "../../actions/gate_review.ts";
import { THREAD_SAYS } from "../../actions/thread_words.ts";
import { reviewedClosed } from "../../core/gate_hold.ts";
import { getIssue } from "../../core/issues.ts";
import { pillarsOf } from "../../core/pillars.ts";
import type { Repo } from "../../core/repos.ts";
import type { Ctx, Screen } from "../app/app.ts";
import { binding } from "../app/keys.ts";
import type { Session } from "../session.ts";
import { ListState, drawList, hitList, live, metaOf, runAsync, type ListRow } from "./common.ts";
import { issueScreen } from "./issue.ts";
import { local } from "./where.ts";
import { emptyState } from "../ui/widgets.ts";
/** One line of the screen: a candidate, or an issue the review closed. */
export interface HeldLine {
  readonly number: number;
  readonly title: string;
  readonly theme: string;
  readonly why: string;
  readonly waiting: number;
  readonly closed: boolean;
}
export interface HeldRead {
  readonly review: GateReview;
  readonly lines: readonly HeldLine[];
}
/** The gate's candidates and what it closed, or nothing where the repository has no gate. */
export function readHeld(f: Session, repo: Repo): HeldRead | undefined {
  const review = reviewGate(f.app, repo);
  if (review === undefined) return undefined;
  const lines: HeldLine[] = review.themes.flatMap((t) =>
    t.items.map((i) => ({
      number: i.number,
      title: i.title,
      theme: t.name,
      why: i.verdict.why,
      waiting: i.waiting,
      closed: false,
    })),
  );
  for (const i of reviewedClosed(f.db, repo, pillarsOf(f.db, repo)))
    lines.push({ number: i.number, title: i.title, theme: "Closed by the review", why: "revive with l", waiting: 0, closed: true });
  return { review, lines };
}
/** One row per line; a candidate shows its tick, a flagged one says closing parks work. */
export function heldRows(lines: readonly HeldLine[], ticked: ReadonlySet<number>): ListRow[] {
  return lines.map((l) => ({
    title: `${l.closed ? "   " : ticked.has(l.number) ? "[x]" : "[ ]"} #${l.number} ${l.title}`,
    meta: metaOf(
      l.theme,
      l.why,
      l.waiting > 0 ? `${l.waiting} open waits for it: closing parks it` : "",
    ),
  }));
}
export function heldScreen(f: Session, ctx: Ctx, repo: Repo): Screen {
  const state = new ListState();
  let read: HeldRead | undefined;
  let ticked = new Set<number>();
  const lines = (): readonly HeldLine[] => read?.lines ?? [];
  const reload = (): void => {
    const next = readHeld(f, repo);
    if (next?.review.digest !== read?.review.digest) ticked = new Set(next?.review.ticked ?? []);
    read = next;
    state.clamp(lines().length);
    ctx.invalidate();
  };
  const lift = (index: number): void => {
    const line = lines()[index];
    if (line === undefined) return;
    const issue = getIssue(f.db, repo.id, line.number);
    if (issue === undefined) return;
    const done = liftHold(f.app, f.user, repo, issue);
    if (done.ok) ctx.toast(`#${line.number} is lifted from behind the Later gate.`, "success");
    else ctx.toast(done.error === "not_held" ? `#${line.number} is not behind the Later gate.` : THREAD_SAYS.planForbidden, "danger");
    reload();
  };
  const apply = (): void => {
    if (read === undefined) return;
    if (f.user === undefined) return void ctx.toast("Sign in first.", "danger");
    const user = f.user;
    const digest = read.review.digest;
    const numbers = [...ticked];
    runAsync(ctx, async () => {
      const done = applyGateReview(f.app, user, repo, numbers, digest);
      if (done.ok) ctx.toast(`Closed ${done.value}.`, "success");
      else
        ctx.toast(
          done.error === "stale"
            ? "What the gate holds changed since you read it. Nothing was closed."
            : done.error === "forbidden"
              ? THREAD_SAYS.planForbidden
              : "There is no Later gate here.",
          "danger",
        );
      reload();
    });
  };
  const openAt = (index: number): void => {
    const line = lines()[index];
    if (line !== undefined) ctx.push(issueScreen(f, ctx, local(f, repo), line.number));
  };
  const toggle = (index: number): void => {
    const line = lines()[index];
    if (line === undefined || line.closed) return;
    if (!ticked.delete(line.number)) ticked.add(line.number);
    ctx.invalidate();
  };
  return {
    title: `Held · ${repo.ownerName}/${repo.name}`,
    keys: [
      binding(["j", "k"], "move"),
      binding(["space"], "tick"),
      binding(["A"], "close the ticked"),
      binding(["l"], "lift / revive"),
      binding(["enter"], "open"),
      binding(["esc", "q"], "close"),
    ],
    load(signal) {
      live(f, signal, { repoId: repo.id }, () => runAsync(ctx, async () => reload()));
      reload();
      return Promise.resolve();
    },
    render(area, s) {
      if (read === undefined) {
        emptyState(s, area, ctx.theme.c, { title: "No Later gate", body: "This repository holds nothing back." });
        return;
      }
      drawList(s, area, ctx.theme.c, state, heldRows(lines(), ticked));
      hitList(ctx, area, state, lines().length, { open: openAt });
    },
    key(e) {
      if (e.key === "esc" || e.key === "q") ctx.pop();
      else if (e.key === " " || e.key === "space") toggle(state.index);
      else if (e.key === "A") apply();
      else if (e.key === "l") lift(state.index);
      else if (e.key === "enter") openAt(state.index);
      else state.key(e, lines().length);
      return true;
    },
  };
}
@@ -44,6 +44,7 @@
import {
} from "./common.ts";
import { issueScreen } from "./issue.ts";
import { newPullScreen } from "./newpull.ts";
import { heldScreen } from "./held.ts";
import { planScreen } from "./plan.ts";
import { pullScreen } from "./pull.ts";
import { verdictsForPulls, type Verdict } from "./verdicts.ts";
@@ -272,7 +273,7 @@
export function issuesScreen(
        ...(stops() > 0 ? [binding(["P"], "pillar")] : []),
        binding(["a"], mine ? "all authors" : "only mine"),
        ...(mayWrite() ? [binding(["c"], `new ${noun}`)] : []),
        ...(kind === "issue" && repo !== undefined ? [binding(["m"], "plan")] : []),
        ...(kind === "issue" && repo !== undefined ? [binding(["m"], "plan"), binding(["h"], "held")] : []),
        binding(["/"], "search"),
        binding(["r"], "refresh"),
      ];
@@ -426,6 +427,10 @@
export function issuesScreen(
        ctx.push(planScreen(f, ctx, repo));
        return true;
      }
      if (e.key === "h" && kind === "issue" && repo !== undefined) {
        ctx.push(heldScreen(f, ctx, repo));
        return true;
      }
      if (e.key === "enter") {
        openAt(state.index);
        return true;
@@ -0,0 +1,204 @@
/**
 * The Later gate in plain sight (#8700): the banner at the top of a held
 * issue, with Lift, and the route behind it. Reading is `core/gate_hold.ts`,
 * acting is `actions/gate.ts`.
 */
import { applyGateReview, reviewGate } from "../../actions/gate_review.ts";
import { liftHold } from "../../actions/gate.ts";
import { startsTicked, type Triaged } from "../../core/gate_triage.ts";
import { pillarsOf } from "../../core/pillars.ts";
import { THREAD_SAYS } from "../../actions/thread_words.ts";
import { isCrew } from "../../core/agents.ts";
import { closedByReview, gateHolding, reviewedClosed } from "../../core/gate_hold.ts";
import type { Issue } from "../../core/issues.ts";
import { canWrite, type Repo } from "../../core/repos.ts";
import { notePhase, takeSessionTime } from "../../core/route_timing.ts";
import type { Ctx } from "../../http/context.ts";
import { crumbsFor, loadRepo, notFoundPage, repoBase, repoHeader, repoPalette, signInFirst } from "../chrome.ts";
import { readForm } from "../form.ts";
import { html, type Html } from "../html.ts";
import { flashTo, page } from "../layout.ts";
import { btn, disclosure, time } from "../ui.ts";
import { threadContext } from "./thread.ts";
/** What the banner says about the hold, and the one button that ends it. */
export function heldBanner(ctx: Ctx, repo: Repo, issue: Issue): Html | null {
  const user = ctx.auth.user;
  const base0 = repoBase(repo);
  if (closedByReview(ctx.app.db, issue))
    return html`<div class="bar" id="held" role="note">
      <span>Closed by the <a href="${base0}/held">Later gate review</a>: not chosen. An idea that matters comes back.</span>
      ${user !== undefined && canWrite(ctx.app.db, repo, user)
        ? html`<form method="post" action="${base0}/issues/${issue.number}/lift" class="inline">
            ${btn("Revive", { type: "submit", variant: "primary", size: "sm" })}
          </form>`
        : null}
    </div>`;
  const gate = gateHolding(ctx.app.db, repo, issue);
  if (gate === undefined) return null;
  const mayLift =
    user !== undefined &&
    (canWrite(ctx.app.db, repo, user) || isCrew(ctx.app.db, repo.id, user.id));
  const base = repoBase(repo);
  return html`<div class="bar" id="held" role="note">
    <span
      >Held by the <a href="${base}/held">Later gate</a>, set
      by ${gate.authorName} ${time(gate.createdAt)}. The crew picks nothing
      here until it is lifted.</span
    >
    ${mayLift
      ? html`<form method="post" action="${base}/issues/${issue.number}/lift" class="inline">
          ${btn("Lift", { type: "submit", variant: "primary", size: "sm" })}
        </form>`
      : null}
  </div>`;
}
// POST /:owner/:name/issues/:number/lift
export async function liftHoldSubmit(ctx: Ctx): Promise<Response> {
  const found = threadContext(ctx, "issue");
  if (found instanceof Response) return found;
  if (!ctx.auth.user) return signInFirst(ctx);
  const form = await readForm(ctx, "rw");
  if (form instanceof Response) return form;
  const repo = loadRepo(ctx) ?? found.repo;
  const dest = `${repoBase(repo)}/issues/${found.issue.number}`;
  const lifted = liftHold(ctx.app, ctx.auth.user, repo, found.issue);
  if (!lifted.ok)
    return flashTo(ctx, dest, {
      tone: "danger",
      message:
        lifted.error === "not_held"
          ? `#${found.issue.number} is not behind the Later gate.`
          : THREAD_SAYS.planForbidden,
    });
  return flashTo(ctx, dest, {
    message: `#${found.issue.number} is lifted from behind the Later gate.`,
  });
}
// ---- the list, and the one pass over it ----
/** One row of the review: ticked to close, and Lift to let it go instead. */
function reviewRow(base: string, mayLift: boolean, item: Triaged): Html {
  return html`<li class="bar">
    <input type="checkbox" form="apply" name="n" value="${item.number}" ${startsTicked(item) ? "checked" : ""} aria-label="Close #${item.number}" />
    <a href="${base}/issues/${item.number}">${item.title}</a>
    <span class="muted small">#${item.number} · ${item.verdict.why}</span>
    ${item.waiting > 0
      ? html`<span class="small" role="note">${item.waiting} open ${item.waiting === 1 ? "issue waits" : "issues wait"} for it: closing parks ${item.waiting === 1 ? "it" : "them"}</span>`
      : null}
    ${mayLift
      ? html`<form method="post" action="${base}/issues/${item.number}/lift" class="inline">
          ${btn("Lift", { type: "submit", size: "sm", variant: "ghost" })}
        </form>`
      : null}
  </li>`;
}
// GET /:owner/:name/held — what the gate holds, grouped by theme, with one pass proposed
export function heldPage(ctx: Ctx): Response {
  notePhase(ctx.request, "session", takeSessionTime(ctx.request));
  const repo = loadRepo(ctx);
  const review = repo === undefined ? undefined : reviewGate(ctx.app, repo);
  if (repo === undefined || review === undefined) {
    notePhase(ctx.request, "render", 0);
    return notFoundPage(ctx);
  }
  const rendering = performance.now();
  const set = pillarsOf(ctx.app.db, repo);
  const gate = set.gate!;
  const base = repoBase(repo);
  const user = ctx.auth.user;
  const mayLift =
    user !== undefined &&
    (canWrite(ctx.app.db, repo, user) || isCrew(ctx.app.db, repo.id, user.id));
  const mayApply = user !== undefined && user.kind !== "agent" && canWrite(ctx.app.db, repo, user);
  const closed = reviewedClosed(ctx.app.db, repo, set);
  const body = html`${repoHeader(ctx, repo, "issues", { compact: true })}
    <div class="page-head mt">
      <h1>Held by the Later gate</h1>
      <p class="muted">
        ${review.held} open ${review.held === 1 ? "issue waits" : "issues wait"}
        behind <a href="${base}/issues/${gate.number}">the gate</a>, set by
        ${gate.authorName} ${time(gate.createdAt)}. The crew picks none of
        them until it is lifted.
      </p>
    </div>
    <p>
      Unchosen ideas are dropped, not tracked. Tick the ones to close; only
      those the crew found done on main start ticked. An unticked issue
      stays behind the gate, and Lift lets one go. An issue that open work
      waits for says so: closing it parks that work. A closed issue stays
      findable here and one tap revives it. Nothing changes until you
      approve.
    </p>
    ${mayApply && review.changes.length > 0
      ? html`<form id="apply" method="post" action="${base}/held/apply" class="bar">
          <input type="hidden" name="digest" value="${review.digest}" />
          ${btn("Close the ticked", { type: "submit", variant: "primary" })}
        </form>`
      : null}
    <div class="stack mt">
      ${review.themes.map((t) =>
        disclosure(
          html`${t.name} <span class="muted small">${t.items.length}</span>`,
          html`<ul class="stack stack-tight">${t.items.map((i) => reviewRow(base, mayLift, i))}</ul>`,
        ),
      )}
      ${closed.length === 0
        ? null
        : disclosure(
            html`Closed by the review <span class="muted small">${closed.length}</span>`,
            html`<ul class="stack stack-tight">
              ${closed.map(
                (i) => html`<li class="bar">
                  <a href="${base}/issues/${i.number}">${i.title}</a>
                  <span class="muted small">#${i.number}</span>
                  ${mayLift
                    ? html`<form method="post" action="${base}/issues/${i.number}/lift" class="inline">
                        ${btn("Revive", { type: "submit", size: "sm", variant: "ghost" })}
                      </form>`
                    : null}
                </li>`,
              )}
            </ul>`,
          )}
    </div>`;
  const response = page({
    ctx,
    title: `Held · ${repo.name}`,
    crumbs: crumbsFor(repo),
    palette: repoPalette(ctx, repo),
    body,
  });
  notePhase(ctx.request, "render", performance.now() - rendering);
  return response;
}
// POST /:owner/:name/held/apply  { approved } — the proposal the person read, done
export async function heldApply(ctx: Ctx): Promise<Response> {
  const repo = loadRepo(ctx);
  if (!repo) return notFoundPage(ctx);
  if (!ctx.auth.user) return signInFirst(ctx);
  const form = await readForm(ctx, "rw");
  if (form instanceof Response) return form;
  const dest = `${repoBase(repo)}/held`;
  const approved = [...form.getAll("n")]
    .map((n) => Number(n))
    .filter((n) => Number.isInteger(n) && n > 0)
    .slice(0, 1000);
  const done = applyGateReview(ctx.app, ctx.auth.user, repo, approved, form.get("digest")?.toString());
  if (!done.ok)
    return flashTo(ctx, dest, {
      tone: "danger",
      message:
        done.error === "stale"
          ? "What the gate holds changed since you read it. Nothing was closed; read it again."
          : done.error === "forbidden"
            ? THREAD_SAYS.planForbidden
            : "There is no Later gate here.",
    });
  return flashTo(ctx, dest, { message: `Closed ${done.value}.` });
}
@@ -0,0 +1,51 @@
/**
 * Home says what is being held back for a person (#8700): one line per
 * repository whose Later gate holds open issues — how many, who set the
 * gate, when — and a link that opens the list.
 */
import { gateHold } from "../../core/gate_hold.ts";
import { reposWithUmbrellas } from "../../core/pillars.ts";
import { canWrite, listReposOwnedBy, type Repo } from "../../core/repos.ts";
import type { User } from "../../core/users.ts";
import type { Ctx } from "../../http/context.ts";
import { repoBase } from "../chrome.ts";
import { html, type Html } from "../html.ts";
import { time } from "../ui.ts";
import { writableAppsOf } from "./asks.ts";
/** The repositories whose gate holds work back from this person, with the hold. */
function holds(ctx: Ctx, user: User) {
  const db = ctx.app.db;
  const own = listReposOwnedBy(db, user.id);
  const byId = new Map<string, Repo>(own.map((r) => [r.id, r]));
  for (const r of writableAppsOf(ctx, user).repos) byId.set(r.id, r);
  const withUmbrellas = reposWithUmbrellas(db, [...byId.keys()]);
  const out = [];
  for (const id of withUmbrellas) {
    const repo = byId.get(id)!;
    if (!canWrite(db, repo, user)) continue;
    const hold = gateHold(db, repo);
    if (hold !== undefined) out.push({ repo, hold });
  }
  return out;
}
/** One line for each gate that holds work back; nothing where none does. */
export function heldLine(ctx: Ctx, user: User): Html | null {
  const found = holds(ctx, user);
  if (found.length === 0) return null;
  return html`<section class="stack stack-tight" id="held-line" aria-label="Held back">
    ${found.map(
      ({ repo, hold }) =>
        html`<p class="small">
          <a href="${repoBase(repo)}/held"
            >${hold.held} ${hold.held === 1 ? "issue is" : "issues are"} held
            behind the Later gate</a
          >
          in ${repo.name}, set by ${hold.by} ${time(hold.since)}. Nothing there
          starts until you lift it.
        </p>`,
    )}
  </section>`;
}
@@ -52,6 +52,7 @@
import { writableAppsOf } from "./asks.ts";
import { needsYouSection } from "./asks_page.ts";
import { flowCards } from "./flow_card.ts";
import { composer, feedJs, feedNote, feedRegion, registerWorkerJs } from "./feed.ts";
import { heldLine } from "./held.ts";
import { appChips, movingRegion, tellBox } from "./living.ts";
import { alarmLines, cachedAlarms } from "./alarm_lines.ts";
import { kpiRow, waitingLine } from "./kpi_row.ts";
@@ -299,7 +300,7 @@
export async function studioHome(
  ) {
    const apps = await clientApps(ctx, user);
    const lean = html`<h1 class="sr-only">Home</h1>
      ${firstSteps} ${address} ${crewKeyNote(ctx)} ${apps}
      ${firstSteps} ${address} ${crewKeyNote(ctx)} ${heldLine(ctx, user)} ${apps}
      <div class="stack">
        ${composer(ctx, user)}
        <p class="small muted">
@@ -327,6 +328,7 @@
export async function studioHome(
  const body = html`<h1 class="sr-only">Home</h1>
    ${tellBox(ctx, user)}
    ${ask} ${address}
    ${timePhase(ctx.request, "held", () => heldLine(ctx, user))}
    <section class="stack" aria-label="The forge">${kpis}</section>
    ${timePhase(ctx.request, "moving", () => movingRegion(ctx.app.db, user))}
    ${appChips(ctx, user)}
@@ -19,6 +19,7 @@
import { getAppByRepo } from "../../core/apps.ts";
import { LATER_TITLED } from "../../core/pillars.ts";
import { deferredOf, linkedIssueIds } from "../../core/dependencies.ts";
import { hasPicture } from "../../core/note_pictures.ts";
import { heldBanner } from "../pages/gate.ts";
import {
  getIssuesByNumbers,
  labelsFor,
@@ -564,6 +565,7 @@
async function studioTell(
      ownTitle: true,
    })}
    ${head}
    ${heldBanner(ctx, repo, issue)}
    <div class="split">
      <div>
        ${talk.node} ${doneLine}
@@ -123,7 +123,7 @@
describe("the one list of what asks first", () => {
    "access", "account_verify", "app_members", "app_notes", "asks_act", "asks_decide", "asks_proposal", "asks_undecide",
    "assign", "attach_look", "board_pins", "board_write", "branches", "capacity", "cloud_accounts", "close", "confirm_wait",
    "crew", "decisions_by", "detach", "edit", "email_verify", "feed_chips", "feed_dismiss", "flag_set", "flag_winner",
    "follow_mode", "front_page", "hold", "issue_teams", "labels", "limb", "make_it_yours", "map", "merge", "new_app",
    "follow_mode", "front_page", "hold", "issue_teams", "labels", "lift", "limb", "make_it_yours", "map", "merge", "new_app",
    "notify", "org_create", "origin_apps", "pins", "plan", "profile", "propose_to_parent_forge", "repo_labels", "reports",
    "restore_drill", "review", "say", "signup", "snapshot_now", "spend", "steer", "sync", "take_back", "take_updates",
    "teams", "tell", "threads", "trail", "upstream", "variant", "wait_for", "watch", "whoami_can", "write_file",
@@ -5,6 +5,7 @@
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { listEvents } from "../src/core/events.ts";
import { closedByReview, reviewedClosed } from "../src/core/gate_hold.ts";
import { askToLiveByPillar } from "../src/core/pillars.ts";
let root = "";
@@ -63,3 +64,14 @@
test("the window of merged pulls walks the merged ones, not the repository's iss
  expect(lines.join("\n")).toContain("pull_merged");
  expect(lines.join("\n")).not.toContain("issue_repo_updated");
});
test("whether the Later gate review closed an issue reads the event index, not the table", () => {
  const one = plans(() => void closedByReview(app.db, { id: "i", state: "closed" } as never));
  expect(one.join("\n")).toContain("SEARCH e USING");
  noScan(one.filter((l) => !/^SCAN issue|SEARCH issue/.test(l)));
  const many = plans(
    () => void reviewedClosed(app.db, { id: "r" } as never, { gate: { id: "g" } } as never),
  );
  expect(many.join("\n")).toContain("SEARCH e USING");
  noScan(many);
});
@@ -0,0 +1,394 @@
/**
 * The Later gate in plain sight (#8700): home says what it holds, who set it
 * and when; a held issue says so at its top with Lift; the `Later` label and
 * the gate are one thing; and one pass over the lot proposes what to close.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { linkIssue, unlinkIssue } from "../src/actions/dependencies.ts";
import { applyGateReview, reviewGate } from "../src/actions/gate_review.ts";
import { liftHold } from "../src/actions/gate.ts";
import { addComment, openIssue, setIssueLabels, setIssueState } from "../src/actions/issues.ts";
import { createLabel, createRepo } from "../src/actions/repos.ts";
import { closedByReview, gateHold, gateHolding, reviewedClosed } from "../src/core/gate_hold.ts";
import { startsTicked, triage } from "../src/core/gate_triage.ts";
import { pillarsOf } from "../src/core/pillars.ts";
import { createToken } from "../src/core/tokens.ts";
import { getIssueById, labelsFor, type Issue } from "../src/core/issues.ts";
import { getRepoById, type Repo } from "../src/core/repos.ts";
import { createUser, getUserByName, type User } from "../src/core/users.ts";
import { serve, type Servers } from "../src/http/server.ts";
describe("the Later gate in plain sight", () => {
  let dataDir: string;
  let app: App;
  let servers: Servers;
  let alice: User;
  let repo: Repo;
  let cookie = "";
  let gate: Issue;
  const fresh = () => getRepoById(app.db, repo.id)!;
  const current = (i: Issue) => getIssueById(app.db, i.id)!;
  const open = (title: string): Issue => {
    const made = openIssue(app, alice, fresh(), { title });
    if (!made.ok) throw new Error(String(made.error));
    return made.value;
  };
  const names = (i: Issue) => labelsFor(app.db, i.id).map((l) => l.name);
  const holds = (i: Issue) => gateHolding(app.db, fresh(), current(i)) !== undefined;
  const labels = (i: Issue, to: string[]) => {
    const set = setIssueLabels(app, alice, fresh(), current(i), to);
    if (!set.ok) throw new Error(String(set.error));
  };
  const get = async (path: string) =>
    (await fetch(`${servers.url}${path}`, { headers: { cookie } })).text();
  const post = (path: string, body: Record<string, string> = {}) =>
    fetch(`${servers.url}${path}`, {
      method: "POST",
      headers: { cookie, origin: servers.url },
      body: new URLSearchParams(body),
      redirect: "manual",
    });
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-later-gate-"));
    app = createApp({ dataDir, port: 0 });
    servers = await serve(app);
    const made = await createUser(app.db, {
      origin: "seed",
      trusted: true,
      username: "alice",
      email: "[email protected]",
      password: "a-good-passphrase",
      adminIfFirst: true,
    });
    if (!made.ok) throw new Error(made.error);
    alice = getUserByName(app.db, "alice")!;
    const created = await createRepo(app, alice, { name: "engine", visibility: "public" });
    if (!created.ok) throw new Error(String(created.error));
    repo = created.value;
    const signin = await fetch(`${servers.url}/signin`, {
      method: "POST",
      headers: { origin: servers.url },
      body: new URLSearchParams({ username: "alice", password: "a-good-passphrase" }),
      redirect: "manual",
    });
    cookie = (signin.headers.get("set-cookie") ?? "").split(";")[0]!;
    open("P0 Trust: be trusted");
    gate = open("Later gate: nothing behind this starts until the owner opens it");
  });
  afterAll(async () => {
    await servers.stop();
    await rm(dataDir, { recursive: true, force: true });
  });
  test("a gate that holds nothing says nothing on home", async () => {
    expect(gateHold(app.db, fresh())).toBeUndefined();
    expect(await get("/")).not.toContain("held-line");
  });
  test("a new gate shows up on home: how many, who set it", async () => {
    const a = open("Later thing one");
    const b = open("Later thing two");
    expect(linkIssue(app, alice, fresh(), current(a), gate).ok).toBe(true);
    expect(linkIssue(app, alice, fresh(), current(b), gate).ok).toBe(true);
    const hold = gateHold(app.db, fresh())!;
    expect(hold.held).toBe(2);
    expect(hold.by).toBe("alice");
    const home = await get("/");
    expect(home).toContain('id="held-line"');
    expect(home).toContain("2 issues are held");
    expect(home).toContain("set by alice");
    expect(home).toContain("/alice/engine/held");
  });
  test("a held issue says so at its top with Lift, and Lift lifts it", async () => {
    const i = open("Held by the gate");
    linkIssue(app, alice, fresh(), current(i), gate);
    expect(names(i)).toContain("Later");
    const page = await get(`/alice/engine/issues/${i.number}`);
    expect(page).toContain('id="held"');
    expect(page).toContain(`/alice/engine/issues/${i.number}/lift`);
    const res = await post(`/alice/engine/issues/${i.number}/lift`);
    expect(res.status).toBe(303);
    expect(holds(i)).toBe(false);
    expect(names(i)).not.toContain("Later");
    expect(await get(`/alice/engine/issues/${i.number}`)).not.toContain('id="held"');
  });
  test("lifting what is not held is refused", () => {
    const i = open("Free");
    const lifted = liftHold(app, alice, fresh(), current(i));
    expect(lifted.ok).toBe(false);
  });
  test("removing the Later label lifts the hold, and adding it holds", () => {
    const i = open("Label and gate are one");
    linkIssue(app, alice, fresh(), current(i), gate);
    expect(holds(i)).toBe(true);
    labels(i, []);
    expect(holds(i)).toBe(false);
    expect(names(i)).not.toContain("Later");
    labels(i, ["Later"]);
    expect(holds(i)).toBe(true);
    expect(names(i)).toContain("Later");
  });
  test("an unrelated label change leaves the hold alone", () => {
    const i = open("Other labels");
    linkIssue(app, alice, fresh(), current(i), gate);
    const made = createLabel(app, alice, fresh(), "ui", "336699");
    if (!made.ok) throw new Error(String(made.error));
    labels(i, ["Later", "ui"]);
    expect(holds(i)).toBe(true);
  });
  test("triage makes every held issue a candidate; only one found done starts ticked", () => {
    const themes = triage(
      [
        { number: 1, title: "Search the archive", waiting: 0 },
        { number: 2, title: "Search archive export", waiting: 2 },
        { number: 3, title: "Search archive filters", waiting: 0 },
        { number: 4, title: "Paint the footer blue", waiting: 0 },
      ],
      new Set([4]),
    );
    const rows = themes.flatMap((t) => t.items);
    expect(rows.length).toBe(4);
    expect(rows.find((r) => r.number === 1)!.verdict).toMatchObject({ kind: "close", reason: "dropped" });
    expect(rows.find((r) => r.number === 4)!.verdict).toMatchObject({ kind: "close", reason: "done" });
    expect(rows.filter(startsTicked).map((r) => r.number)).toEqual([4]);
    expect(rows.find((r) => r.number === 2)!.waiting).toBe(2);
    expect(themes[0]!.items.length).toBe(3);
    expect(triage([]).length).toBe(0);
  });
  test("one approval closes what is ticked, it stays findable, and one tap revives it", async () => {
    const a = open("Idea nobody chose");
    const b = open("Idea to keep behind the gate");
    for (const i of [a, b]) linkIssue(app, alice, fresh(), current(i), gate);
    const review = reviewGate(app, fresh())!;
    expect(review.changes.map((c) => c.number)).toContain(a.number);
    expect(await get("/alice/engine/held")).toContain("Close the ticked");
    // A proposal that is not the one shown is refused whole.
    expect(applyGateReview(app, alice, fresh(), [999999], review.digest)).toEqual({ ok: false, error: "stale" });
    expect(current(a).state).toBe("open");
    const res = await post("/alice/engine/held/apply", { n: String(a.number), digest: review.digest });
    expect(res.status).toBe(303);
    expect(current(a).state).toBe("closed");
    expect(current(b).state).toBe("open");
    expect(holds(b)).toBe(true);
    // Findable: on the held page and with a Revive at the issue's top.
    expect(await get("/alice/engine/held")).toContain(`/alice/engine/issues/${a.number}/lift`);
    const closedPage = await get(`/alice/engine/issues/${a.number}`);
    expect(closedPage).toContain("Revive");
    const back = await post(`/alice/engine/issues/${a.number}/lift`);
    expect(back.status).toBe(303);
    expect(current(a).state).toBe("open");
    expect(holds(a)).toBe(false);
    expect(names(a)).not.toContain("Later");
  });
  test("an agent reads the proposal and never applies it", async () => {
    const bot = await createUser(app.db, {
      origin: "seed",
      trusted: true,
      username: "botty",
      email: "[email protected]",
      password: "a-good-passphrase",
    });
    expect(bot.ok).toBe(true);
    const agent = { ...getUserByName(app.db, "botty")!, kind: "agent" as const };
    expect(applyGateReview(app, agent, fresh(), [], reviewGate(app, fresh())!.digest)).toEqual({ ok: false, error: "forbidden" });
  });
  // ---- the review's safety, its marker, and who may do what ----
  const held = (title: string): Issue => {
    const i = open(title);
    expect(linkIssue(app, alice, fresh(), current(i), gate).ok).toBe(true);
    return i;
  };
  const proposal = () => reviewGate(app, fresh())!;
  const reviewedBy = (i: Issue) => closedByReview(app.db, current(i));
  test("the page ticks nothing unless the crew found it done, and flags what open work waits for", async () => {
    const blocker = held("Blocker the review might close");
    const waiter = open("Waits for the blocker");
    expect(linkIssue(app, alice, fresh(), current(waiter), current(blocker)).ok).toBe(true);
    expect(proposal().changes.find((c) => c.number === blocker.number)!.waiting).toBe(1);
    expect(proposal().ticked).not.toContain(blocker.number);
    const page = await get("/alice/engine/held");
    expect(page).toContain("closing parks it");
    expect(page).not.toMatch(/<input[^>]*name="n"[^>]*\bchecked\b/);
  });
  test("an apply that carries no digest, or a stale one, closes nothing", async () => {
    const a = held("Digest candidate");
    const read = proposal();
    expect(applyGateReview(app, alice, fresh(), [a.number], undefined)).toEqual({ ok: false, error: "stale" });
    // An issue newly held since the page was read changes what was shown.
    const late = held("Held after the page was read");
    expect(applyGateReview(app, alice, fresh(), [a.number], read.digest)).toEqual({ ok: false, error: "stale" });
    const res = await post("/alice/engine/held/apply", { n: String(a.number), digest: read.digest });
    expect(res.status).toBe(303);
    expect(current(a).state).toBe("open");
    expect(current(late).state).toBe("open");
    expect(applyGateReview(app, alice, fresh(), [a.number], proposal().digest)).toEqual({ ok: true, value: 1 });
  });
  test("a comment cannot forge the review's marker; a close after a reopen is not the review's", () => {
    const a = held("Forged marker candidate");
    const forged = held("Closed by a person, with a lookalike note");
    expect(addComment(app, alice, fresh(), current(forged), "Gate review: closed: not chosen.").ok).toBe(true);
    expect(setIssueState(app, alice, fresh(), current(forged), "closed").ok).toBe(true);
    expect(reviewedBy(forged)).toBe(false);
    expect(reviewedClosed(app.db, fresh(), pillarsOf(app.db, fresh())).map((i) => i.number)).not.toContain(forged.number);
    expect(applyGateReview(app, alice, fresh(), [a.number], proposal().digest).ok).toBe(true);
    expect(reviewedBy(a)).toBe(true);
    // Reopened, then closed by hand: no longer the review's.
    expect(setIssueState(app, alice, fresh(), current(a), "open").ok).toBe(true);
    expect(reviewedBy(a)).toBe(false);
    expect(setIssueState(app, alice, fresh(), current(a), "closed").ok).toBe(true);
    expect(reviewedBy(a)).toBe(false);
  });
  test("a close that does not happen leaves no marker and no note", () => {
    const a = held("Closed elsewhere first");
    const read = proposal();
    expect(setIssueState(app, alice, fresh(), current(a), "closed").ok).toBe(true);
    // Stale now: the issue left the candidates, and nothing is written.
    expect(applyGateReview(app, alice, fresh(), [a.number], read.digest).ok).toBe(false);
    expect(reviewedBy(a)).toBe(false);
    expect(app.db.query("SELECT 1 FROM comment WHERE issue_id = ?1 AND body LIKE 'Gate review:%'").get(a.id)).toBeNull();
  });
  test("lifting what is not held changes nothing, even on a closed issue", () => {
    const a = held("Closed by hand but still behind the gate");
    expect(setIssueState(app, alice, fresh(), current(a), "closed").ok).toBe(true);
    expect(liftHold(app, alice, fresh(), current(a))).toEqual({ ok: false, error: "not_held" });
    expect(current(a).state).toBe("closed");
    expect(holds(a)).toBe(false);
    // Reviewed-closed, then let out of the gate by another road: nothing to lift, and it stays closed.
    const b = held("Reviewed then unlinked");
    expect(applyGateReview(app, alice, fresh(), [b.number], proposal().digest).ok).toBe(true);
    expect(unlinkIssue(app, alice, fresh(), current(b), gate).ok).toBe(true);
    expect(liftHold(app, alice, fresh(), current(b))).toEqual({ ok: false, error: "not_held" });
    expect(current(b).state).toBe("closed");
  });
  describe("who may lift, revive and apply", () => {
    let bobCookie = "";
    let bobToken = "";
    let aliceToken = "";
    const as = (c: string, path: string, body: Record<string, string> = {}) =>
      fetch(`${servers.url}${path}`, {
        method: "POST",
        headers: { ...(c === "" ? {} : { cookie: c }), origin: servers.url },
        body: new URLSearchParams(body),
        redirect: "manual",
      });
    const mcp = async (token: string, name: string, args: unknown) => {
      const res = await fetch(`${servers.url}/mcp`, {
        method: "POST",
        headers: {
          "content-type": "application/json",
          accept: "application/json, text/event-stream",
          authorization: `Bearer ${token}`,
        },
        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
      });
      const body = (await res.json()) as any;
      const text: string = body.result.content[0].text;
      return body.result.isError === true ? { error: text } : { value: JSON.parse(text) };
    };
    beforeAll(async () => {
      const made = await createUser(app.db, {
        origin: "seed",
        trusted: true,
        username: "bob",
        email: "[email protected]",
        password: "a-good-passphrase",
      });
      if (!made.ok) throw new Error(made.error);
      const bob = getUserByName(app.db, "bob")!;
      const signin = await fetch(`${servers.url}/signin`, {
        method: "POST",
        headers: { origin: servers.url },
        body: new URLSearchParams({ username: "bob", password: "a-good-passphrase" }),
        redirect: "manual",
      });
      bobCookie = (signin.headers.get("set-cookie") ?? "").split(";")[0]!;
      bobToken = createToken(app.db, bob.id, "rw", "rw").token;
      aliceToken = createToken(app.db, alice.id, "rw", "rw").token;
    });
    test("a guest and a reader cannot lift or apply on the page; the work stays held", async () => {
      const a = held("Reader cannot lift this");
      const read = proposal();
      for (const c of ["", bobCookie]) {
        await as(c, `/alice/engine/issues/${a.number}/lift`);
        expect(holds(a)).toBe(true);
        await as(c, "/alice/engine/held/apply", { n: String(a.number), digest: read.digest });
        expect(current(a).state).toBe("open");
      }
      expect(applyGateReview(app, getUserByName(app.db, "bob")!, fresh(), [a.number], read.digest)).toEqual({
        ok: false,
        error: "forbidden",
      });
    });
    test("a reader cannot revive on the page, and sees no Revive form", async () => {
      const a = held("Reader cannot revive this");
      expect(applyGateReview(app, alice, fresh(), [a.number], proposal().digest).ok).toBe(true);
      await as("", `/alice/engine/issues/${a.number}/lift`);
      await as(bobCookie, `/alice/engine/issues/${a.number}/lift`);
      expect(current(a).state).toBe("closed");
      const page = await (await fetch(`${servers.url}/alice/engine/issues/${a.number}`, { headers: { cookie: bobCookie } })).text();
      expect(page).not.toContain(`/issues/${a.number}/lift`);
    });
    test("the MCP lift and held tools hold the same line", async () => {
      const a = held("Lifted over MCP");
      const read = await mcp(aliceToken, "held", { app: "alice/engine" });
      expect(read.value.digest).toBe(proposal().digest);
      expect(read.value.themes.length).toBeGreaterThan(0);
      expect((await mcp(bobToken, "lift", { app: "alice/engine", issue: a.number })).error).toBeDefined();
      expect(holds(a)).toBe(true);
      expect((await mcp(bobToken, "held", { app: "alice/engine", apply: [a.number], digest: read.value.digest })).error).toContain("forbidden");
      expect(current(a).state).toBe("open");
      // A writer's apply needs the digest it read.
      expect((await mcp(aliceToken, "held", { app: "alice/engine", apply: [a.number] })).error).toBeDefined();
      expect(current(a).state).toBe("open");
      const lifted = await mcp(aliceToken, "lift", { app: "alice/engine", issue: a.number });
      expect(lifted.value.says).toContain("lifted");
      expect(holds(a)).toBe(false);
      expect((await mcp(aliceToken, "lift", { app: "alice/engine", issue: a.number })).error).toContain("not_held");
    });
    test("a private repository's held page is not found by a guest or a stranger", async () => {
      const made = await createRepo(app, alice, { name: "vault", visibility: "private" });
      if (!made.ok) throw new Error(String(made.error));
      const priv = made.value;
      const mk = (title: string) => {
        const o = openIssue(app, alice, priv, { title });
        if (!o.ok) throw new Error(String(o.error));
        return o.value;
      };
      mk("P0 Trust: be trusted");
      const g = mk("Later gate: nothing behind this starts until the owner opens it");
      const h = mk("Secret held idea");
      expect(linkIssue(app, alice, priv, h, g).ok).toBe(true);
      expect((await fetch(`${servers.url}/alice/vault/held`)).status).toBe(404);
      const stranger = await fetch(`${servers.url}/alice/vault/held`, { headers: { cookie: bobCookie } });
      expect(stranger.status).toBe(404);
      expect(await stranger.text()).not.toContain("Secret held idea");
      expect(await get("/alice/vault/held")).toContain("Secret held idea");
    });
  });
});
@@ -329,6 +329,8 @@
describe("the forge over MCP", () => {
      "land_past_gate",
      "repo_labels",
      "wait_for",
      "lift",
      "held",
      "confirm_wait",
      "attach_look",
      "hold",
@@ -50,6 +50,7 @@
test("a site-admin person is offered the whole roster", () => {
    ["profile", "Open a profile", "username or org"],
    ["repo", "Open a repository", "owner/name"],
    ["issues", "Issues in a repository", "owner/name"],
    ["held", "Held by the Later gate", "owner/name"],
    ["pulls", "Pull requests in a repository", "owner/name"],
    ["milestones", "Milestones in a repository", "owner/name"],
    ["repo-usage", "Usage of a repository", "owner/name"],
@@ -132,6 +133,7 @@
test("a site-admin agent is offered the roster without the person-only entries",
    ["profile", "Open a profile", "username or org"],
    ["repo", "Open a repository", "owner/name"],
    ["issues", "Issues in a repository", "owner/name"],
    ["held", "Held by the Later gate", "owner/name"],
    ["pulls", "Pull requests in a repository", "owner/name"],
    ["milestones", "Milestones in a repository", "owner/name"],
    ["repo-usage", "Usage of a repository", "owner/name"],
@@ -188,6 +190,7 @@
test("a member person is offered the signed-in roster without the admin entries"
    ["profile", "Open a profile", "username or org"],
    ["repo", "Open a repository", "owner/name"],
    ["issues", "Issues in a repository", "owner/name"],
    ["held", "Held by the Later gate", "owner/name"],
    ["pulls", "Pull requests in a repository", "owner/name"],
    ["milestones", "Milestones in a repository", "owner/name"],
    ["repo-usage", "Usage of a repository", "owner/name"],
@@ -238,6 +241,7 @@
test("signed out, the palette offers sign-in and the public entries", () => {
    ["profile", "Open a profile", "username or org"],
    ["repo", "Open a repository", "owner/name"],
    ["issues", "Issues in a repository", "owner/name"],
    ["held", "Held by the Later gate", "owner/name"],
    ["pulls", "Pull requests in a repository", "owner/name"],
    ["milestones", "Milestones in a repository", "owner/name"],
    ["repo-usage", "Usage of a repository", "owner/name"],
@@ -0,0 +1,170 @@
/**
 * What the Later gate holds, in the terminal (#8700): `h` on a repository's
 * issues opens the held screen, the page's twin. A writer ticks and closes,
 * lifts and revives through the same actions; a reader is refused in the same
 * words and changes nothing; a private repository is not found; and the web
 * hears every write as the events its viewers already follow.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { linkIssue } from "../src/actions/dependencies.ts";
import { openIssue } from "../src/actions/issues.ts";
import { createRepo } from "../src/actions/repos.ts";
import { THREAD_SAYS } from "../src/actions/thread_words.ts";
import { createApp, type App as Forge } from "../src/app.ts";
import { gateHolding } from "../src/core/gate_hold.ts";
import { getIssueById, type Issue } from "../src/core/issues.ts";
import { getRepoById, type Repo } from "../src/core/repos.ts";
import { createUser, getUserByName, type User } from "../src/core/users.ts";
import { createForgeApp } from "../src/tui/forge.ts";
import type { TuiIdentity } from "../src/tui/session.ts";
import { headlessTerminal } from "../src/tui/term/terminal.ts";
import { quietLogs } from "./helpers/globals.ts";
import { settleApp } from "./helpers/tui.ts";
quietLogs();
describe("the Later gate, in the terminal", () => {
  let dataDir: string;
  let forge: Forge;
  let repo: Repo;
  let idea: Issue;
  let other: Issue;
  let gate: Issue;
  const fresh = () => getRepoById(forge.db, repo.id)!;
  const current = (i: Issue) => getIssueById(forge.db, i.id)!;
  const held = (i: Issue) => gateHolding(forge.db, fresh(), current(i)) !== undefined;
  function boot(user: User | undefined) {
    const terminal = headlessTerminal(140, 32);
    const identity: TuiIdentity = { sshUsername: "t", remoteAddress: "127.0.0.1", user };
    const { app } = createForgeApp(forge, identity, { terminal, exitHooks: false });
    app.start();
    const press = async (...keys: string[]) => {
      for (const key of keys) {
        const ctrl = key.startsWith("ctrl+");
        app.dispatch({ type: "key", key: ctrl ? key.slice(5) : key, ctrl, alt: false, shift: false });
      }
      await settleApp(app);
    };
    const typeText = async (text: string) => {
      for (const ch of text) app.dispatch({ type: "key", key: ch, ctrl: false, alt: false, shift: false });
      await settleApp(app);
    };
    const toHeld = async (slug: string) => {
      await settleApp(app);
      await press("ctrl+k");
      await typeText("Held by the Later gate");
      await press("enter");
      await typeText(slug);
      await press("enter");
    };
    return { text: () => app.screen.toText(), press, typeText, toHeld, stop: () => app.stop() };
  }
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-tui-held-"));
    forge = createApp({ dataDir, port: 0 });
    for (const [username, adminIfFirst] of [["alice", true], ["bob", false]] as const) {
      const made = await createUser(forge.db, {
        origin: "seed",
        trusted: true,
        username,
        email: `${username}@forge.local`,
        password: "a-good-passphrase",
        adminIfFirst,
      });
      if (!made.ok) throw new Error(made.error);
    }
    const alice = getUserByName(forge.db, "alice")!;
    const made = await createRepo(forge, alice, { name: "plan", visibility: "public" });
    if (!made.ok) throw new Error("repo");
    repo = made.value;
    const open = (r: Repo, title: string): Issue => {
      const o = openIssue(forge, alice, r, { title });
      if (!o.ok) throw new Error(String(o.error));
      return o.value;
    };
    open(fresh(), "P0 Trust: be trusted");
    gate = open(fresh(), "Later gate: nothing behind this starts until the owner opens it");
    idea = open(fresh(), "Unchosen idea about colours");
    other = open(fresh(), "Another idea about fonts");
    for (const i of [idea, other]) linkIssue(forge, alice, fresh(), current(i), gate);
    const vault = await createRepo(forge, alice, { name: "vault", visibility: "private" });
    if (!vault.ok) throw new Error("vault");
    open(vault.value, "P0 Trust: be trusted");
    const g = open(vault.value, "Later gate: nothing behind this starts until the owner opens it");
    linkIssue(forge, alice, vault.value, open(vault.value, "Secret held idea"), g);
  }, 60_000);
  afterAll(async () => {
    forge.close();
    await rm(dataDir, { recursive: true, force: true });
  });
  test("a reader sees the candidates unticked, and is refused to lift or close", async () => {
    const h = boot(getUserByName(forge.db, "bob")!);
    await h.toHeld("alice/plan");
    expect(h.text()).toContain("Unchosen idea about colours");
    expect(h.text()).toContain("[ ] #");
    expect(h.text()).not.toContain("[x]");
    await h.press("l");
    expect(h.text()).toContain(THREAD_SAYS.planForbidden);
    await h.press("space", "A");
    expect(held(idea) && held(other)).toBe(true);
    expect(current(idea).state).toBe("open");
    h.stop();
  });
  test("a guest sees a public gate and changes nothing", async () => {
    const h = boot(undefined);
    await h.toHeld("alice/plan");
    expect(h.text()).toContain("Unchosen idea about colours");
    await h.press("l");
    expect(held(idea) && held(other)).toBe(true);
    await h.press("space", "A");
    expect(current(idea).state).toBe("open");
    h.stop();
  });
  test("a private repository is not found by a reader or a guest", async () => {
    for (const user of [getUserByName(forge.db, "bob"), undefined]) {
      const h = boot(user);
      await h.toHeld("alice/vault");
      expect(h.text()).toContain("not found");
      expect(h.text()).not.toContain("Secret held idea");
      h.stop();
    }
  });
  test("a writer ticks and closes, lifts and revives, and the web hears each write", async () => {
    const heard: string[] = [];
    const off = forge.bus.subscribe((e) => {
      if (e.repoId === repo.id) heard.push(`${e.kind}:${e.payload["number"]}`);
    });
    const h = boot(getUserByName(forge.db, "alice")!);
    await h.toHeld("alice/plan");
    // Nothing is ticked until the writer ticks: the first line is the newest.
    await h.press("space");
    expect(h.text()).toContain("[x]");
    await h.press("A");
    expect(current(other).state).toBe("closed");
    expect(current(idea).state).toBe("open");
    expect(heard).toContain(`issue.closed:${other.number}`);
    expect(h.text()).toContain("Closed by the review");
    // The closed one is listed after the candidates; Revive is `l` on it.
    await h.press("j", "l");
    expect(current(other).state).toBe("open");
    expect(held(other)).toBe(false);
    expect(heard).toContain(`issue.reopened:${other.number}`);
    expect(heard).toContain(`issue.unblocked:${other.number}`);
    // And lifting an open candidate lets it out.
    await h.press("k", "l");
    expect(held(idea)).toBe(false);
    off();
    h.stop();
  });
});
		@@ -0,0 +1,12 @@
	1	# The Later gate in plain sight (#8700)
	2
	3	The Later gate (`Later gate: …`, read by `core/pillars.ts`) holds work back from the crew. A person is told so where they look:
	4
	5	- Home says, per repository you write, `N issues are held behind the Later gate in <repo>, set by <who> <when>` (`web/studio/held.ts`), and the line opens `/:owner/:name/held`.
	6	- A held issue says so at its top, with Lift (`web/pages/gate.ts`). Lift is `liftHold` (`actions/gate.ts`): the issue stops waiting for the gate, and its `Later` label goes with it. The MCP `lift` tool is the same action.
	7	- The label and the gate are one thing. Giving an issue `Later` puts it behind the gate; taking `Later` off lifts it (`followLabel`, called from `setIssueLabels`). The other direction, an edge changing the label, was already `actions/pillars.ts`.
	8	- The pass over the lot (`/:owner/:name/held`, MCP `held`, the terminal's held screen) reads titles only, with no model and no run (`core/gate_triage.ts`). Unchosen ideas are dropped, not tracked (Shape Up): every held issue is a candidate to close, grouped by the word its titles share most. Only one the crew found done on main starts ticked; unticked is keep. An issue that open work waits for says so on its row, because closing it parks that work (`dropped` holds dependents). One button closes the ticked (`applyGateReview`). The form carries a digest of the candidates shown (`reviewDigest`, their sorted numbers); if the gate holds other issues when it is applied, it refuses and closes nothing. An agent may read the proposal and never applies it.
	9	- Closed ones stay findable. The apply writes the `issue.gate_reviewed` event after each close, and a comment note beside it. The event, not the note, is the marker (`closedByReview`): it is the review's only while it is newer than the issue's last close and reopen, and a comment cannot forge it. Each is listed under "Closed by the review" on the held page and shows Revive at its top. Revive (the same `lift` action) lets it out from behind the gate and reopens it as one outcome: the hold is checked first, and a reopen that fails puts the hold back.
	10	- The terminal has the same page: `h` on a repository's issues, or "Held by the Later gate" in the palette (`tui/screens/held.ts`). `space` ticks, `A` closes the ticked, `l` lifts or revives. It reads and acts through the same functions, so a reader is refused in the same words and a private repository is not found; the web hears each write as the close, reopen and unblock events it already follows.
	11
	12	Not done: snoozing an issue until a date or until new activity; merging duplicates; a per-issue "keep" verdict beyond leaving the box unticked.
		@@ -0,0 +1,79 @@
	1	/**
	2	* The Later gate, in plain sight (#8700): lifting what it holds, and keeping
	3	* the `Later` label and the gate one thing. The gate is an edge (the issue
	4	* waits for the gate issue) and the label is that edge made visible
	5	* (`actions/pillars.ts` writes the label when the edge changes); this is the
	6	* other direction, so a person who sets or removes the label by hand changes
	7	* the edge too, and lifting by either road reads the same.
	8	*/
	9
	10	import type { App } from "../app.ts";
	11	import { closedByReview, gateHolding, gateOf } from "../core/gate_hold.ts";
	12	import type { Issue, Label } from "../core/issues.ts";
	13	import { isStructural, LATER, pillarsOf } from "../core/pillars.ts";
	14	import type { Repo } from "../core/repos.ts";
	15	import type { User } from "../core/users.ts";
	16	import { err, ok, type Result } from "../kernel/result.ts";
	17	import { isMirror } from "../origins/write-through.ts";
	18	import type { DependencyError } from "../core/dependencies.ts";
	19	import type { AccessError } from "./access.ts";
	20	import { linkIssue, unlinkIssue } from "./dependencies.ts";
	21	import { setIssueState } from "./issues.ts";
	22
	23	/** Whether a label set carries the `Later` label. */
	24	export const hasLater = (labels: readonly Pick<Label, "name">[]): boolean =>
	25	labels.some((l) => l.name.toLowerCase() === LATER.toLowerCase());
	26
	27	/**
	28	* Let the issue go from behind the gate: it waits for the gate no more, and
	29	* its `Later` label goes with it. One the gate review closed is reopened as
	30	* part of it: an idea that matters comes back with one tap. The hold is
	31	* checked first, and a reopen that fails puts the hold back, so the answer
	32	* is the whole outcome. One action, the same for a person and an agent;
	33	* whoever may link may lift.
	34	*/
	35	export function liftHold(
	36	app: App,
	37	actor: User \| undefined,
	38	repo: Repo,
	39	issue: Issue,
	40	): Result<Issue, AccessError \| "not_held"> {
	41	const revive = closedByReview(app.db, issue);
	42	const gate = revive ? gateOf(app.db, repo, issue) : gateHolding(app.db, repo, issue);
	43	if (gate === undefined) return err("not_held");
	44	const lifted = unlinkIssue(app, actor, repo, issue, gate);
	45	if (!lifted.ok) return lifted;
	46	if (!revive) return ok(issue);
	47	const reopened = setIssueState(app, actor, repo, issue, "open");
	48	if (!reopened.ok) {
	49	linkIssue(app, actor, repo, issue, gate);
	50	return err(reopened.error === "unauthorized" \|\| reopened.error === "not_found" ? reopened.error : "forbidden");
	51	}
	52	return ok(reopened.value);
	53	}
	54
	55	/**
	56	* Labels were just replaced by hand. Giving an issue `Later` puts it behind
	57	* the gate; taking `Later` off lifts it. Nothing happens where the
	58	* repository has no gate, for the issue is the plan's own furniture, or for
	59	* a mirror (its labels are its origin's). A link or unlink that fails is
	60	* returned, so the caller never leaves the label and the gate apart.
	61	*/
	62	export function followLabel(
	63	app: App,
	64	actor: User,
	65	repo: Repo,
	66	issue: Issue,
	67	before: readonly Pick<Label, "name">[],
	68	after: readonly Pick<Label, "name">[],
	69	): Result<void, AccessError \| DependencyError> {
	70	const was = hasLater(before);
	71	const is = hasLater(after);
	72	if (was === is \|\| issue.kind !== "issue" \|\| isMirror(app, repo)) return ok(undefined);
	73	const set = pillarsOf(app.db, repo);
	74	if (set.gate === undefined \|\| isStructural(set, issue.id)) return ok(undefined);
	75	const holding = gateHolding(app.db, repo, issue) !== undefined;
	76	if (is && !holding) return linkIssue(app, actor, repo, issue, set.gate);
	77	if (!is && holding) return unlinkIssue(app, actor, repo, issue, set.gate);
	78	return ok(undefined);
	79	}
		@@ -0,0 +1,118 @@
	1	/**
	2	* The one-time pass over what the Later gate holds (#8700): the candidates
	3	* (`core/gate_triage.ts`) read for a repository, and applied on one approval.
	4	* Applying closes what the person ticked; what they left unticked stays
	5	* behind the gate. A closed issue keeps a "Gate review:" note and the
	6	* `issue.gate_reviewed` event only this path writes, which is how it is found
	7	* again and revived (`liftHold`). The approval carries a digest of the
	8	* candidates the person read; if the gate holds other issues now, the apply
	9	* refuses. A person approves — an agent may read the proposal and never
	10	* apply it.
	11	*/
	12
	13	import { createHash } from "node:crypto";
	14	import type { App } from "../app.ts";
	15	import { alreadyDone } from "../core/done_on_main.ts";
	16	import { heldIssues, REVIEW_NOTE } from "../core/gate_hold.ts";
	17	import { startsTicked, triage, type Theme, type Triaged } from "../core/gate_triage.ts";
	18	import { getIssue } from "../core/issues.ts";
	19	import { pillarsOf } from "../core/pillars.ts";
	20	import { canWrite, type Repo } from "../core/repos.ts";
	21	import type { User } from "../core/users.ts";
	22	import { err, ok, type Result } from "../kernel/result.ts";
	23	import { addComment, setIssueState } from "./issues.ts";
	24
	25	export interface GateReview {
	26	readonly themes: readonly Theme[];
	27	/** Every held issue as a candidate to close. */
	28	readonly changes: readonly Triaged[];
	29	/** The numbers that start ticked: what the crew found done on main. */
	30	readonly ticked: readonly number[];
	31	/** Names the candidates shown; the apply must carry it back. */
	32	readonly digest: string;
	33	readonly held: number;
	34	}
	35
	36	/** A short name for a set of issue numbers, whatever their order. */
	37	export function reviewDigest(numbers: readonly number[]): string {
	38	const sorted = [...numbers].sort((a, b) => a - b).join(",");
	39	return createHash("sha256").update(sorted).digest("hex").slice(0, 16);
	40	}
	41
	42	/** How many open issues wait for each of these, in one read. */
	43	function waitingOn(app: App, ids: readonly string[]): Map<string, number> {
	44	const out = new Map<string, number>();
	45	if (ids.length === 0) return out;
	46	const rows = app.db
	47	.query<{ blocked_by_id: string; n: number }, string[]>(
	48	`SELECT d.blocked_by_id, COUNT(*) AS n FROM issue_dependency d
	49	JOIN issue ON issue.id = d.issue_id
	50	WHERE issue.state = 'open' AND d.blocked_by_id IN (${ids.map((_, i) => `?${i + 1}`).join(",")})
	51	GROUP BY d.blocked_by_id`,
	52	)
	53	.all(...ids);
	54	for (const r of rows) out.set(r.blocked_by_id, r.n);
	55	return out;
	56	}
	57
	58	/** What the gate holds, triaged by title: one read. */
	59	export function reviewGate(app: App, repo: Repo): GateReview \| undefined {
	60	const set = pillarsOf(app.db, repo);
	61	if (set.gate === undefined) return undefined;
	62	const held = heldIssues(app.db, repo, set);
	63	const ids = held.map((i) => i.id);
	64	const done = alreadyDone(app.db, ids);
	65	const waiting = waitingOn(app, ids);
	66	const themes = triage(
	67	held.map((i) => ({ number: i.number, title: i.title, waiting: waiting.get(i.id) ?? 0 })),
	68	new Set(held.filter((i) => done.has(i.id)).map((i) => i.number)),
	69	);
	70	const changes = themes.flatMap((t) => t.items);
	71	return {
	72	themes,
	73	changes,
	74	ticked: changes.filter(startsTicked).map((c) => c.number),
	75	digest: reviewDigest(changes.map((c) => c.number)),
	76	held: held.length,
	77	};
	78	}
	79
	80	export type ApplyError = "not_found" \| "forbidden" \| "stale";
	81
	82	/**
	83	* Apply the approval the person gave: `approved` are the issue numbers they
	84	* ticked and `digest` names the candidates they read. If the gate holds other
	85	* issues now, or an approved one is not a candidate, the whole is refused, so
	86	* a person never approves what they did not read. Returns how many closed.
	87	*/
	88	export function applyGateReview(
	89	app: App,
	90	actor: User,
	91	repo: Repo,
	92	approved: readonly number[],
	93	digest: string \| undefined,
	94	): Result<number, ApplyError> {
	95	if (actor.kind === "agent" \|\| !canWrite(app.db, repo, actor)) return err("forbidden");
	96	const review = reviewGate(app, repo);
	97	if (review === undefined) return err("not_found");
	98	if (digest !== review.digest) return err("stale");
	99	const proposed = new Map(review.changes.map((c) => [c.number, c.verdict]));
	100	if (!approved.every((n) => proposed.has(n))) return err("stale");
	101	let closed = 0;
	102	for (const number of new Set(approved)) {
	103	const issue = getIssue(app.db, repo.id, number);
	104	const verdict = proposed.get(number)!;
	105	if (issue === undefined \|\| issue.state !== "open") continue;
	106	if (!setIssueState(app, actor, repo, issue, "closed", { reason: verdict.reason }).ok) continue;
	107	// The marker follows the close, never the other way: a failed close leaves none.
	108	app.bus.append({
	109	kind: "issue.gate_reviewed",
	110	repoId: repo.id,
	111	actorId: actor.id,
	112	payload: { number: issue.number },
	113	});
	114	addComment(app, actor, repo, issue, `${REVIEW_NOTE}closed: ${verdict.why}. Revive it from the held page to bring it back.`);
	115	closed++;
	116	}
	117	return ok(closed);
	118	}
		@@ -68,6 +68,7 @@ import {
68	68	} from "../origins/import.ts";
69	69	import { err, ok, type Result } from "../kernel/result.ts";
70	70	import { clearFirst } from "../core/first.ts";
	71	import { followLabel } from "./gate.ts";
71	72	import { inheritPillar } from "./pillars.ts";
72	73	import {
73	74	requireParticipant,
		@@ -705,6 +706,7 @@ export function setIssueLabels(
705	706	if (!label) return err("unknown_label");
706	707	if (!resolved.some((l) => l.id === label.id)) resolved.push(label);
707	708	}
	709	const before = labelsFor(app.db, issue.id);
708	710	writeLabels(
709	711	app.db,
710	712	issue.id,
		@@ -716,6 +718,13 @@ export function setIssueLabels(
716	718	actorId: writer.value.id,
717	719	payload: { number: issue.number, labels: resolved.map((l) => l.name) },
718	720	});
	721	// `Later` is the Later gate made visible: changing the label changes the gate.
	722	const followed = followLabel(app, writer.value, repo, issue, before, resolved);
	723	if (!followed.ok) {
	724	// The label and the gate move together or not at all.
	725	writeLabels(app.db, issue.id, before.map((l) => l.id));
	726	return err("forbidden");
	727	}
719	728	return ok(labelsFor(app.db, issue.id));
720	729	}
721	730
		@@ -38,6 +38,7 @@ const READER_KINDS: ReadonlySet<string> = new Set([
38	38	"issue.labeled",
39	39	"issue.first",
40	40	"issue.closed",
	41	"issue.gate_reviewed",
41	42	"issue.commented",
42	43	"usage.delta",
43	44	"issue.raised",
		@@ -0,0 +1,159 @@
	1	/**
	2	* What the Later gate holds (#8700): the open issues that wait behind it, who
	3	* set the gate and when, read from the same edges `core/pillars.ts` reads.
	4	* Nothing is stored. The gate is the plan's own issue, so "who set it" is its
	5	* author and "when" is the day it was opened.
	6	*/
	7
	8	import type { Database } from "bun:sqlite";
	9	import { getIssue, type Issue } from "./issues.ts";
	10	import { isStructural, pillarsOf, type Pillars } from "./pillars.ts";
	11	import type { Repo } from "./repos.ts";
	12
	13	export interface GateHold {
	14	readonly gate: Issue;
	15	/** Open issues waiting behind the gate, not counting the plan's furniture. */
	16	readonly held: number;
	17	/** Who opened the gate. */
	18	readonly by: string;
	19	/** When it was opened, an ISO instant. */
	20	readonly since: string;
	21	}
	22
	23	/** The open issues waiting behind the gate, newest first, the plan's furniture left out. */
	24	export function heldIssues(
	25	db: Database,
	26	repo: Repo,
	27	set: Pillars,
	28	limit = 500,
	29	): Issue[] {
	30	if (set.gate === undefined) return [];
	31	const rows = db
	32	.query<{ number: number }, [string, string, number]>(
	33	`SELECT issue.number FROM issue_dependency d
	34	JOIN issue ON issue.id = d.issue_id
	35	WHERE d.blocked_by_id = ?1 AND issue.repo_id = ?2
	36	AND issue.kind = 'issue' AND issue.state = 'open' AND issue.sealed = 0
	37	ORDER BY issue.number DESC LIMIT ?3`,
	38	)
	39	.all(set.gate.id, repo.id, limit + 8);
	40	const out: Issue[] = [];
	41	for (const row of rows) {
	42	const issue = getIssue(db, repo.id, row.number);
	43	if (issue !== undefined && !isStructural(set, issue.id)) out.push(issue);
	44	if (out.length === limit) break;
	45	}
	46	return out;
	47	}
	48
	49	/** How many open issues wait behind the gate: one read. */
	50	export function countHeld(db: Database, repo: Repo, set: Pillars): number {
	51	if (set.gate === undefined) return 0;
	52	const structural = [
	53	...set.pillars.map((p) => p.umbrella.id),
	54	...(set.later === undefined ? [] : [set.later.id]),
	55	];
	56	const row = db
	57	.query<{ n: number }, string[]>(
	58	`SELECT COUNT(*) AS n FROM issue_dependency d
	59	JOIN issue ON issue.id = d.issue_id
	60	WHERE d.blocked_by_id = ?1 AND issue.repo_id = ?2
	61	AND issue.kind = 'issue' AND issue.state = 'open' AND issue.sealed = 0
	62	${structural.length === 0 ? "" : `AND issue.id NOT IN (${structural.map((_, i) => `?${i + 3}`).join(",")})`}`,
	63	)
	64	.get(set.gate.id, repo.id, ...structural);
	65	return row?.n ?? 0;
	66	}
	67
	68	/** The repository's gate hold, or nothing where there is no gate or it holds nothing. */
	69	export function gateHold(db: Database, repo: Repo): GateHold \| undefined {
	70	const set = pillarsOf(db, repo);
	71	if (set.gate === undefined) return undefined;
	72	const held = countHeld(db, repo, set);
	73	if (held === 0) return undefined;
	74	return {
	75	gate: set.gate,
	76	held,
	77	by: set.gate.authorName,
	78	since: set.gate.createdAt,
	79	};
	80	}
	81
	82	/** The gate this issue waits behind, open or closed, if it does. */
	83	export function gateOf(
	84	db: Database,
	85	repo: Repo,
	86	issue: Issue,
	87	): Issue \| undefined {
	88	if (issue.kind !== "issue") return undefined;
	89	const set = pillarsOf(db, repo);
	90	if (set.gate === undefined \|\| isStructural(set, issue.id)) return undefined;
	91	const row = db
	92	.query<{ one: number }, [string, string]>(
	93	"SELECT 1 AS one FROM issue_dependency WHERE issue_id = ?1 AND blocked_by_id = ?2",
	94	)
	95	.get(issue.id, set.gate.id);
	96	return row === null ? undefined : set.gate;
	97	}
	98
	99	/** The gate this open issue waits behind, if it does. */
	100	export function gateHolding(
	101	db: Database,
	102	repo: Repo,
	103	issue: Issue,
	104	): Issue \| undefined {
	105	return issue.state === "open" ? gateOf(db, repo, issue) : undefined;
	106	}
	107
	108	/** The note a gate review leaves on an issue it closed (`actions/gate_review.ts`). */
	109	export const REVIEW_NOTE = "Gate review: ";
	110
	111	/**
	112	* The event only the review's apply path writes, right after the close. An
	113	* issue is "closed by the review" while it is the latest of this, a close and
	114	* a reopen on that issue: a comment cannot forge it, and a reopen followed by
	115	* a manual close does not read as the review's.
	116	*/
	117	export const GATE_REVIEWED = "issue.gate_reviewed"; // also named in `actions/gate_review.ts` and `core/event_audience.ts`
	118
	119	/** The newest event of a kind on `issue` (a row of `issue`), by rowid; each reads the event index by equality. */
	120	const newest = (kind: string): string =>
	121	`COALESCE((SELECT MAX(e.rowid) FROM event e
	122	WHERE e.repo_id = issue.repo_id AND e.kind = '${kind}'
	123	AND json_extract(e.payload, '$.number') = issue.number), 0)`;
	124
	125	/** The SQL that says whether the review closed `issue`: its event is newer than the issue's last close and reopen. */
	126	const BY_REVIEW = `(${newest(GATE_REVIEWED)} > ${newest("issue.closed")} AND ${newest(GATE_REVIEWED)} > ${newest("issue.reopened")})`;
	127
	128	/** Whether the gate review closed this issue, so it can be found and revived. */
	129	export function closedByReview(db: Database, issue: Issue): boolean {
	130	if (issue.state !== "closed") return false;
	131	return (
	132	db
	133	.query<{ one: number }, [string]>(
	134	`SELECT 1 AS one FROM issue WHERE id = ?1 AND ${BY_REVIEW}`,
	135	)
	136	.get(issue.id) !== null
	137	);
	138	}
	139
	140	/** The issues the gate review closed that are still behind the gate, newest first. */
	141	export function reviewedClosed(
	142	db: Database,
	143	repo: Repo,
	144	set: Pillars,
	145	limit = 300,
	146	): Issue[] {
	147	if (set.gate === undefined) return [];
	148	const rows = db
	149	.query<{ number: number }, [string, string, number]>(
	150	`SELECT issue.number FROM issue_dependency d
	151	JOIN issue ON issue.id = d.issue_id
	152	WHERE d.blocked_by_id = ?1 AND issue.repo_id = ?2
	153	AND issue.kind = 'issue' AND issue.state = 'closed' AND issue.sealed = 0
	154	AND ${BY_REVIEW}
	155	ORDER BY issue.number DESC LIMIT ?3`,
	156	)
	157	.all(set.gate.id, repo.id, limit);
	158	return rows.flatMap((r) => getIssue(db, repo.id, r.number) ?? []);
	159	}
		@@ -0,0 +1,89 @@
	1	/**
	2	* A one-time look at what the Later gate holds (#8700), from titles alone:
	3	* no model, no run, nothing stored. Unchosen ideas are dropped, not tracked
	4	* (Shape Up): every held issue is a candidate to close, and only one the
	5	* crew found done on main starts ticked; the rest are the person's to tick,
	6	* and one that open work waits for is flagged, for closing it parks that
	7	* work. Unticked is keep. A closed one stays findable and one tap revives
	8	* it. The lot is grouped by theme, the word its titles share most. Nothing
	9	* here changes an issue (`actions/gate_review.ts` applies the approval).
	10	*/
	11
	12	export interface Held {
	13	readonly number: number;
	14	readonly title: string;
	15	/** Open issues that wait for this one: closing it parks them. */
	16	readonly waiting: number;
	17	}
	18
	19	export interface Verdict {
	20	readonly kind: "close";
	21	readonly why: string;
	22	readonly reason: "done" \| "dropped";
	23	}
	24
	25	export interface Triaged {
	26	readonly number: number;
	27	readonly title: string;
	28	readonly waiting: number;
	29	readonly verdict: Verdict;
	30	}
	31
	32	export interface Theme {
	33	readonly name: string;
	34	readonly items: readonly Triaged[];
	35	}
	36
	37	const STOP = new Set(
	38	"a an and are as at be by for from has have how in is it its of on or that the this to was we with when what who which not no can do does your you our new add make use used using into out up per via issue issues".split(
	39	" ",
	40	),
	41	);
	42
	43	/** Lowercase words of three letters or more, the stop words left out. */
	44	export function words(text: string): string[] {
	45	return (text.toLowerCase().match(/[a-z][a-z0-9]{2,}/g) ?? []).filter(
	46	(w) => !STOP.has(w),
	47	);
	48	}
	49
	50	/** Whether a candidate starts ticked: only one the crew found done on main. */
	51	export const startsTicked = (t: Triaged): boolean => t.verdict.reason === "done";
	52
	53	/** A theme needs this many issues; a word on fewer is not a theme. */
	54	export const THEME_MIN = 3;
	55	/** Themes shown; the rest go under `OTHER`. */
	56	export const THEMES_MAX = 8;
	57	export const OTHER = "Other";
	58
	59	/** The candidate close for each held issue, under the theme its title belongs to. */
	60	export function triage(
	61	held: readonly Held[],
	62	done: ReadonlySet<number> = new Set(),
	63	): Theme[] {
	64	const sets = new Map(held.map((h) => [h.number, new Set(words(h.title))]));
	65	// A theme is a word many titles share: each issue goes under the commonest
	66	// of its words that is common enough, ties to the shorter, then alphabetical.
	67	const freq = new Map<string, number>();
	68	for (const s of sets.values()) for (const w of s) freq.set(w, (freq.get(w) ?? 0) + 1);
	69	const chosen = [...freq]
	70	.filter(([, n]) => n >= THEME_MIN)
	71	.sort((a, b) => b[1] - a[1] \|\| a[0].length - b[0].length \|\| a[0].localeCompare(b[0]))
	72	.slice(0, THEMES_MAX)
	73	.map(([w]) => w);
	74	const groups = new Map<string, Triaged[]>(chosen.map((w) => [w, []]));
	75	const other: Triaged[] = [];
	76	for (const h of held) {
	77	const verdict: Verdict = done.has(h.number)
	78	? { kind: "close", why: "the crew found it done on main", reason: "done" }
	79	: { kind: "close", why: "not chosen: an idea that matters comes back", reason: "dropped" };
	80	const row = { number: h.number, title: h.title, waiting: h.waiting, verdict };
	81	const theme = chosen.find((w) => sets.get(h.number)!.has(w));
	82	if (theme === undefined) other.push(row);
	83	else groups.get(theme)!.push(row);
	84	}
	85	const out = [...groups]
	86	.filter(([, items]) => items.length > 0)
	87	.map(([name, items]) => ({ name, items }));
	88	return other.length === 0 ? out : [...out, { name: OTHER, items: other }];
	89	}
		@@ -57,6 +57,12 @@ export const ASKING: Readonly<Record<string, Asking>> = {
57	57	model_grant: { does: "give an account a monthly model grant", undo: () => "`model_grant` with `usdPerMonth: 0` takes it back" },
58	58	model_ceiling: { does: "cap an account's model spend", undo: () => "`model_ceiling` with both `null` clears it" },
59	59	limits: { does: "change one of the forge's limits", undo: () => "`limits` with `value: \"\"` restores the default" },
	60	// Closing the Later gate's unchosen ideas in one go; reading its proposal asks nothing.
	61	held: {
	62	does: "close the issues the Later gate review proposed to close",
	63	asks: (a) => a["apply"] !== undefined,
	64	undo: () => "`lift` on each issue revives it",
	65	},
60	66	// Secrets and credentials.
61	67	secrets: { does: "set or remove a sealed secret", asks: not("action", "list") },
62	68	app_env: { does: "set or unset an app's variable", asks: not("action", "list") },
		@@ -0,0 +1,50 @@
	1	import { applyGateReview, reviewGate } from "../../../actions/gate_review.ts";
	2	import { THREAD_SAYS } from "../../../actions/thread_words.ts";
	3	import { good, bad, type Tool, APP_ARG, planRepo, isAnswer } from "../shared.ts";
	4
	5	export const tool: Tool = {
	6	name: "held",
	7	doc: "`{ app, apply? }`: what the Later gate holds, grouped by theme, with each as a candidate to close, from titles alone; `apply: [numbers], digest` (a person's token; the numbers to close, and the `digest` the read gave) does it, refused if what the gate holds has moved; only `done` ones are in `approve`; `lift` revives a closed one",
	8	description: "What the Later gate holds, and one proposed pass over it.",
	9	inputSchema: {
	10	type: "object",
	11	properties: {
	12	app: APP_ARG,
	13	apply: { type: "array", items: { type: "integer", minimum: 1 }, maxItems: 1000 },
	14	digest: { type: "string", maxLength: 64 },
	15	},
	16	required: ["app"],
	17	},
	18	writes: true,
	19	run(ctx, user, args) {
	20	const repo = planRepo(ctx, user, args);
	21	if (isAnswer(repo)) return repo;
	22	const apply = args["apply"];
	23	if (apply !== undefined) {
	24	if (!Array.isArray(apply) \|\| !apply.every((n) => Number.isInteger(n) && n > 0))
	25	return bad("invalid_apply", "apply is the list of issue numbers the proposal names");
	26	const done = applyGateReview(ctx.app, user, repo, apply as number[], typeof args["digest"] === "string" ? args["digest"] : undefined);
	27	if (!done.ok)
	28	return bad(
	29	done.error,
	30	done.error === "stale"
	31	? "what the gate holds changed since you read it; read it again"
	32	: done.error === "forbidden"
	33	? THREAD_SAYS.planForbidden
	34	: "there is no Later gate here",
	35	);
	36	return good({ says: `Closed ${done.value}.` });
	37	}
	38	const review = reviewGate(ctx.app, repo);
	39	if (review === undefined) return bad("not_found", "there is no Later gate here");
	40	return good({
	41	says: `${review.held} held; ${review.ticked.length} found done on main.`,
	42	themes: review.themes.map((t) => ({
	43	theme: t.name,
	44	issues: t.items.map((i) => ({ number: i.number, title: i.title, waiting: i.waiting, ...i.verdict })),
	45	})),
	46	approve: review.ticked,
	47	digest: review.digest,
	48	});
	49	},
	50	};
		@@ -65,6 +65,7 @@ export { tool as forges } from "./forges.ts";
65	65	export { tool as forks } from "./forks.ts";
66	66	export { tool as front_page } from "./front_page.ts";
67	67	export { tool as health } from "./health.ts";
	68	export { tool as held } from "./held.ts";
68	69	export { tool as here } from "./here.ts";
69	70	export { tool as hold } from "./hold.ts";
70	71	export { tool as hooks } from "./hooks.ts";
		@@ -74,6 +75,7 @@ export { tool as issue_teams } from "./issue_teams.ts";
74	75	export { tool as issues } from "./issues.ts";
75	76	export { tool as labels } from "./labels.ts";
76	77	export { tool as land_past_gate } from "./land_past_gate.ts";
	78	export { tool as lift } from "./lift.ts";
77	79	export { tool as limb } from "./limb.ts";
78	80	export { tool as limits } from "./limits.ts";
79	81	export { tool as make_it_yours } from "./make_it_yours.ts";