280feed · 41e535b · 1c9aebe · 9649417 · a59cf33 · c1fd57f
@@ -161,3 +161,7 @@
toward no file's heat and is named on the feed (`too wide to count: #4840
`src/crew/stale_reds.ts` `sweepStaleReds(app, repo, now, room)` runs each autonomy tick and reads only the database, so a restart or roll loses nothing. An open crew pull whose latest check on its head failed, with no run in 30 minutes and no person holding or assigned to it, is re-checked (reason `sweep`); still red, its builder is queued with the failing test named, within the free slots and 3 a tick. Past its tries it is parked and its issue is ready again. Red for over 24 h and conflicting with main, or with its issue closed, it is closed with one line. The flow report's `stale_reds` line (`src/flow/stale_reds.ts`) counts the ones not yet handled, and the keeper names `stale_reds` as a cause from 3.
How a person sees stale reds: `bun scripts/flow-report.ts` prints the `stale_reds:` line (count and oldest hours), and the keeper names `stale_reds` as the cause when they are what holds the flow; the terminal Flow dialog draws the keeper's line (`keeperLine`), so it shows there when the keeper picks that cause. It has no line of its own on the dialog.
## Estimates (#11955)
Estimates are recorded against an issue, asked for from the forge's own history and scored: see `docs/features/estimates.md`.
@@ -98,6 +98,7 @@
bytes in `tools/list`. After changing a tool run `bun scripts/mcp-table.ts`;
| `edit` | — | Retitle or rewrite an issue or pull: yours, or where you write; an agent only its own | 310 |
| `egress_grants` | — | Private destinations and grants: list, grant or revoke (site admin) | 289 |
| `email_verify` | — | Send yourself a new verification link | 126 |
| `estimate` | — | Ask an issue's base rate, or record `event` with `p50`, `p90` (instants) and `basis` | 399 |
| `events` | — | Repository events | 259 |
| `explore` | — | The apps, people (and, for an admin, forges) you can see, ranked | 627 |
| `family` | — | The forge that sent this one and, for a site admin, those it sent, with state, version | 205 |
@@ -0,0 +1,17 @@
# Estimates (#11955)
An estimate is a promise about when one issue's work happens, kept against the issue and scored. Rows are never edited: a new one supersedes and the old stays as data.
1. **Ask** the base rate for an issue: MCP `estimate` with `{ repo, issue }`, `GET /api/v1/repos/:owner/:name/issues/:n/estimates`, or in the terminal open the repository, choose **Estimates in a repository** from the palette and press `a` on the issue. It comes from the forge's own history (`src/flow/estimate_base.ts`): merged pulls in the last 30 days of the same repository, size and kind (and builder when assigned), measured from the first agent run on the issue (else its creation) to the pull opening, the merge and the release that carried the merge going live. Quantiles are nearest-rank, `sorted[round((n - 1) * q)]`. Under five samples it says so and widens: builder, kind, size, then 90 days. It adds what history does not know (queue position, runs going, budget left, why a release is held) and your own scorecard. Anyone who may read the issue may ask.
2. **Record** one: the same tool with `event` (`pull_opened`, `merged`, `live`), `p50`, `p90` (future instants, p50 ≤ p90) and `basis`; `POST` to the same URL; or `r` on the terminal screen, typing `event p50 p90 basis…` (for example `merged 2026-11-14T07:15:00Z 2026-11-14T11:00:00Z a small change`). Only someone with write access, or a crew member on the repository, records, and only on an open issue.
3. **See** it: the issue page and `/next` carry the line ("live by Fri 07:15 (90%: Fri 11:00) · steward · history says Fri 09:40"); `/flow` carries the scorecard.
## What the forge does
Nobody settles an estimate by hand. `src/actions/estimates_settle.ts` is the one place that hears of the events on the bus: a pull that says `Closes #N` opening or merging sets the actual instant of `pull_opened` or `merged`; `release.verified_live` resolves each open `live` estimate at the first release cut after its merge that served. An issue closed as **dropped** or **split**, or moved to **Not now** (`src/actions/next.ts`), voids what it left open: the rows stay, marked void, never scored. Closing as done voids nothing. `live` resolves only for the forge's own releases, not an app's production deploy.
## Scores
`src/flow/estimate_score.ts`: ratio = actual / p50 duration, both from the moment the estimate was made; the median ratio is the bias; the p90 hit rate should be about 90%. Only an estimator's first estimate per issue and event counts, so revising late cannot improve a score. The base rate shown at the time is scored as the estimator `history`. The scorecards read the newest 5,000 estimates in repositories the viewer may read, so a private repository's estimators, sizes and counts show only to those who can open it.
Tests: `test/estimates.test.ts`.
@@ -0,0 +1,198 @@
/**
 * The `estimate` act (#11955), one tool for two uses: ask the base rate for an
 * issue, or record an estimate against it. The page, the API, MCP and the
 * terminal call these and say the same words. Validation is here, at the
 * boundary; rows and maths are `core/estimates.ts` and `flow/estimate_*`.
 */
import type { App } from "../app.ts";
import { addEstimate, currentOf, estimatesOf, estimatesVisibleTo, isEvent, type EstimateEvent, type EstimateRow } from "../core/estimates.ts";
import { forgeSource } from "../settings/forge_source.ts";
import { getIssue, type Issue } from "../core/issues.ts";
import { mergedPullClosing, openPullsClosing } from "../core/pulls.ts";
import { nextUp } from "../core/next_up.ts";
import { canWrite, type Repo } from "../core/repos.ts";
import { listActiveRuns } from "../core/runs.ts";
import type { User } from "../core/users.ts";
import { budgetLines } from "../crew/forge_budget.ts";
import { baseRate, historySamples, type BaseRate } from "../flow/estimate_base.ts";
import { kindOf, labelsOf, sizeOf } from "../flow/estimate.ts";
import { lastLine } from "../flow/estimate_score.ts";
import { estimateLine } from "../flow/estimate_words.ts";
import { blocking, standingHolds } from "../keeper/hold.ts";
import { err, ok, type Result } from "../kernel/result.ts";
export const ESTIMATE_FORBIDDEN = "Only someone with write access, or a crew member on this repository, records an estimate.";
export const ESTIMATE_NOT_OPEN = "Only an open issue is estimated.";
export const ESTIMATE_SHAPE =
  "`event` is pull_opened, merged or live; `p50` and `p90` are instants like 2026-11-14T07:15:00Z, both in the future with p50 no later than p90; `basis` is one line, at most 300 characters.";
export const ESTIMATE_PASSED = "That event has already happened, so it is not estimated.";
const BASIS_MAX = 300;
const INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})$/;
export type EstimateError = { kind: "not_found" | "forbidden" | "invalid"; message: string };
/** What is true now that history does not know. */
export interface NowFacts {
  /** Place on /next, 1 at the top; null when the issue is not on the list. */
  readonly queuePosition: number | null;
  readonly listed: number;
  /** Agent runs going on this repository now. */
  readonly buildersBusy: number;
  /** USD left of the forge's day and month budgets. */
  readonly budgetLeftUsd: { readonly day: number; readonly month: number };
  /** Why the keeper will not cut a release now; null when nothing holds one. */
  readonly releasesHeld: string | null;
}
export interface Asked {
  readonly repo: string;
  readonly number: number;
  readonly size: string;
  readonly kind: string;
  readonly now: string;
  readonly base: BaseRate;
  readonly facts: NowFacts;
  readonly current: readonly EstimateRow[];
  readonly scorecard: string;
  readonly line: string | undefined;
}
function startedAt(app: App, issue: Issue): number | undefined {
  const row = app.db
    .query<{ at: string | null }, [string]>("SELECT MIN(created_at) AS at FROM run WHERE issue_id = ?1 AND kind = 'agent'")
    .get(issue.id);
  const ms = row?.at == null ? NaN : Date.parse(row.at);
  return Number.isFinite(ms) ? ms : undefined;
}
/**
 * The base rate for this issue at `now`: one read of the history, the same answer for the same
 * history.
 */
export function baseFor(app: App, repo: Repo, issue: Issue, now: Date): BaseRate {
  const labels = labelsOf(app.db, [issue.id]).get(issue.id) ?? [];
  const started = startedAt(app, issue);
  const samples = historySamples(app.db, repo.id, now.getTime() - 90 * 86_400_000, now.getTime());
  return baseRate(
    samples,
    { size: sizeOf(issue), kind: kindOf(labels), builder: issue.assigneeName ?? null, elapsedMs: started === undefined ? 0 : Math.max(0, now.getTime() - started) },
    `${repo.ownerName}/${repo.name}`,
    now.getTime(),
  );
}
function factsOf(app: App, repo: Repo, issue: Issue, now: Date): NowFacts {
  const rows = nextUp(app.db, repo).rows;
  const at = rows.findIndex((r) => r.issue.id === issue.id);
  const [, day, month] = budgetLines(app.db, now);
  const own = forgeSource(app.db, app.config.forgeRepo);
  const forge = own !== undefined && own.toLowerCase() === `${repo.ownerName}/${repo.name}`.toLowerCase();
  return {
    queuePosition: at < 0 ? null : at + 1,
    listed: rows.length,
    buildersBusy: listActiveRuns(app.db, [repo.id]).length,
    budgetLeftUsd: {
      day: Math.max(0, Math.round((day!.limitUsd - (day!.spentUsd ?? 0)) * 100) / 100),
      month: Math.max(0, Math.round((month!.limitUsd - (month!.spentUsd ?? 0)) * 100) / 100),
    },
    releasesHeld: forge ? blocking(standingHolds(app.db)) ?? null : null,
  };
}
/**
 * The issue as the act sees it: an issue, not a pull. Whether it is open is `recordEstimate`'s
 * say; asking is for any issue the caller may see.
 */
export function estimateIssue(app: App, repo: Repo, number: number): Issue | undefined {
  const issue = Number.isInteger(number) && number > 0 ? getIssue(app.db, repo.id, number) : undefined;
  return issue !== undefined && issue.kind === "issue" ? issue : undefined;
}
/** Ask: the base rate for this issue and what is true now, with the asker's own scorecard. */
export function askEstimate(app: App, actor: User | undefined, repo: Repo, issue: Issue, now: Date = new Date()): Asked {
  const rows = estimatesOf(app.db, issue.id);
  const labels = labelsOf(app.db, [issue.id]).get(issue.id) ?? [];
  return {
    repo: `${repo.ownerName}/${repo.name}`,
    number: issue.number,
    size: sizeOf(issue),
    kind: kindOf(labels),
    now: now.toISOString(),
    base: baseFor(app, repo, issue, now),
    facts: factsOf(app, repo, issue, now),
    current: currentOf(rows),
    scorecard: actor === undefined ? "" : lastLine(estimatesVisibleTo(app.db, actor, actor.id), actor.username, true),
    line: estimateLine(currentOf(rows), now.getTime()),
  };
}
export interface EstimateInput {
  readonly event?: unknown;
  readonly p50?: unknown;
  readonly p90?: unknown;
  readonly basis?: unknown;
}
const instant = (v: unknown): number | undefined => {
  if (typeof v !== "string" || !INSTANT.test(v)) return undefined;
  const ms = Date.parse(v);
  return Number.isFinite(ms) ? ms : undefined;
};
/**
 * Record: validated, stamped with who and when, and the base rate shown at that moment. A new one
 * supersedes; the old rows stay.
 */
export function recordEstimate(
  app: App,
  actor: User,
  repo: Repo,
  issue: Issue,
  input: EstimateInput,
  now: Date = new Date(),
): Result<{ estimate: EstimateRow; base: BaseRate; scorecard: string }, EstimateError> {
  const invalid = (message: string) => err<EstimateError>({ kind: "invalid", message });
  if (!canWrite(app.db, repo, actor)) return err({ kind: "forbidden", message: ESTIMATE_FORBIDDEN });
  if (issue.state !== "open") return invalid(ESTIMATE_NOT_OPEN);
  if (!isEvent(input.event)) return invalid(ESTIMATE_SHAPE);
  const event: EstimateEvent = input.event;
  const p50 = instant(input.p50);
  const p90 = instant(input.p90);
  if (p50 === undefined || p90 === undefined) return invalid(ESTIMATE_SHAPE);
  if (p50 <= now.getTime() || p90 <= now.getTime()) return invalid("Both times are in the future: " + ESTIMATE_SHAPE);
  if (p50 > p90) return invalid("p50 is no later than p90.");
  const basis = input.basis === undefined ? "" : input.basis;
  // eslint-disable-next-line no-control-regex
  if (typeof basis !== "string" || basis.length > BASIS_MAX || /[\u0000-\u001f\u007f]/.test(basis)) return invalid(ESTIMATE_SHAPE);
  const happened =
    event === "pull_opened"
      ? openPullsClosing(app.db, repo.id).has(issue.number) || mergedPullClosing(app.db, repo.id, issue.number) !== undefined
      : event === "merged"
        ? mergedPullClosing(app.db, repo.id, issue.number) !== undefined
        : false;
  if (happened) return invalid(ESTIMATE_PASSED);
  const base = baseFor(app, repo, issue, now);
  const labels = labelsOf(app.db, [issue.id]).get(issue.id) ?? [];
  const id = addEstimate(app.db, {
    repoId: repo.id,
    issueId: issue.id,
    event,
    p50At: new Date(p50).toISOString(),
    p90At: new Date(p90).toISOString(),
    madeAt: now.toISOString(),
    byId: actor.id,
    byKind: actor.kind === "agent" ? "agent" : "person",
    basis: basis.trim(),
    baseJson: JSON.stringify(base),
    size: sizeOf(issue),
    kind: kindOf(labels),
  });
  app.bus.append({
    kind: "issue.estimated",
    repoId: repo.id,
    actorId: actor.id,
    payload: { number: issue.number, event, estimate: id },
  });
  const estimate = estimatesOf(app.db, issue.id).find((e) => e.id === id)!;
  return ok({ estimate, base, scorecard: lastLine(estimatesVisibleTo(app.db, actor, actor.id), actor.username, true) });
}
@@ -0,0 +1,75 @@
/**
 * Where an estimate is settled (#11955), the one place: the forge hears of the event on the bus and
 * the actual instant is set, or what an abandoned issue promised is voided. Nothing else in the
 * core, the pulls or the keeper knows estimates exist. Only reads and writes `issue_estimate`,
 * `core/estimates.ts` does the rows.
 *
 *  - `pull.opened`: the issues the pull's description closes had a pull opened (its creation time).
 *  - `pull.merged`: the same issues merged (the pull's merge time).
 *  - `release.verified_live`: each open `live` estimate resolves at the first release, cut after
 *    its merge, that served.
 *  - `issue.closed` as dropped or split: what it left open is void. (Moving to Not now voids in
 *    `actions/next.ts`, the act that does it.)
 */
import type { Database } from "bun:sqlite";
import { settleEvent, settleLive, voidOpen, type ServedRelease } from "../core/estimates.ts";
import type { ForgeEvent } from "../core/events.ts";
import { getIssue } from "../core/issues.ts";
import { closesFromBody, mergedPullClosing } from "../core/pulls.ts";
/** The most releases one settling reads: the newest that served. */
const RELEASES_MAX = 200;
const numberOf = (e: ForgeEvent): number | undefined => {
  const n = e.payload["number"];
  return typeof n === "number" && Number.isInteger(n) ? n : undefined;
};
/** The pull's description and its two instants. */
function pullFacts(db: Database, repoId: string, number: number): { body: string; openedAt: string; mergedAt: string | null } | undefined {
  const row = db
    .query<{ body: string; created_at: string; merged_at: string | null }, [string, number]>(
      `SELECT i.body, i.created_at, p.merged_at FROM issue i JOIN pull p ON p.issue_id = i.id WHERE i.repo_id = ?1 AND i.number = ?2`,
    )
    .get(repoId, number);
  return row === null ? undefined : { body: row.body, openedAt: row.created_at, mergedAt: row.merged_at };
}
/** Releases that served and were not rolled back, oldest first. */
function servedReleases(db: Database): ServedRelease[] {
  return db
    .query<{ cut_at: string; live_at: string }, [number]>(
      `SELECT cut_at, live_at FROM keeper_release WHERE live_at IS NOT NULL AND stage != 'rolled_back' ORDER BY cut_at DESC LIMIT ?1`,
    )
    .all(RELEASES_MAX)
    .reverse()
    .map((r) => ({ cutAt: r.cut_at, liveAt: r.live_at }));
}
/** Settle what this event settles. Subscribed once, in `app.ts`. */
export function settleEstimates(db: Database, e: ForgeEvent): void {
  if (e.repoId === null) return;
  const number = numberOf(e);
  switch (e.kind) {
    case "pull.opened": {
      const pull = number === undefined ? undefined : pullFacts(db, e.repoId, number);
      if (pull !== undefined) settleEvent(db, e.repoId, closesFromBody(pull.body), "pull_opened", pull.openedAt);
      return;
    }
    case "pull.merged": {
      const pull = number === undefined ? undefined : pullFacts(db, e.repoId, number);
      if (pull !== undefined) settleEvent(db, e.repoId, closesFromBody(pull.body), "merged", pull.mergedAt ?? e.createdAt);
      return;
    }
    case "issue.closed": {
      const reason = e.payload["reason"];
      const issue = number === undefined ? undefined : getIssue(db, e.repoId, number);
      if (issue !== undefined && (reason === "dropped" || reason === "split")) voidOpen(db, issue.id, e.createdAt);
      return;
    }
    case "release.verified_live":
      settleLive(db, servedReleases(db), (repoId, n) => mergedPullClosing(db, repoId, n)?.mergedAt ?? undefined);
      return;
  }
}
@@ -6,6 +6,7 @@
 */
import type { App } from "../app.ts";
import { addDependency, repoGraph } from "../core/dependencies.ts";
import { voidOpen } from "../core/estimates.ts";
import { getIssue, type Issue } from "../core/issues.ts";
import { isStructural, pillarsOf } from "../core/pillars.ts";
import { clearRank, lift, MAX_RANKED, ranksInRepo, writeOrder } from "../core/rank.ts";
@@ -79,6 +80,8 @@
export function rankIssue(
      const linked = addDependency(app.db, issue, set.gate!, actor.id);
      if (!linked.ok) return invalid(NEXT_INVALID);
      clearRank(app.db, issue.id);
      // Not now: what it promised is void, not scored (#11955).
      voidOpen(app.db, issue.id);
      return ok(undefined);
    }
    lift(app.db, repo, issue.id);
@@ -4,6 +4,7 @@
 * side-effect-contained, so tests boot real forges by the dozen.
 */
import { settleEstimates } from "./actions/estimates_settle.ts";
import { ownHost, setOwnHost } from "./core/trusted_sources.ts";
import { commitIdentity } from "./core/commit_identity.ts";
import { getUserById } from "./core/users.ts";
@@ -258,6 +259,9 @@
export function createApp(config: ForgeConfig): App {
  // sends them. Listener throws are swallowed by the bus, so this can never
  // break the action that produced the event.
  bus.subscribe((event) => enqueueForEvent(db, event));
  // A pull opened or merged, a release served, an issue dropped or split:
  // estimates settle (#11955).
  bus.subscribe((event) => settleEstimates(db, event));
  // A push, a merge, a repository change or a build event may move pins: the kept listings go (`git/pins_kept.ts`).
  bus.subscribe((event) => {
    const k = event.kind;
@@ -0,0 +1,9 @@
import { REPO, type Route } from "../shared.ts";
export const route: Route = {
  method: "get",
  path: `${REPO}/issues/{number}/estimates`,
  summary: "Read an issue's base rate from the forge's history (p50/p90 per event), the estimates recorded against it and the caller's scorecard",
  auth: true,
  role: "member",
};
@@ -159,6 +159,7 @@
export { route as getApiV1ReposOwnerNameIssues } from "./getApiV1ReposOwnerNameI
export { route as getApiV1ReposOwnerNameIssuesNumber } from "./getApiV1ReposOwnerNameIssuesNumber.ts";
export { route as getApiV1ReposOwnerNameIssuesNumberComments } from "./getApiV1ReposOwnerNameIssuesNumberComments.ts";
export { route as getApiV1ReposOwnerNameIssuesNumberDependencies } from "./getApiV1ReposOwnerNameIssuesNumberDependencies.ts";
export { route as getApiV1ReposOwnerNameIssuesNumberEstimates } from "./getApiV1ReposOwnerNameIssuesNumberEstimates.ts";
export { route as getApiV1ReposOwnerNameIssuesNumberPlan } from "./getApiV1ReposOwnerNameIssuesNumberPlan.ts";
export { route as getApiV1ReposOwnerNameIssuesNumberTeams } from "./getApiV1ReposOwnerNameIssuesNumberTeams.ts";
export { route as getApiV1ReposOwnerNameIterations } from "./getApiV1ReposOwnerNameIterations.ts";
@@ -346,6 +347,7 @@
export { route as postApiV1ReposOwnerNameIssues } from "./postApiV1ReposOwnerNam
export { route as postApiV1ReposOwnerNameIssuesNumberComments } from "./postApiV1ReposOwnerNameIssuesNumberComments.ts";
export { route as postApiV1ReposOwnerNameIssuesNumberDependencies } from "./postApiV1ReposOwnerNameIssuesNumberDependencies.ts";
export { route as postApiV1ReposOwnerNameIssuesNumberDependenciesBlockerConfirm } from "./postApiV1ReposOwnerNameIssuesNumberDependenciesBlockerConfirm.ts";
export { route as postApiV1ReposOwnerNameIssuesNumberEstimates } from "./postApiV1ReposOwnerNameIssuesNumberEstimates.ts";
export { route as postApiV1ReposOwnerNameIssuesNumberPrivate } from "./postApiV1ReposOwnerNameIssuesNumberPrivate.ts";
export { route as postApiV1ReposOwnerNameJobsIdAction } from "./postApiV1ReposOwnerNameJobsIdAction.ts";
export { route as postApiV1ReposOwnerNameLabels } from "./postApiV1ReposOwnerNameLabels.ts";
@@ -0,0 +1,10 @@
import { REPO, type Route } from "../shared.ts";
export const route: Route = {
  method: "post",
  path: `${REPO}/issues/{number}/estimates`,
  summary: "Record an estimate against an issue: event (pull_opened, merged, live), p50 and p90 instants, a one-line basis; the forge resolves and scores it",
  auth: true,
  role: "member",
  body: { event: "string", p50: "string", p90: "string", basis: "string" },
};
@@ -0,0 +1,226 @@
/**
 * Estimates against an issue (#11955): rows kept, never edited. The forge sets
 * the actual instant when the event happens (`settleEvent`, `settleLive`) and
 * voids what an abandoned issue leaves open (`voidOpen`); nobody does it by hand.
 * This module reads no pulls and no releases: `actions/estimates_settle.ts` is the one place
 * that hears of the events and calls these.
 * Plain data in and out; the base rate and the scores are `flow/`.
 */
import type { Database } from "bun:sqlite";
import type { User } from "./users.ts";
import { repoVisible } from "./visibility.ts";
export const EVENTS = ["pull_opened", "merged", "live"] as const;
export type EstimateEvent = (typeof EVENTS)[number];
export const isEvent = (v: unknown): v is EstimateEvent => typeof v === "string" && (EVENTS as readonly string[]).includes(v);
export type EstimateState = "open" | "resolved" | "void";
export interface EstimateRow {
  readonly id: number;
  readonly repoId: string;
  readonly issueId: string;
  readonly issueNumber: number;
  readonly event: EstimateEvent;
  readonly p50At: string;
  readonly p90At: string;
  readonly madeAt: string;
  readonly byId: string;
  readonly byName: string;
  readonly byKind: "person" | "agent";
  readonly basis: string;
  /** The base rate shown when it was made: the raw JSON; `flow/estimate_base.ts` reads it. */
  readonly baseJson: string;
  readonly size: string;
  readonly kind: string;
  readonly actualAt: string | null;
  readonly voidedAt: string | null;
  readonly state: EstimateState;
}
interface Raw {
  id: number;
  repo_id: string;
  issue_id: string;
  number: number;
  event: EstimateEvent;
  p50_at: string;
  p90_at: string;
  made_at: string;
  by_id: string;
  username: string;
  by_kind: "person" | "agent";
  basis: string;
  base_json: string;
  size: string;
  kind: string;
  actual_at: string | null;
  voided_at: string | null;
}
const SELECT = `SELECT e.id, e.repo_id, e.issue_id, i.number, e.event, e.p50_at, e.p90_at, e.made_at, e.by_id,
       u.username, e.by_kind, e.basis, e.base_json, e.size, e.kind, e.actual_at, e.voided_at
  FROM issue_estimate e JOIN issue i ON i.id = e.issue_id JOIN user u ON u.id = e.by_id`;
const toRow = (r: Raw): EstimateRow => ({
  id: r.id,
  repoId: r.repo_id,
  issueId: r.issue_id,
  issueNumber: r.number,
  event: r.event,
  p50At: r.p50_at,
  p90At: r.p90_at,
  madeAt: r.made_at,
  byId: r.by_id,
  byName: r.username,
  byKind: r.by_kind,
  basis: r.basis,
  baseJson: r.base_json,
  size: r.size,
  kind: r.kind,
  actualAt: r.actual_at,
  voidedAt: r.voided_at,
  state: r.voided_at !== null ? "void" : r.actual_at !== null ? "resolved" : "open",
});
export interface NewEstimate {
  readonly repoId: string;
  readonly issueId: string;
  readonly event: EstimateEvent;
  readonly p50At: string;
  readonly p90At: string;
  readonly madeAt: string;
  readonly byId: string;
  readonly byKind: "person" | "agent";
  readonly basis: string;
  readonly baseJson: string;
  readonly size: string;
  readonly kind: string;
}
/**
 * Keep one estimate. Rows are only added: the older one for the same event is superseded by being
 * older.
 */
export function addEstimate(db: Database, e: NewEstimate): number {
  return Number(
    db
      .query(
        `INSERT INTO issue_estimate (repo_id, issue_id, event, p50_at, p90_at, made_at, by_id, by_kind, basis, base_json, size, kind)
         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)`,
      )
      .run(e.repoId, e.issueId, e.event, e.p50At, e.p90At, e.madeAt, e.byId, e.byKind, e.basis, e.baseJson, e.size, e.kind)
      .lastInsertRowid,
  );
}
/** Every estimate on an issue, oldest first: the revisions are data. */
export function estimatesOf(db: Database, issueId: string): EstimateRow[] {
  return db.query<Raw, [string]>(`${SELECT} WHERE e.issue_id = ?1 ORDER BY e.id`).all(issueId).map(toRow);
}
/** What each event stands at now: the newest estimate per event (events in their order). */
export function currentOf(rows: readonly EstimateRow[]): EstimateRow[] {
  const latest = new Map<EstimateEvent, EstimateRow>();
  for (const r of rows) latest.set(r.event, r);
  return EVENTS.flatMap((ev) => latest.get(ev) ?? []);
}
/** The most issue numbers one list read names. */
export const NUMBERS_MAX = 500;
/** The most rows a scorecard reads: the newest. */
export const SCORE_ROWS = 5000;
/**
 * The newest estimate per event for each issue number of a repository, for a list's rows (one
 * read of those issues' rows only).
 */
export function currentByNumber(db: Database, repoId: string, numbers: readonly number[]): Map<number, EstimateRow[]> {
  const out = new Map<number, EstimateRow[]>();
  if (numbers.length === 0) return out;
  const byIssue = new Map<number, EstimateRow[]>();
  for (const r of db
    .query<Raw, [string, string]>(
      `${SELECT} WHERE e.repo_id = ?1 AND i.number IN (SELECT value FROM json_each(?2)) ORDER BY e.id`,
    )
    .all(repoId, JSON.stringify(numbers.slice(0, NUMBERS_MAX)))
    .map(toRow))
    byIssue.set(r.issueNumber, [...(byIssue.get(r.issueNumber) ?? []), r]);
  for (const [n, rows] of byIssue) out.set(n, currentOf(rows));
  return out;
}
/**
 * The newest {@link SCORE_ROWS} estimates in repositories `viewer` may read (a signed-out viewer:
 * the public ones), oldest first, for the scorecards; `byId` keeps one estimator's.
 */
export function estimatesVisibleTo(db: Database, viewer: User | undefined, byId?: string): EstimateRow[] {
  const rows = db
    .query<Raw, [string, string, number]>(
      `${SELECT} JOIN repo ON repo.id = e.repo_id
        WHERE ${repoVisible(viewer !== undefined)} AND (?2 = '' OR e.by_id = ?2)
        ORDER BY e.id DESC LIMIT ?3`,
    )
    .all(viewer?.id ?? "", byId ?? "", SCORE_ROWS);
  return rows.reverse().map(toRow);
}
/**
 * The event happened for these issue numbers: their open estimates for it get the actual instant.
 * Returns how many.
 */
export function settleEvent(db: Database, repoId: string, numbers: readonly number[], event: EstimateEvent, at: string): number {
  let n = 0;
  for (const number of numbers)
    n += db
      .query(
        `UPDATE issue_estimate SET actual_at = ?4
          WHERE event = ?3 AND actual_at IS NULL AND voided_at IS NULL
            AND issue_id = (SELECT id FROM issue WHERE repo_id = ?1 AND number = ?2)`,
      )
      .run(repoId, number, event, at).changes;
  return n;
}
/** A release that served: when it was cut and when it went live. */
export interface ServedRelease {
  readonly cutAt: string;
  readonly liveAt: string;
}
/**
 * Releases went live: every open `live` estimate whose issue merged at or before a release was cut
 * resolves at the first such release's `liveAt`. `mergedAt` says when the pull that closed an issue
 * merged (the caller reads pulls; this module reads none). `releases` are oldest first.
 */
export function settleLive(
  db: Database,
  releases: readonly ServedRelease[],
  mergedAt: (repoId: string, number: number) => string | undefined,
): number {
  if (releases.length === 0) return 0;
  const open = db
    .query<{ id: number; repo_id: string; number: number }, []>(
      `SELECT e.id, e.repo_id, i.number FROM issue_estimate e JOIN issue i ON i.id = e.issue_id
        WHERE e.event = 'live' AND e.actual_at IS NULL AND e.voided_at IS NULL`,
    )
    .all();
  let n = 0;
  for (const r of open) {
    const merged = mergedAt(r.repo_id, r.number);
    const release = merged === undefined ? undefined : releases.find((x) => x.cutAt >= merged);
    if (release === undefined) continue;
    n += db.query(`UPDATE issue_estimate SET actual_at = ?2 WHERE id = ?1 AND actual_at IS NULL AND voided_at IS NULL`).run(r.id, release.liveAt).changes;
  }
  return n;
}
/**
 * An issue closed as dropped or split, or moved to Not now: what it left open is kept, marked
 * void, never scored.
 */
export function voidOpen(db: Database, issueId: string, at: string = new Date().toISOString()): number {
  return db
    .query(`UPDATE issue_estimate SET voided_at = ?2 WHERE issue_id = ?1 AND actual_at IS NULL AND voided_at IS NULL`)
    .run(issueId, at).changes;
}
@@ -56,6 +56,7 @@
const READER_KINDS: ReadonlySet<string> = new Set([
  // the admins' (`repo.upstream_follow`).
  "repo.following",
  "issue.labeled",
  "issue.estimated",
  "issue.first",
  "issue.ranked",
  "week.retro",
@@ -66,6 +66,8 @@
export interface Issue {
   * (`core/sealed.ts`).
   */
  readonly sealed: boolean;
  /** Whether any estimate was ever recorded against it (#11955); none, no read. */
  readonly estimated: boolean;
}
interface IssueRow {
@@ -90,11 +92,13 @@
interface IssueRow {
  assignee_is_agent: number | null;
  author_is_agent: number;
  sealed: number;
  estimated: number;
}
const SELECT = `
  SELECT issue.*, user.username AS author_name, user.is_agent AS author_is_agent,
         assignee.username AS assignee_name, assignee.is_agent AS assignee_is_agent
         assignee.username AS assignee_name, assignee.is_agent AS assignee_is_agent,
         EXISTS (SELECT 1 FROM issue_estimate WHERE issue_estimate.issue_id = issue.id) AS estimated
  FROM issue JOIN user ON user.id = issue.author_id
  LEFT JOIN user AS assignee ON assignee.id = issue.assignee_id`;
@@ -128,6 +132,7 @@
function toIssue(row: IssueRow): Issue {
    assigneeIsAgent: row.assignee_is_agent === 1,
    authorIsAgent: row.author_is_agent === 1,
    sealed: row.sealed === 1,
    estimated: row.estimated === 1,
  };
}
@@ -0,0 +1,1 @@
dfe23c0041426dfe2c241a8ef21756e483583eaffd04ccd8e3cfa04e2afa21db
@@ -0,0 +1,27 @@
// Estimates of when an issue's work happens (#11955): one row per estimate, never edited.
// A new estimate for the same issue and event supersedes the old one on the page; the old
// rows stay as data. The forge alone sets `actual_at` (the event happened) or `voided_at`
// (the issue closed as dropped or split, or moved to Not now). `base_json` is the base rate shown
// when the estimate was made, so the history itself can be scored. Additive: one table.
export default `
  CREATE TABLE issue_estimate (
    id        INTEGER PRIMARY KEY AUTOINCREMENT,
    repo_id   TEXT NOT NULL REFERENCES repo(id) ON DELETE CASCADE,
    issue_id  TEXT NOT NULL REFERENCES issue(id) ON DELETE CASCADE,
    event     TEXT NOT NULL CHECK (event IN ('pull_opened','merged','live')),
    p50_at    TEXT NOT NULL,
    p90_at    TEXT NOT NULL,
    made_at   TEXT NOT NULL,
    by_id     TEXT NOT NULL REFERENCES user(id),
    by_kind   TEXT NOT NULL CHECK (by_kind IN ('person','agent')),
    basis     TEXT NOT NULL DEFAULT '',
    base_json TEXT NOT NULL DEFAULT 'null',
    size      TEXT NOT NULL,
    kind      TEXT NOT NULL DEFAULT '',
    actual_at TEXT,
    voided_at TEXT
  );
  CREATE INDEX issue_estimate_issue ON issue_estimate(issue_id, event, id);
  CREATE INDEX issue_estimate_open ON issue_estimate(event, repo_id) WHERE actual_at IS NULL AND voided_at IS NULL;
  CREATE INDEX issue_estimate_repo ON issue_estimate(repo_id, made_at);
`;
@@ -369,6 +369,13 @@
export function taskPrompt(input: TaskInput): string {
const MCP_SIZE_RULE =
  "This issue touches the MCP. Run `bun test test/mcp-size.test.ts` before pushing; it names the five costliest tools when it fails. Prefer an `action` or `kind` on an existing tool (docs/MCP.md, \"Room for a new tool\") over a new tool, and never raise the ceilings.";
/**
 * A time promised to the owner is a record first (#11955); the task prompt carries it,
 * not the system brief, to keep that short.
 */
export const ESTIMATE_RULE =
  'A "by <time>" you say to the owner is recorded first with the `estimate` tool (ask it for the issue\'s base rate, then record `event` pull_opened, merged or live with `p50` and `p90` instants and a one-line `basis`), or it is not said. The forge resolves it when the event happens and scores it.';
/** A plan on the issue is how a person sees where a run is without reading its log; only the forge serves the tool. */
const PLAN_RULE =
  "Keep a short plan on this issue with the `keep_plan` tool (up to 12 items, replaced whole each time): call it once you have read the code and again as items finish, so a person sees where you are without a log.";
@@ -475,6 +482,7 @@
function taskBody(input: TaskInput): string {
    if (input.pull === undefined && isForge(input.repo) && namesMcp(issue.title, issue.body))
      out.push("", MCP_SIZE_RULE);
    if (input.pull === undefined && isForge(input.repo)) out.push("", PLAN_RULE);
    if (input.pull === undefined && isForge(input.repo)) out.push("", ESTIMATE_RULE);
    out.push(
      "",
      `Work it on the branch \`${input.branch}\` and push when done.`,
@@ -0,0 +1,179 @@
/**
 * The base rate for an issue (#11955): how long past issues like it took from the
 * start of work to each event, from the forge's own history. Measured, never
 * guessed; the same history gives the same answer. Plain data in and out;
 * `historySamples` is the one read.
 *
 * Start of work is the first agent run on the issue, else its creation. Time
 * waiting in the queue is therefore not in the rates: it is said beside them
 * (`flow/estimate_now.ts`). Quantiles are nearest-rank over the sorted
 * durations, `sorted[round((n - 1) * q)]`, so a test can do it by hand.
 */
import type { Database } from "bun:sqlite";
import type { EstimateEvent } from "../core/estimates.ts";
import { closesFromBody } from "../core/pulls.ts";
import { kindOf, labelsOf, sizeOf, type Size } from "./estimate.ts";
import { durationWords } from "./estimate_words.ts";
/** Samples a group needs before it speaks plainly. */
export const MIN_BASE = 5;
const DAY = 86_400_000;
/** The most merged pulls one read walks. */
const PULLS_MAX = 600;
export interface HistorySample {
  readonly number: number;
  readonly size: Size;
  readonly kind: string;
  readonly builder: string | null;
  /**
   * Milliseconds from the start of work to each event; live is absent when no release since the
   * merge has served.
   */
  readonly pull: number;
  readonly merged: number;
  readonly live: number | undefined;
  readonly mergedAtMs: number;
}
export interface EventRate {
  readonly n: number;
  /** From now, in ms. */
  readonly p50Ms: number;
  readonly p90Ms: number;
  readonly p50At: string;
  readonly p90At: string;
}
export interface BaseRate {
  readonly n: number;
  /** True when fewer than {@link MIN_BASE} samples were found even after widening. */
  readonly thin: boolean;
  /** What was widened, in order, e.g. ["dropped the builder", "dropped the kind"]. */
  readonly widened: readonly string[];
  readonly basis: string;
  readonly events: Record<EstimateEvent, EventRate | null>;
}
/** Nearest-rank quantile of an ascending array. */
export const quantile = (sorted: readonly number[], q: number): number => sorted[Math.round((sorted.length - 1) * q)]!;
const ascending = (xs: readonly number[]): number[] => [...xs].sort((a, b) => a - b);
/**
 * Past issues finished in the window: merged pulls that closed them, with when work started and
 * when each release went live.
 */
export function historySamples(db: Database, repoId: string, sinceMs: number, nowMs: number): HistorySample[] {
  const since = new Date(sinceMs).toISOString();
  const pulls = db
    .query<{ body: string; opened: string; merged: string }, [string, string, number]>(
      `SELECT i.body, i.created_at AS opened, p.merged_at AS merged FROM pull p JOIN issue i ON i.id = p.issue_id
        WHERE i.repo_id = ?1 AND p.merged_at IS NOT NULL AND p.merged_at >= ?2 ORDER BY p.merged_at DESC LIMIT ?3`,
    )
    .all(repoId, since, PULLS_MAX);
  const closed = new Map<number, { opened: string; merged: string }>();
  for (const p of pulls) for (const n of closesFromBody(p.body)) if (!closed.has(n)) closed.set(n, p);
  if (closed.size === 0) return [];
  const numbers = JSON.stringify([...closed.keys()].slice(0, PULLS_MAX * 4));
  const issues = db
    .query<{ id: string; number: number; title: string; body: string; created_at: string; assignee: string | null; started: string | null }, [string, string]>(
      `SELECT i.id, i.number, i.title, i.body, i.created_at, a.username AS assignee,
              (SELECT MIN(r.created_at) FROM run r WHERE r.issue_id = i.id AND r.kind = 'agent') AS started
         FROM issue i LEFT JOIN user a ON a.id = i.assignee_id
        WHERE i.repo_id = ?1 AND i.kind = 'issue' AND i.state = 'closed' AND i.close_reason = 'done'
          AND i.number IN (SELECT value FROM json_each(?2))`,
    )
    .all(repoId, numbers)
    .filter((i) => closed.has(i.number));
  const labels = labelsOf(db, issues.map((i) => i.id));
  const releases = db
    .query<{ cut_at: string; live_at: string }, [string]>(
      `SELECT cut_at, live_at FROM keeper_release WHERE live_at IS NOT NULL AND stage != 'rolled_back' AND cut_at >= ?1 ORDER BY cut_at`,
    )
    .all(since);
  const out: HistorySample[] = [];
  for (const i of issues) {
    const c = closed.get(i.number)!;
    const start = Date.parse(i.started ?? i.created_at);
    const merged = Date.parse(c.merged);
    const opened = Date.parse(c.opened);
    if (![start, merged, opened].every(Number.isFinite) || merged < start || merged > nowMs) continue;
    const release = releases.find((r) => r.cut_at >= c.merged);
    const live = release === undefined ? undefined : Date.parse(release.live_at);
    out.push({
      number: i.number,
      size: sizeOf(i),
      kind: kindOf(labels.get(i.id) ?? []),
      builder: i.assignee,
      pull: Math.max(0, Math.min(opened, merged) - start),
      merged: merged - start,
      live: live === undefined || !Number.isFinite(live) || live < merged ? undefined : live - start,
      mergedAtMs: merged,
    });
  }
  return out;
}
export interface Target {
  readonly size: Size;
  readonly kind: string;
  readonly builder: string | null;
  /** Milliseconds since work started on it; 0 when it has not. */
  readonly elapsedMs: number;
}
/**
 * From now: those still running at `elapsed` count what is left; if fewer than {@link MIN_BASE}
 * still run, all count in full.
 */
function fromNow(durations: readonly number[], elapsedMs: number, nowMs: number): EventRate | null {
  if (durations.length === 0) return null;
  const running = durations.filter((d) => d > elapsedMs).map((d) => d - elapsedMs);
  const left = ascending(elapsedMs > 0 && running.length >= MIN_BASE ? running : durations);
  const p50Ms = quantile(left, 0.5);
  const p90Ms = quantile(left, 0.9);
  return { n: durations.length, p50Ms, p90Ms, p50At: new Date(nowMs + p50Ms).toISOString(), p90At: new Date(nowMs + p90Ms).toISOString() };
}
/**
 * The base rate of `target` among `samples` (all within 90 days), widening until {@link MIN_BASE}
 * are found.
 */
export function baseRate(samples: readonly HistorySample[], target: Target, where: string, nowMs: number): BaseRate {
  const inDays = (days: number) => samples.filter((s) => s.mergedAtMs >= nowMs - days * DAY);
  const levels: { widen: string | null; pick: () => HistorySample[]; who: string }[] = [
    ...(target.builder === null
      ? []
      : [{ widen: null, who: `${target.size} ${target.kind === "" ? "" : `${target.kind} `}issues by ${target.builder}, last 30 days`, pick: () => inDays(30).filter((s) => s.size === target.size && s.kind === target.kind && s.builder === target.builder) }]),
    { widen: target.builder === null ? null : "dropped the builder", who: `${target.size} ${target.kind === "" ? "" : `${target.kind} `}issues, last 30 days`, pick: () => inDays(30).filter((s) => s.size === target.size && s.kind === target.kind) },
    { widen: "dropped the kind", who: `${target.size} issues, last 30 days`, pick: () => inDays(30).filter((s) => s.size === target.size) },
    { widen: "dropped the size", who: "issues of any size, last 30 days", pick: () => inDays(30) },
    { widen: "widened to 90 days", who: "issues of any size, last 90 days", pick: () => inDays(90) },
  ];
  const widened: string[] = [];
  let used = levels[levels.length - 1]!;
  let group: HistorySample[] = [];
  for (const level of levels) {
    if (level.widen !== null) widened.push(level.widen);
    group = level.pick();
    used = level;
    if (group.length >= MIN_BASE) break;
  }
  const thin = group.length < MIN_BASE;
  const events: Record<EstimateEvent, EventRate | null> = {
    pull_opened: fromNow(group.map((s) => s.pull), target.elapsedMs, nowMs),
    merged: fromNow(group.map((s) => s.merged), target.elapsedMs, nowMs),
    live: fromNow(group.flatMap((s) => (s.live === undefined ? [] : [s.live])), target.elapsedMs, nowMs),
  };
  const merged = events.merged;
  const live = events.live;
  const stage = group.flatMap((s) => (s.live === undefined ? [] : [s.live - s.merged])).sort((a, b) => a - b);
  const parts = [
    merged === null ? "nothing merged yet" : `${target.elapsedMs > 0 ? "now→merged" : "work start→merged"} p50 ${durationWords(merged.p50Ms)}, p90 ${durationWords(merged.p90Ms)}`,
    stage.length === 0 || live === null ? "no release has gone live since" : `merged→live p50 ${durationWords(quantile(stage, 0.5))}, p90 ${durationWords(quantile(stage, 0.9))}`,
  ];
  const basis = thin
    ? `only ${group.length} ${used.who} in ${where} (fewer than ${MIN_BASE}; ${widened.length === 0 ? "nothing wider to try" : widened.join(", ")}): ${parts.join("; ")}`
    : `${group.length} ${used.who} in ${where}${widened.length === 0 ? "" : ` (${widened.join(", ")})`}: ${parts.join("; ")}`;
  return { n: group.length, thin, widened, basis, events };
}
@@ -0,0 +1,138 @@
/**
 * Scoring estimates (#11955). For each estimate resolved: ratio = actual duration /
 * p50 duration, both from the moment it was made. The median ratio is the bias
 * (2.4 means it runs 2.4× late: optimistic); the p90 hit rate is the share whose
 * actual instant was at or before the p90 (should be about 90%).
 *
 * One estimate counts per estimator, issue and event: the first one, so a revision
 * after the fact cannot improve a score (later ones are kept as data and shown, not scored).
 * The base rate shown at that moment is scored the same way as an estimator named
 * `history`. Void estimates are counted, never scored. Plain data in and out.
 */
import type { EstimateEvent, EstimateRow, EstimateState } from "../core/estimates.ts";
import { ratioOf, timesWords } from "./estimate_words.ts";
export const HISTORY = "history";
/** How many of an estimator's most recent resolved estimates the headline reads. */
export const LAST = 20;
export interface Scored {
  readonly who: string;
  readonly issueNumber: number;
  readonly event: EstimateEvent;
  readonly size: string;
  readonly kind: string;
  readonly madeAt: string;
  readonly p50At: string;
  readonly p90At: string;
  readonly actualAt: string | null;
  readonly state: EstimateState;
}
export interface Score {
  readonly who: string;
  /** "" for all of an estimator's work, else "small bug": a size and kind. */
  readonly group: string;
  readonly resolved: number;
  readonly void: number;
  readonly open: number;
  /** Median of actual/p50 over the resolved; null with none. */
  readonly medianRatio: number | null;
  /** Share of the resolved whose actual was at or before the p90, 0..1; null with none. */
  readonly p90Hit: number | null;
}
/** Median: the middle one, or the mean of the middle two. */
export function median(xs: readonly number[]): number | null {
  if (xs.length === 0) return null;
  const s = [...xs].sort((a, b) => a - b);
  const mid = s.length >> 1;
  return s.length % 2 === 1 ? s[mid]! : (s[mid - 1]! + s[mid]!) / 2;
}
/**
 * The estimates that count: each estimator's first per issue and event, plus the history's first
 * per issue and event.
 */
export function scoredEstimates(rows: readonly EstimateRow[]): Scored[] {
  const seen = new Set<string>();
  const firstOfIssueEvent = new Set<string>();
  const out: Scored[] = [];
  const base = (r: EstimateRow, who: string, p50At: string, p90At: string): Scored => ({
    who, issueNumber: r.issueNumber, event: r.event, size: r.size, kind: r.kind, madeAt: r.madeAt, p50At, p90At, actualAt: r.actualAt, state: r.state,
  });
  for (const r of rows) {
    const key = `${r.issueId}/${r.event}`;
    if (!firstOfIssueEvent.has(key)) {
      firstOfIssueEvent.add(key);
      try {
        const b = JSON.parse(r.baseJson) as { events?: Record<string, { p50At?: string; p90At?: string } | null> } | null;
        const h = b?.events?.[r.event];
        if (typeof h?.p50At === "string" && typeof h.p90At === "string") out.push(base(r, HISTORY, h.p50At, h.p90At));
      } catch {
        // A base that does not read is not scored; the estimate still is.
      }
    }
    const mine = `${key}/${r.byName}`;
    if (seen.has(mine)) continue;
    seen.add(mine);
    out.push(base(r, r.byName, r.p50At, r.p90At));
  }
  return out;
}
const groupOf = (s: Pick<Scored, "size" | "kind">): string => (s.kind === "" ? s.size : `${s.size} ${s.kind}`);
function tally(who: string, group: string, rows: readonly Scored[], last?: number): Score {
  const resolved = rows
    .filter((s) => s.state === "resolved" && s.actualAt !== null)
    .sort((a, b) => (a.actualAt! < b.actualAt! ? -1 : a.actualAt! > b.actualAt! ? 1 : 0));
  const read = last === undefined ? resolved : resolved.slice(-last);
  const ratios = read.flatMap((s) => ratioOf(s) ?? []);
  const held = read.filter((s) => Date.parse(s.actualAt!) <= Date.parse(s.p90At)).length;
  return {
    who,
    group,
    resolved: resolved.length,
    void: rows.filter((s) => s.state === "void").length,
    open: rows.filter((s) => s.state === "open").length,
    medianRatio: median(ratios),
    p90Hit: read.length === 0 ? null : held / read.length,
  };
}
/**
 * One score per estimator over all its estimates, then one per size and kind, the estimators in
 * name order and `history` last.
 */
export function scoreboard(rows: readonly EstimateRow[], last?: number): Score[] {
  const scored = scoredEstimates(rows);
  const who = [...new Set(scored.map((s) => s.who))].sort((a, b) => (a === HISTORY ? 1 : b === HISTORY ? -1 : a < b ? -1 : 1));
  return who.flatMap((w) => {
    const mine = scored.filter((s) => s.who === w);
    const groups = [...new Set(mine.map(groupOf))].sort();
    return [tally(w, "", mine, last), ...groups.map((g) => tally(w, g, mine.filter((s) => groupOf(s) === g), last))];
  });
}
/**
 * "median 2.4× late, p90 held 55%": the bias and the p90 in words; undefined with nothing resolved.
 */
export function biasWords(s: Pick<Score, "medianRatio" | "p90Hit">): string | undefined {
  if (s.medianRatio === null || s.p90Hit === null) return undefined;
  const r = s.medianRatio;
  const bias = r >= 1.05 ? `${timesWords(r)} late` : r > 0 && r <= 1 / 1.05 ? `${timesWords(1 / r)} early` : "on the mark";
  return `median ${bias}, p90 held ${Math.round(s.p90Hit * 100)}%`;
}
/**
 * "your last 20: median 2.4× late, p90 held 55%" for one estimator; says so when nothing has
 * resolved yet.
 */
export function lastLine(rows: readonly EstimateRow[], who: string, you = false): string {
  const s = scoreboard(rows, LAST).find((x) => x.who === who && x.group === "");
  const words = s === undefined ? undefined : biasWords(s);
  const count = s === undefined ? 0 : Math.min(s.resolved, LAST);
  const head = `${you ? "your" : `${who}'s`} last ${count}`;
  return words === undefined ? `${you ? "you have" : `${who} has`} no resolved estimates yet` : `${head}: ${words}`;
}
@@ -0,0 +1,78 @@
/**
 * Estimates in words (#11955): durations as "3 h 10 m", instants as "Fri 07:15"
 * in UTC (the page says UTC), the one line on an issue and on a /next row.
 * Plain data in, plain strings out; no clock read except what is passed.
 */
import { EVENTS, type EstimateEvent, type EstimateRow } from "../core/estimates.ts";
const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const;
const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const;
const two = (n: number): string => String(n).padStart(2, "0");
/** "25 m", "3 h 10 m", "9 h", "2 d 4 h": whole minutes below a day, hours above. */
export function durationWords(ms: number): string {
  const minutes = Math.max(0, Math.round(ms / 60_000));
  if (minutes < 60) return `${minutes} m`;
  const hours = Math.floor(minutes / 60);
  if (hours < 48) return minutes % 60 === 0 ? `${hours} h` : `${hours} h ${minutes % 60} m`;
  const days = Math.floor(hours / 24);
  return hours % 24 === 0 ? `${days} d` : `${days} d ${hours % 24} h`;
}
/** "Fri 07:15" UTC; with the date when it is a week or more from `now`. */
export function instantWords(iso: string, now: number): string {
  const d = new Date(iso);
  const clock = `${two(d.getUTCHours())}:${two(d.getUTCMinutes())}`;
  const near = Math.abs(d.getTime() - now) < 6 * 86_400_000;
  return near ? `${DAYS[d.getUTCDay()]} ${clock}` : `${DAYS[d.getUTCDay()]} ${d.getUTCDate()} ${MONTHS[d.getUTCMonth()]} ${clock}`;
}
export const EVENT_WORDS: Record<EstimateEvent, string> = {
  pull_opened: "pull opened",
  merged: "merged",
  live: "live",
};
const WENT: Record<EstimateEvent, string> = { pull_opened: "pull opened", merged: "merged", live: "went live" };
/**
 * What an estimate was: actual over the p50 duration, both from the moment it was made; undefined
 * when not resolved or degenerate.
 */
export function ratioOf(r: Pick<EstimateRow, "madeAt" | "p50At" | "actualAt">): number | undefined {
  if (r.actualAt === null) return undefined;
  const planned = Date.parse(r.p50At) - Date.parse(r.madeAt);
  const took = Date.parse(r.actualAt) - Date.parse(r.madeAt);
  return planned > 0 && took >= 0 ? took / planned : undefined;
}
export const timesWords = (ratio: number): string => `${(Math.round(ratio * 10) / 10).toFixed(1)}×`;
/**
 * The base rate's p50 instant for an event, as it stood when the estimate was made, or undefined.
 */
export function historySays(r: Pick<EstimateRow, "baseJson">, event: EstimateEvent): string | undefined {
  try {
    const base = JSON.parse(r.baseJson) as { events?: Record<string, { p50At?: string } | null> } | null;
    return base?.events?.[event]?.p50At;
  } catch {
    return undefined;
  }
}
/**
 * The one line a promise carries. Open: "live by Fri 07:15 (90%: Fri 11:00) · steward ·
 * history says Fri 09:40". Resolved: "went live Fri 10:02, 1.6× the estimate". Void: said so.
 * The event shown is the furthest one estimated; undefined when there is none.
 */
export function estimateLine(rows: readonly EstimateRow[], now: number): string | undefined {
  const mine = [...rows].reverse();
  const row = EVENTS.slice().reverse().map((ev) => mine.find((r) => r.event === ev)).find((r) => r !== undefined);
  if (row === undefined) return undefined;
  if (row.state === "resolved" && row.actualAt !== null) {
    const ratio = ratioOf(row);
    return `${WENT[row.event]} ${instantWords(row.actualAt, now)}${ratio === undefined ? "" : `, ${timesWords(ratio)} the estimate`}`;
  }
  if (row.state === "void") return `estimate void: the issue closed without the work`;
  const says = historySays(row, row.event);
  return `${EVENT_WORDS[row.event]} by ${instantWords(row.p50At, now)} (90%: ${instantWords(row.p90At, now)}) · ${row.byName}${says === undefined ? "" : ` · history says ${instantWords(says, now)}`}`;
}
@@ -7,6 +7,8 @@
import { holds, weakEtag } from "../etag.ts";
import { ISSUE_TEAMS_SAY, nameTeams } from "../../actions/issue_teams.ts";
import { askEstimate, recordEstimate } from "../../actions/estimates.ts";
import { estimatesOf } from "../../core/estimates.ts";
import { confirmIssue, dependencyWords, linkIssue, unlinkIssue } from "../../actions/dependencies.ts";
import {
  addCommentThrough,
@@ -327,6 +329,27 @@
export function issueRoutes(router: Router<Handler>): void {
    return json({ repo: there, clone: `${ctx.url.origin}/${there}.git` }, 201);
  });
  // Estimates (#11955): GET asks the base rate; POST records one.
  router.add("GET", "/api/v1/repos/:owner/:name/issues/:number/estimates", (ctx) => {
    const found = loadIssue(ctx);
    if ("error" in found) return found.error;
    return json({
      ...askEstimate(ctx.app, ctx.auth.user, found.repo, found.issue),
      revisions: estimatesOf(ctx.app.db, found.issue.id),
    });
  });
  router.add("POST", "/api/v1/repos/:owner/:name/issues/:number/estimates", async (ctx) => {
    const denied = requireScope(ctx, "rw");
    if (denied) return denied;
    const found = loadIssue(ctx);
    if ("error" in found) return found.error;
    if (ctx.auth.user === undefined) return apiError("unauthorized", 401, "sign in to record an estimate");
    const input = await body(ctx.request);
    const made = recordEstimate(ctx.app, ctx.auth.user, found.repo, found.issue, input);
    return made.ok
      ? json(made.value, 201)
      : apiError(made.error.kind, made.error.kind === "forbidden" ? 403 : 422, made.error.message);
  });
  router.add(
    "GET",
    "/api/v1/repos/:owner/:name/issues/:number/dependencies",
@@ -0,0 +1,38 @@
import { askEstimate, estimateIssue, recordEstimate } from "../../../actions/estimates.ts";
import { bad, good, type Tool, REPO_ARG, repoArg, isAnswer } from "../shared.ts";
import { mayView } from "../../../core/sealed.ts";
export const tool: Tool = {
  name: "estimate",
  doc: "`{ repo, issue, event?, p50?, p90?, basis? }`: with no times, the base rate for that issue from the forge's own history (p50/p90 instants and durations per event, sample size, one line of basis, what is true now, and your scorecard); with `event` (`pull_opened`, `merged`, `live`), `p50` and `p90` (future instants, p50 ≤ p90) it records an estimate, which the forge resolves when the event happens and a new one supersedes",
  description: "Ask an issue's base rate, or record `event` with `p50`, `p90` (instants) and `basis`.",
  inputSchema: {
    type: "object",
    properties: {
      repo: REPO_ARG,
      issue: { type: "integer", minimum: 1 },
      event: { type: "string", enum: ["pull_opened", "merged", "live"] },
      p50: { type: "string", maxLength: 40 },
      p90: { type: "string", maxLength: 40 },
      basis: { type: "string", maxLength: 300 },
    },
    required: ["repo", "issue"],
  },
  writes: true,
  readsWithout: "event",
  run(ctx, user, args) {
    const repo = repoArg(ctx, user, args);
    if (isAnswer(repo)) return repo;
    const issue = estimateIssue(ctx.app, repo, args["issue"] as number);
    if (issue === undefined || !mayView(ctx.app.db, repo, issue, ctx.auth.user))
      return bad("no_such_issue", `no issue #${String(args["issue"])}`);
    if (args["event"] === undefined) return good(askEstimate(ctx.app, user, repo, issue));
    const made = recordEstimate(ctx.app, user, repo, issue, {
      event: args["event"],
      p50: args["p50"],
      p90: args["p90"],
      basis: args["basis"],
    });
    return made.ok ? good({ says: `Recorded: ${made.value.base.basis}`, ...made.value }) : bad(made.error.kind, made.error.message);
  },
};
@@ -57,6 +57,7 @@
export { tool as economics } from "./economics.ts";
export { tool as edit } from "./edit.ts";
export { tool as egress_grants } from "./egress_grants.ts";
export { tool as email_verify } from "./email_verify.ts";
export { tool as estimate } from "./estimate.ts";
export { tool as events } from "./events.ts";
export { tool as explore } from "./explore.ts";
export { tool as family } from "./family.ts";
@@ -101,6 +101,7 @@
import { stalledScreen } from "./screens/stalled.ts";
import { issuesScreen, newIssueScreen } from "./screens/issues.ts";
import { limbsScreen } from "./screens/limbs.ts";
import { nextScreen } from "./screens/next.ts";
import { estimatesScreen } from "./screens/estimates.ts";
import { findingsScreen } from "./screens/findings.ts";
import { flowsScreen } from "./screens/flows.ts";
import { weekScreen } from "./screens/week.ts";
@@ -177,6 +178,12 @@
const REPO_VERBS: readonly {
    title: "Next up in a repository",
    open: (f, ctx, repo) => nextScreen(f, ctx, repo),
  },
  {
    // What is promised for each issue, the base rate to ask, and recording one (#11955).
    id: "estimates",
    title: "Estimates in a repository",
    open: (f, ctx, repo) => estimatesScreen(f, ctx, repo),
  },
  {
    // The retrospective the forge wrote at the last weekly reset, and its proposals (#8704).
    id: "week",
@@ -0,0 +1,135 @@
/**
 * A repository's estimates, in the terminal (#11955): the issues the crew builds from next, each
 * with what is promised for it, and the same two acts the page, the API and MCP `estimate` reach.
 * Gated as they are: a reader sees the list (sealed issues left to `sealedScope`) and asks an
 * issue's base rate with `a`; recording with `r` is `recordEstimate`, so only a writer or a crew
 * member on the repository can. The line typed is `event p50 p90 basis…`, e.g.
 * `merged 2026-11-14T07:15:00Z 2026-11-14T11:00:00Z a small change`.
 */
import { askEstimate, estimateIssue, recordEstimate, type Asked } from "../../actions/estimates.ts";
import { currentByNumber, type EstimateRow } from "../../core/estimates.ts";
import { nextUp, type NextRow } from "../../core/next_up.ts";
import { canRead, canWrite, type Repo } from "../../core/repos.ts";
import { mayView, sealedScope } from "../../core/sealed.ts";
import { estimateLine } from "../../flow/estimate_words.ts";
import type { Ctx, Screen } from "../app/app.ts";
import { binding } from "../app/keys.ts";
import { fill, len, split } from "../ui/layout.ts";
import { style } from "../term/style.ts";
import { truncate } from "../term/width.ts";
import type { Session } from "../session.ts";
import { ListState, drawList, live, promptScreen, type ListRow } from "./common.ts";
/** The rows shown: the top of the list, as the page's. */
const SHOWN = 100;
const LIVE_KINDS = ["issue.estimated", "issue.ranked", "issue.opened", "issue.closed", "issue.reopened"];
/** `event p50 p90 basis…` as the act's input. */
export function parseEstimate(line: string): { event: string; p50: string; p90: string; basis: string } | undefined {
  const m = /^\s*(\S+)\s+(\S+)\s+(\S+)(?:\s+(.*))?$/s.exec(line);
  return m === null ? undefined : { event: m[1]!, p50: m[2]!, p90: m[3]!, basis: (m[4] ?? "").trim() };
}
export function estimatesScreen(f: Session, ctx: Ctx, repo: Repo): Screen {
  const state = new ListState();
  let rows: readonly NextRow[] = [];
  let promised = new Map<number, EstimateRow[]>();
  let asked: Asked | undefined;
  let loaded = false;
  // Read at use, not at open: access can change under a session.
  const may = (): boolean => f.user !== undefined && canWrite(f.db, repo, f.user);
  const reload = (): void => {
    if (!canRead(f.db, repo, f.user)) {
      rows = [];
      promised = new Map();
    } else {
      const scope = sealedScope(f.db, repo, f.user);
      rows = nextUp(f.db, repo, scope).rows.slice(0, SHOWN);
      promised = currentByNumber(f.db, repo.id, rows.filter((r) => r.issue.estimated).map((r) => r.issue.number));
    }
    loaded = true;
    state.clamp(rows.length);
    ctx.invalidate();
  };
  const current = (): NextRow | undefined => rows[state.index];
  const target = () => {
    const row = current();
    // The act's own gate for one issue: a kind of issue the viewer may see.
    const issue = row === undefined ? undefined : estimateIssue(f.app, repo, row.issue.number);
    return issue !== undefined && mayView(f.db, repo, issue, f.user) ? issue : undefined;
  };
  const ask = (): void => {
    const issue = target();
    if (issue === undefined || !canRead(f.db, repo, f.user)) return;
    asked = askEstimate(f.app, f.user, repo, issue);
    ctx.invalidate();
  };
  const record = (): void => {
    const issue = target();
    if (issue === undefined || !may()) return;
    ctx.push(
      promptScreen(ctx, screen, {
        title: `Estimate #${issue.number}`,
        label: "event p50 p90 basis: event is pull_opened, merged or live; times like 2026-11-14T07:15:00Z",
        onSubmit: (raw) => {
          const input = parseEstimate(raw);
          if (input === undefined) return "event, p50 and p90 first, then the basis";
          const made = recordEstimate(f.app, f.user!, repo, issue, input);
          if (!made.ok) return made.error.message;
          ctx.toast(`Recorded: ${made.value.base.basis}`, "success");
          reload();
          return undefined;
        },
      }),
    );
  };
  const lines = (): ListRow[] =>
    rows.map((r) => {
      const words = estimateLine(promised.get(r.issue.number) ?? [], Date.now());
      return { title: `#${r.issue.number} ${r.issue.title}`, meta: words ?? "no estimate" };
    });
  const screen: Screen = {
    title: `${repo.ownerName}/${repo.name} — Estimates`,
    get keys() {
      return [
        binding(["j", "k"], "move cursor"),
        binding(["a"], "ask the base rate", { disabled: current() === undefined }),
        binding(["r"], "record an estimate", { disabled: !may() || current() === undefined }),
      ];
    },
    load(signal) {
      live(f, signal, { repoId: repo.id, kinds: LIVE_KINDS }, () => reload());
      reload();
      return Promise.resolve();
    },
    render(area, s) {
      const c = ctx.theme.c;
      const [head, list] = split(area, "v", [len(2), fill(1)]);
      const note = !loaded
        ? "Loading…"
        : rows.length === 0
          ? "Nothing is ready to estimate."
          : `a asks the base rate for the issue under the cursor${may() ? ", r records an estimate" : "; you can read estimates, not record them"}`;
      s.text(head!.x, head!.y, truncate(note, head!.w), style(c.mutedFg, c.bg), head!.x + head!.w);
      const said = asked === undefined ? "" : `#${asked.number}: ${asked.base.basis}`;
      s.text(head!.x, head!.y + 1, truncate(said, head!.w), style(c.fg, c.bg), head!.x + head!.w);
      drawList(s, list!, c, state, lines());
    },
    key(e) {
      if (state.key(e, rows.length)) return true;
      if (e.ctrl || e.alt) return false;
      if (e.key === "a") ask();
      else if (e.key === "r") record();
      else return false;
      return true;
    },
  };
  return screen;
}
@@ -0,0 +1,27 @@
/**
 * The estimate scorecard on /flow (#11955), over the repositories the viewer may read: per
 * estimator, then per size and kind, how late (or early) the median ran and how often the p90 held.
 */
import { estimatesVisibleTo } from "../../core/estimates.ts";
import type { User } from "../../core/users.ts";
import type { Database } from "bun:sqlite";
import { biasWords, scoreboard, type Score } from "../../flow/estimate_score.ts";
import { html, type Html } from "../html.ts";
import { icon, row } from "../ui.ts";
const counts = (s: Score): string => `${String(s.resolved)} resolved · ${String(s.void)} void · ${String(s.open)} open`;
/** One row per score: "steward · small bug: median 2.4× late, p90 held 55% · 6 resolved …". */
export function estimatesSection(db: Database, viewer: User | undefined): Html {
  const scores = scoreboard(estimatesVisibleTo(db, viewer));
  if (scores.length === 0) return html``;
  return html`<h2>Estimates</h2>
    <p class="muted small">The p90 should hold about 90% of the time.</p>
      
        sentinelcrew
        2d ago
        outdated
      
      Principle 1 and 8: this paragraph explains the page twice. One plain sentence at most. Also scores here cover all repos, including private ones: scope to what the viewer can see.
    
    <ul class="list mb" id="estimate-scores">${scores.map((s) =>
      row({
        lead: icon("activity"),
        title: html`${s.who}${s.group === "" ? "" : ` · ${s.group}`}`,
        meta: html`${biasWords(s) ?? "nothing resolved yet"} · ${counts(s)}`,
      }),
    )}</ul>`;
}
@@ -24,6 +24,7 @@
import { handoverSection } from "./flow-handover.ts";
import { readDrifts } from "../../flow/alarm_drift.ts";
import { readHandoverLists } from "../../flow/handover_read.ts";
import { readWaiting, waitingSection } from "./flow-waiting.ts";
import { estimatesSection } from "./flow-estimates.ts";
import { clogSection, readClogView } from "./flow-clog.ts";
import { cpuStopsSection } from "./flow-cpu.ts";
import { cpuClosedPulls } from "../../flow/cpu_closed.ts";
@@ -108,6 +109,7 @@
export async function flowPage(ctx: Ctx): Promise<Response> {
    ${clogSection(readClogView(ctx.app.db))}
    ${cpuStopsSection(cpuStops(ctx.app.db).stopped, cpuClosedPulls(ctx.app.db, new Date()))}
    ${waitingSection(await readWaiting(ctx.app.db, ctx.app.reposRoot, new Date()))}
    ${estimatesSection(ctx.app.db, ctx.auth.user)}
    ${pipesSvg(p)}
    <p class="muted small">${money(p.usd)} spent in the last 7 days; ${plural(p.shipped, "pull")} shipped.</p>
    ${handoverSection(readHandoverLists(ctx.app.db, await readDrifts(ctx.app), Date.now()))}
@@ -7,6 +7,8 @@
 * beside each action (`j`/`k` choose the row), which post the same form.
 */
import { placeOf, rankIssue, rankedWords, stepTo, type Place } from "../../actions/next.ts";
import { currentByNumber } from "../../core/estimates.ts";
import { estimateLine } from "../../flow/estimate_words.ts";
import { nextUp, TOP, type NextRow } from "../../core/next_up.ts";
import { openPullStages } from "../../flow/read.ts";
import { stateWord, type StateFacts } from "./next_state.ts";
@@ -157,6 +159,7 @@
function line(
  position: number | null = null,
  state: string | null = null,
  mine = false,
  promise: string | undefined = undefined,
): Html {
  const r = rows[at]!;
  const n = r.issue.number;
@@ -175,7 +178,7 @@
function line(
    title: r.issue.title,
    titleAttr: r.issue.title,
    lead: html`${position === null ? "·" : String(position)}`,
    meta: html`${mine ? html`<span class="mine">Owner's pick</span> · ` : null}${r.role === "blocker" ? "Blocker" : "Enabler"} · #${n}${state === null ? "" : ` · ${state} · ${r.onIt ?? "next"}`} · ${r.roleWhy}${away ? null : html` · <span class="estimate">${rangeWords(priced.find((p) => p.number === n)?.estimate ?? { known: false, samples: 0, basis: "no estimate" })}</span>`}${state !== null || r.onIt === null ? "" : ` · on it: ${r.onIt}`}${r.why === null ? "" : ` · ${r.why}`}`,
    meta: html`${mine ? html`<span class="mine">Owner's pick</span> · ` : null}${r.role === "blocker" ? "Blocker" : "Enabler"} · #${n}${state === null ? "" : ` · ${state} · ${r.onIt ?? "next"}`} · ${r.roleWhy}${away ? null : html` · <span class="estimate">${rangeWords(priced.find((p) => p.number === n)?.estimate ?? { known: false, samples: 0, basis: "no estimate" })}</span>`}${state !== null || r.onIt === null ? "" : ` · on it: ${r.onIt}`}${r.why === null ? "" : ` · ${r.why}`}${promise === undefined ? "" : ` · ${promise}`}`,
    nav: true,
    data: { number: String(n), ...(cost === undefined ? {} : { cost: String(cost) }) },
    ...(controls === null ? {} : { after: controls }),
@@ -209,6 +212,9 @@
export function nextPage(ctx: Ctx): Response {
  const { priced, cut, capacity, sentence } = weekView(ctx.app.db, repo.id, rows, new Date());
  const costs = rowCosts(priced);
  const stages = openPullStages(ctx.app.db, repo, scope, new Date(), new Set(rows.map((r) => r.issue.number)));
  const promised = currentByNumber(ctx.app.db, repo.id, rows.filter((r) => r.issue.estimated).map((r) => r.issue.number));
  const nowMs = Date.now();
  const promise = (r: NextRow): string | undefined => estimateLine(promised.get(r.issue.number) ?? [], nowMs);
  const facts = (r: NextRow): StateFacts => ({ stage: stages.get(r.issue.number) ?? "issue", waits: r.waits, held: r.state === "held", onIt: r.onIt !== null });
  // One numbered order, folded: the first TOP rows open, what comes after, then Later.
  // A filter hides rows but keeps each one's place in the whole ranking.
@@ -220,7 +226,7 @@
export function nextPage(ctx: Ctx): Response {
      <ul class="list setting-list"${id === undefined ? null : html` id="${id}"`}${id !== undefined && !isFiltered && costs !== null && capacity !== null && cut.unsure === null ? html` data-capacity="${String(capacity.usd)}"` : null}>
        ${list.flatMap((at, i) => [
          ...(i === mark && cut.unsure === null && id !== undefined ? [cutMark(cut, false)] : []),
          line(base, rows, at, writer, back, false, priced, costs?.[at], at + 1, stateWord(rows[at]!, facts(rows[at]!)), rows[at]!.byOwner),
          line(base, rows, at, writer, back, false, priced, costs?.[at], at + 1, stateWord(rows[at]!, facts(rows[at]!)), rows[at]!.byOwner, promise(rows[at]!)),
        ])}
      </ul></details>`;
  };
@@ -1,3 +1,4 @@
import type { Database } from "bun:sqlite";
/**
 * One tell in the studio: a tell is one sentence someone said, and the page
 * answers three questions — who has it, what it is waiting on, and what the
@@ -50,6 +51,8 @@
import { repoDir } from "../../git/repos.ts";
import type { Ctx } from "../../http/context.ts";
import { crumbsFor, repoBase, repoHeader, repoPalette } from "../chrome.ts";
import { html, when, type Html } from "../html.ts";
import { currentOf, estimatesOf } from "../../core/estimates.ts";
import { estimateLine } from "../../flow/estimate_words.ts";
import { noteLine } from "./note.ts";
import { threadLine } from "../describe.ts";
import { page } from "../layout.ts";
@@ -522,6 +525,7 @@
async function studioTell(
          badge("Sealed security report", { tone: "danger", icon: "lock" }),
      )}
      ${workSpent(ctx, repo, issue.id)}
      ${promiseLine(db, issue)}
      ${!direction && issue.state === "open" && canWrite(db, repo, user)
        ? flowButton(
            `${thread}/flow`,
@@ -687,3 +691,13 @@
function sealCard(ctx: Ctx, repo: Repo, issue: Issue, action: string): Html | nu
    )}
  </form>`;
}
/**
 * The promise on an issue, in one line: "live by Fri 07:15 (90%: Fri 11:00) · steward · history
 * says Fri 09:40" (#11955).
 */
function promiseLine(db: Database, issue: Issue): Html | null {
  if (!issue.estimated) return null;
  const words = estimateLine(currentOf(estimatesOf(db, issue.id)), Date.now());
  return words === undefined ? null : html`<span class="estimate" id="estimate-line">${words}</span>`;
}
@@ -122,7 +122,7 @@
describe("the one list of what asks first", () => {
  const NOT_ASKED = new Set([
    "access", "account_requests", "account_verify", "app_members", "app_notes", "asks_act", "asks_decide", "asks_proposal", "asks_undecide", "atlas",
    "asks", "assign", "attach_look", "bet", "board_pins", "board_write", "branches", "capacity", "valves", "cloud_accounts", "close", "confirm_wait",
    "crew", "decisions_by", "detach", "economics", "edit", "email_verify", "feed_chips", "feed_dismiss", "feed_like", "flag_set", "flag_winner",
    "crew", "decisions_by", "detach", "economics", "edit", "email_verify", "estimate", "feed_chips", "feed_dismiss", "feed_like", "flag_set", "flag_winner",
    "follow_mode", "fork", "front_page", "hold", "issue_teams", "keep_plan", "knobs", "labels", "lift", "limb", "maintenance", "make_it_yours", "map", "merge", "new_app",
    "next_up", "week", "notify", "open_pull", "org_create", "origin_apps", "pins", "plan", "profile", "propose_to_parent_forge", "repo_labels", "reports",
    "repo", "restore_drill", "review", "say", "signup", "snapshot_now", "spend", "steer", "sync", "take_back", "take_updates",
@@ -0,0 +1,417 @@
/** Estimates against an issue (#11955): ask, record, resolve, void, score. */
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 { askEstimate, recordEstimate } from "../src/actions/estimates.ts";
import { openIssue, setIssueStateThrough } from "../src/actions/issues.ts";
import { mergePull, openPull } from "../src/actions/pulls.ts";
import { commitToBranch, createRepo } from "../src/actions/repos.ts";
import { currentByNumber, currentOf, estimatesOf, estimatesVisibleTo } from "../src/core/estimates.ts";
import { createIssue, getIssue } from "../src/core/issues.ts";
import type { Repo } from "../src/core/repos.ts";
import { createToken } from "../src/core/tokens.ts";
import { createUser, type User } from "../src/core/users.ts";
import { baseRate, quantile, type HistorySample } from "../src/flow/estimate_base.ts";
import { biasWords, lastLine, median, scoreboard } from "../src/flow/estimate_score.ts";
import { durationWords, estimateLine, ratioOf } from "../src/flow/estimate_words.ts";
import { markLive, recordCut } from "../src/keeper/record.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { estimatesScreen, parseEstimate } from "../src/tui/screens/estimates.ts";
import type { Ctx as TuiCtx } from "../src/tui/app/app.ts";
import { keyFor } from "../src/tui/app/keys.ts";
import type { Session } from "../src/tui/session.ts";
const H = 3_600_000;
const NOW = new Date("2026-11-13T12:00:00.000Z");
const at = (ms: number) => new Date(NOW.getTime() + ms).toISOString();
const sample = (n: number, mergedH: number, extra: Partial<HistorySample> = {}): HistorySample => ({
  number: n,
  size: "small",
  kind: "bug",
  builder: null,
  pull: mergedH * H * 0.5,
  merged: mergedH * H,
  live: mergedH * H + 25 * 60_000,
  mergedAtMs: NOW.getTime() - 86_400_000,
  ...extra,
});
describe("the base rate", () => {
  test("six samples: nearest-rank p50 and p90 from now, with the stage after the merge", () => {
    const samples = [1, 2, 3, 4, 5, 6].map((h, i) => sample(i + 1, h));
    const r = baseRate(samples, { size: "small", kind: "bug", builder: null, elapsedMs: 0 }, "trevato/forge", NOW.getTime());
    expect(r.thin).toBe(false);
    expect(r.n).toBe(6);
    // sorted[round(5 * .5)] = sorted[3] = 4 h; sorted[round(5 * .9)] = sorted[5] = 6 h
    expect(r.events.merged!.p50Ms).toBe(4 * H);
    expect(r.events.merged!.p90Ms).toBe(6 * H);
    expect(r.events.merged!.p50At).toBe(at(4 * H));
    expect(r.basis).toContain("6 small bug issues, last 30 days in trevato/forge");
    expect(r.basis).toContain("work start→merged p50 4 h, p90 6 h");
    expect(r.basis).toContain("merged→live p50 25 m, p90 25 m");
  });
  test("fewer than five: it says so and widens, dropping the builder, then the kind", () => {
    const samples = [
      sample(1, 1, { builder: "torque" }),
      sample(2, 2, { builder: "torque" }),
      sample(3, 3, { kind: "" }),
      sample(4, 4, { kind: "" }),
      sample(5, 5, { kind: "" }),
      sample(6, 6, { kind: "" }),
    ];
    const r = baseRate(samples, { size: "small", kind: "bug", builder: "torque", elapsedMs: 0 }, "x/y", NOW.getTime());
    expect(r.widened).toEqual(["dropped the builder", "dropped the kind"]);
    expect(r.n).toBe(6);
    expect(r.thin).toBe(false);
    const few = baseRate(samples.slice(0, 2), { size: "small", kind: "bug", builder: null, elapsedMs: 0 }, "x/y", NOW.getTime());
    expect(few.thin).toBe(true);
    expect(few.basis).toContain("fewer than 5");
  });
  test("work already under way counts only what is left of the slower ones", () => {
    const samples = [1, 2, 3, 4, 5, 6, 7, 8].map((h, i) => sample(i + 1, h));
    const r = baseRate(samples, { size: "small", kind: "bug", builder: null, elapsedMs: 2 * H }, "x/y", NOW.getTime());
    // 3..8 h remain 1..6 h: the same nearest ranks as above
    expect(r.events.merged!.p50Ms).toBe(4 * H);
  });
  test("durations read in words", () => {
    expect([durationWords(25 * 60_000), durationWords(190 * 60_000), durationWords(9 * H), durationWords(52 * H)]).toEqual(["25 m", "3 h 10 m", "9 h", "2 d 4 h"]);
    expect(quantile([1, 2, 3], 0.5)).toBe(2);
  });
});
describe("the scorecard maths", () => {
  const row = (id: number, who: string, p50H: number, actualH: number | null, p90H = p50H * 2, extra: object = {}) => ({
    id, repoId: "r", issueId: `i${id}`, issueNumber: id, event: "merged" as const,
    p50At: at(p50H * H), p90At: at(p90H * H), madeAt: at(0), byId: who, byName: who, byKind: "agent" as const,
    basis: "", baseJson: "null", size: "small", kind: "bug",
    actualAt: actualH === null ? null : at(actualH * H), voidedAt: null,
    state: actualH === null ? ("open" as const) : ("resolved" as const), ...extra,
  });
  test("ratio is actual over p50 from the moment it was made; the median is the bias", () => {
    expect(ratioOf(row(1, "a", 2, 5))).toBe(2.5);
    expect(median([1, 3, 2])).toBe(2);
    expect(median([1, 2, 3, 4])).toBe(2.5);
    const rows = [row(1, "steward", 2, 5), row(2, "steward", 2, 4.8), row(3, "steward", 1, 2.4, 3), row(4, "steward", 2, null)];
    const all = scoreboard(rows).find((s) => s.who === "steward" && s.group === "")!;
    // ratios 2.5, 2.4, 2.4: median 2.4; p90 at 4, 4, 3: the first two missed, the third held
    expect(all.medianRatio).toBeCloseTo(2.4, 10);
    expect(all.p90Hit).toBeCloseTo(1 / 3, 10);
    expect([all.resolved, all.open, all.void]).toEqual([3, 1, 0]);
    expect(biasWords(all)).toBe("median 2.4× late, p90 held 33%");
    expect(lastLine(rows, "steward", true)).toBe("your last 3: median 2.4× late, p90 held 33%");
    expect(scoreboard(rows).some((s) => s.group === "small bug")).toBe(true);
  });
  test("void is counted, never scored; a revision after the fact does not improve the score", () => {
    const rows = [
      row(1, "steward", 2, 6),
      row(2, "steward", 2, 6, 4),
      { ...row(2, "steward", 5, 6, 8), id: 3, issueId: "i2" }, // revised later: kept, not scored
      row(4, "steward", 2, null, 4, { voidedAt: at(H), state: "void" }),
    ];
    const all = scoreboard(rows).find((s) => s.who === "steward" && s.group === "")!;
    expect(all.resolved).toBe(2);
    expect(all.void).toBe(1);
    expect(all.medianRatio).toBe(3);
  });
  test("the base rate shown at the time is scored as `history`", () => {
    const baseJson = JSON.stringify({ events: { merged: { p50At: at(3 * H), p90At: at(9 * H) } } });
    const rows = [row(1, "steward", 2, 3, 4, { baseJson })];
    const history = scoreboard(rows).find((s) => s.who === "history" && s.group === "")!;
    expect(history.medianRatio).toBe(1);
    expect(history.p90Hit).toBe(1);
  });
  test("the line: open, then resolved with its ratio", () => {
    const open = row(1, "steward", 2, null, 6, { baseJson: JSON.stringify({ events: { merged: { p50At: at(3 * H) } } }) });
    expect(estimateLine([open], NOW.getTime())).toBe("merged by Fri 14:00 (90%: Fri 18:00) · steward · history says Fri 15:00");
    expect(estimateLine([row(1, "steward", 2, 3)], NOW.getTime())).toBe("merged Fri 15:00, 1.5× the estimate");
  });
});
describe("recording and resolving on the forge", () => {
  let dataDir = "";
  let app: App;
  let servers: Servers;
  let alice: User;
  let stranger: User;
  let repo: Repo;
  let rw = "";
  const issue = (title: string, body = "") => {
    const o = openIssue(app, alice, repo, { title, body });
    if (!o.ok) throw new Error(String(o.error));
    return o.value;
  };
  const getI = (n: number) => getIssue(app.db, repo.id, n)!;
  const say = (n: number, event: unknown, p50: string, p90: string, now = NOW, who = alice) =>
    recordEstimate(app, who, repo, getI(n), { event, p50, p90, basis: "by hand" }, now);
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-estimates-"));
    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 = made.value;
    const other = await createUser(app.db, { origin: "seed", trusted: true, username: "mallory", email: "[email protected]", password: "a-good-passphrase" });
    if (!other.ok) throw new Error(other.error);
    stranger = other.value;
    const r = await createRepo(app, alice, { name: "forge", visibility: "public" });
    if (!r.ok) throw new Error(String(r.error));
    repo = r.value;
    await commitToBranch(app, alice, repo, { branch: "main", message: "base", files: [{ path: "a.txt", content: "a\n" }] });
    rw = createToken(app.db, alice.id, "rw", "rw").token;
  }, 30_000);
  afterAll(async () => {
    await servers.stop();
    app.close();
    await rm(dataDir, { recursive: true, force: true, maxRetries: 20, retryDelay: 100 });
  });
  test("ask: the base rate comes from seeded history", () => {
    for (let i = 0; i < 6; i++) {
      const done = createIssue(app.db, { repoId: repo.id, authorId: alice.id, title: `done ${i}`, body: "" });
      if (!done.ok) throw new Error("issue");
      const pr = createIssue(app.db, { repoId: repo.id, authorId: alice.id, title: `pr ${i}`, body: `Closes #${done.value.number}`, kind: "pull" });
      if (!pr.ok) throw new Error("pull");
      const created = new Date(NOW.getTime() - (i + 2) * 86_400_000).toISOString();
      const merged = new Date(NOW.getTime() - (i + 2) * 86_400_000 + (i + 1) * H).toISOString();
      app.db.query(`UPDATE issue SET state='closed', close_reason='done', created_at=?2 WHERE id=?1`).run(done.value.id, created);
      app.db.query(`INSERT INTO pull (issue_id, base_branch, head_branch, base_oid, head_oid, merged_at) VALUES (?1,'main','b','a','b',?2)`).run(pr.value.id, merged);
    }
    const target = issue("a small thing");
    const asked = askEstimate(app, alice, repo, target, NOW);
    expect(asked.base.n).toBe(6);
    expect(asked.base.thin).toBe(false);
    expect(asked.base.events.merged!.p50Ms).toBe(4 * H);
    expect(asked.base.events.merged!.p90Ms).toBe(6 * H);
    expect(asked.facts.queuePosition).not.toBeNull();
    expect(asked.facts.budgetLeftUsd.day).toBeGreaterThanOrEqual(0);
    expect(asked.scorecard).toBe("you have no resolved estimates yet");
  });
  test("record: validated, stamped, and a new one supersedes while the old stays", () => {
    const n = issue("record me").number;
    expect(say(n, "nonsense", at(H), at(2 * H)).ok).toBe(false);
    expect(say(n, "merged", at(-H), at(2 * H)).ok).toBe(false);
    expect(say(n, "merged", at(3 * H), at(2 * H)).ok).toBe(false);
    expect(say(n, "merged", "tomorrow", at(2 * H)).ok).toBe(false);
    const nobody = say(n, "merged", at(H), at(2 * H), NOW, stranger);
    expect(nobody.ok).toBe(false);
    if (!nobody.ok) expect(nobody.error.kind).toBe("forbidden");
    expect(estimatesOf(app.db, getI(n).id)).toHaveLength(0);
    const first = say(n, "merged", at(H), at(2 * H));
    expect(first.ok).toBe(true);
    if (!first.ok) return;
    expect(first.value.estimate).toMatchObject({ byName: "alice", byKind: "person", madeAt: NOW.toISOString(), event: "merged", state: "open" });
    expect(JSON.parse(first.value.estimate.baseJson).events).toBeDefined();
    const second = say(n, "merged", at(4 * H), at(5 * H));
    expect(second.ok).toBe(true);
    const rows = estimatesOf(app.db, getI(n).id);
    expect(rows).toHaveLength(2);
    expect(currentOf(rows)[0]!.p50At).toBe(at(4 * H));
    expect(rows[0]!.p50At).toBe(at(H));
  });
  test("resolved by the forge: pull opened, merged, and live; never by hand", async () => {
    const t = issue("ship me");
    const real = new Date();
    const soon = (h: number) => new Date(real.getTime() + h * H).toISOString();
    for (const ev of ["pull_opened", "merged", "live"] as const) {
      const made = recordEstimate(app, alice, repo, t, { event: ev, p50: soon(1), p90: soon(2) }, real);
      expect(made.ok).toBe(true);
    }
    await commitToBranch(app, alice, repo, { branch: "ship", base: "main", message: "ship", files: [{ path: "s.txt", content: "s\n" }] });
    const opened = await openPull(app, alice, repo, { title: "Ship it", body: `Closes #${t.number}`, baseBranch: "main", headBranch: "ship" });
    if (!opened.ok) throw new Error(JSON.stringify(opened.error));
    const state = () => Object.fromEntries(estimatesOf(app.db, t.id).map((e) => [e.event, e.state]));
    expect(state()).toEqual({ pull_opened: "resolved", merged: "open", live: "open" });
    // Asking for an event that already happened is refused.
    expect(recordEstimate(app, alice, repo, t, { event: "pull_opened", p50: soon(1), p90: soon(2) }, real).ok).toBe(false);
    const merged = await mergePull(app, alice, repo, opened.value, "squash");
    if (!merged.ok) throw new Error(JSON.stringify(merged.error));
    expect(state()).toEqual({ pull_opened: "resolved", merged: "resolved", live: "open" });
    // A release cut before the merge does not carry it; one cut after does, and its going live
    // resolves.
    const before = recordCut(app.db, { version: "v-old", sha: "a", knownGood: { version: "k", image: "i" }, at: real.getTime() - 3_600_000 });
    markLive(app.db, before.id, real.getTime() + 1000);
    app.bus.append({ kind: "release.verified_live", repoId: repo.id, payload: { version: "v-old" } });
    expect(state().live).toBe("open");
    const cut = recordCut(app.db, { version: "v-new", sha: "b", knownGood: { version: "k", image: "i" }, at: real.getTime() + 2000 });
    expect(markLive(app.db, cut.id, real.getTime() + 60_000)).toBe(true);
    // Settled when the release is verified, not when it merely answers.
    expect(state().live).toBe("open");
    app.bus.append({ kind: "release.verified_live", repoId: repo.id, payload: { version: "v-new" } });
    expect(state()).toEqual({ pull_opened: "resolved", merged: "resolved", live: "resolved" });
    const live = estimatesOf(app.db, t.id).find((e) => e.event === "live")!;
    expect(live.actualAt).toBe(new Date(real.getTime() + 60_000).toISOString());
    expect(estimateLine([live], real.getTime())).toContain("went live");
  }, 30_000);
  test("an issue closed as split or dropped voids what it left open; done does not", async () => {
    const split = issue("too big");
    const dropped = issue("not wanted");
    for (const t of [split, dropped]) expect(say(t.number, "merged", at(H), at(2 * H)).ok).toBe(true);
    const a = await setIssueStateThrough(app, alice, repo, split, "closed", { reason: "split", into: [issue("half").number] });
    expect(a.ok).toBe(true);
    const b = await setIssueStateThrough(app, alice, repo, dropped, "closed", { reason: "dropped" });
    expect(b.ok).toBe(true);
    expect(estimatesOf(app.db, split.id)[0]).toMatchObject({ state: "void" });
    expect(estimatesOf(app.db, dropped.id)[0]!.voidedAt).not.toBeNull();
    // Closed as done, the promise is kept to be resolved by the merge; nothing voids it.
    const finished = issue("finished by hand");
    expect(say(finished.number, "merged", at(H), at(2 * H)).ok).toBe(true);
    const c = await setIssueStateThrough(app, alice, repo, finished, "closed", { reason: "done" });
    expect(c.ok).toBe(true);
    expect(estimatesOf(app.db, finished.id)[0]).toMatchObject({ state: "open", voidedAt: null });
    const voidRow = scoreboard(estimatesVisibleTo(app.db, alice)).find((s) => s.who === "alice" && s.group === "")!;
    expect(voidRow.void).toBeGreaterThanOrEqual(2);
  });
  test("the API asks and records, and the issue page and /next carry the line", async () => {
    const t = issue("api and page");
    const url = `${servers.url}/api/v1/repos/alice/forge/issues/${t.number}/estimates`;
    const asked = await fetch(url, { headers: { authorization: `Bearer ${rw}` } });
    expect(asked.status).toBe(200);
    expect(((await asked.json()) as any).base.basis).toBeString();
    const soon = (h: number) => new Date(Date.now() + h * H).toISOString();
    const bad = await fetch(url, { method: "POST", headers: { authorization: `Bearer ${rw}`, "content-type": "application/json" }, body: JSON.stringify({ event: "live", p50: soon(3), p90: soon(1) }) });
    expect(bad.status).toBe(422);
    const ok = await fetch(url, { method: "POST", headers: { authorization: `Bearer ${rw}`, "content-type": "application/json" }, body: JSON.stringify({ event: "live", p50: soon(3), p90: soon(5), basis: "api" }) });
    expect(ok.status).toBe(201);
    const page = await (await fetch(`${servers.url}/alice/forge/issues/${t.number}`)).text();
    expect(page).toContain("live by");
    expect(page).toContain("· alice");
    const next = await (await fetch(`${servers.url}/alice/forge/next`)).text();
    expect(next).toContain("live by");
  });
  test("the MCP tool asks with no times and records with them", async () => {
    const t = issue("mcp");
    const call = async (args: unknown) => {
      const res = await fetch(`${servers.url}/mcp`, {
        method: "POST",
        headers: { "content-type": "application/json", accept: "application/json, text/event-stream", authorization: `Bearer ${rw}` },
        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "estimate", arguments: args } }),
      });
      const body = (await res.json()) as any;
      return { error: body.result.isError === true, value: body.result.isError === true ? body.result.content[0].text : JSON.parse(body.result.content[0].text) };
    };
    const asked = await call({ repo: "alice/forge", issue: t.number });
    expect(asked.error).toBe(false);
    expect(asked.value.base).toBeDefined();
    const soon = (h: number) => new Date(Date.now() + h * H).toISOString();
    const made = await call({ repo: "alice/forge", issue: t.number, event: "merged", p50: soon(1), p90: soon(2), basis: "mcp" });
    expect(made.error).toBe(false);
    const refused = await call({ repo: "alice/forge", issue: t.number, event: "merged", p50: soon(2), p90: soon(1) });
    expect(refused.error).toBe(true);
  });
});
describe("who sees what, and how much is read", () => {
  let dir: string;
  let a: App;
  let owner: User;
  let outsider: User;
  let hidden: Repo;
  let shown: Repo;
  beforeAll(async () => {
    dir = await mkdtemp(join(tmpdir(), "forge-estimates-scope-"));
    a = createApp({ dataDir: dir, port: 0 });
    const o = await createUser(a.db, { origin: "seed", trusted: true, username: "olive", email: "[email protected]", password: "a-good-passphrase", adminIfFirst: true });
    const x = await createUser(a.db, { origin: "seed", trusted: true, username: "xavier", email: "[email protected]", password: "a-good-passphrase" });
    if (!o.ok || !x.ok) throw new Error("users");
    owner = o.value;
    outsider = x.value;
    const priv = await createRepo(a, owner, { name: "vault", visibility: "private" });
    const pub = await createRepo(a, owner, { name: "open", visibility: "public" });
    if (!priv.ok || !pub.ok) throw new Error("repos");
    hidden = priv.value;
    shown = pub.value;
  }, 30_000);
  afterAll(async () => {
    a.close();
    await rm(dir, { recursive: true, force: true, maxRetries: 20, retryDelay: 100 });
  });
  const promise = (repo: Repo, title: string) => {
    const made = createIssue(a.db, { repoId: repo.id, authorId: owner.id, title, body: "" });
    if (!made.ok) throw new Error("issue");
    const soon = (h: number) => new Date(Date.now() + h * H).toISOString();
    const r = recordEstimate(a, owner, repo, made.value, { event: "merged", p50: soon(1), p90: soon(2) });
    if (!r.ok) throw new Error(r.error.message);
    return made.value;
  };
  test("the scorecards leave out repositories the viewer cannot read", () => {
    promise(hidden, "secret plan");
    promise(shown, "public plan");
    const sees = (u: User | undefined) => estimatesVisibleTo(a.db, u).map((e) => e.repoId);
    expect(sees(undefined)).toEqual([shown.id]);
    expect(sees(outsider)).toEqual([shown.id]);
    expect(new Set(sees(owner))).toEqual(new Set([hidden.id, shown.id]));
    // The asker's own card reads the same scope: no private estimate of
    // someone else's is in it.
    expect(estimatesVisibleTo(a.db, outsider, owner.id).map((e) => e.repoId)).toEqual([shown.id]);
  });
  test("a list names its issues and reads only theirs", () => {
    const one = promise(shown, "listed");
    promise(shown, "not listed");
    const got = currentByNumber(a.db, shown.id, [one.number]);
    expect([...got.keys()]).toEqual([one.number]);
    expect(currentByNumber(a.db, shown.id, [])).toEqual(new Map());
  });
  test("moving an issue to Not now voids its open estimates; a duplicate is a drop", async () => {
    const gate = openIssue(a, owner, shown, { title: "Later gate: not now" });
    expect(gate.ok).toBe(true);
    const t = promise(shown, "to defer");
    const { rankIssue } = await import("../src/actions/next.ts");
    const moved = rankIssue(a, owner, shown, t.number, { to: "not_now" });
    expect(moved.ok).toBe(true);
    expect(estimatesOf(a.db, t.id)[0]).toMatchObject({ state: "void" });
    const dup = promise(shown, "a duplicate");
    const closed = await setIssueStateThrough(a, owner, shown, dup, "closed", { reason: "dropped", note: "duplicate of another" });
    expect(closed.ok).toBe(true);
    expect(estimatesOf(a.db, dup.id)[0]).toMatchObject({ state: "void" });
  });
  test("the terminal door: a reader asks, only a writer records, a private repository shows nothing", async () => {
    const t = promise(shown, "on the screen");
    const session = (user: User | undefined) => ({ user, db: a.db, app: a }) as unknown as Session;
    const run = async (user: User | undefined, repo: Repo, key: string) => {
      const pushed: unknown[] = [];
      let drawn = 0;
      const ctx = { toast() {}, invalidate: () => drawn++, push: (x: unknown) => pushed.push(x), theme: {} } as unknown as TuiCtx;
      const screen = estimatesScreen(session(user), ctx, repo);
      await screen.load?.(new AbortController().signal);
      const before = drawn;
      screen.key?.(keyFor(key)!);
      return { pushed: pushed.length, drew: drawn - before };
    };
    expect(t.number).toBeGreaterThan(0);
    // Asking redraws with the answer for anyone who can read; recording
    // opens the prompt for a writer only.
    expect((await run(outsider, shown, "a")).drew).toBe(1);
    expect((await run(outsider, shown, "r")).pushed).toBe(0);
    expect((await run(owner, shown, "r")).pushed).toBe(1);
    // The private repository lists nothing to an outsider: no ask, no record.
    expect(await run(outsider, hidden, "a")).toEqual({ pushed: 0, drew: 0 });
    expect(await run(outsider, hidden, "r")).toEqual({ pushed: 0, drew: 0 });
    expect(parseEstimate("merged 2026-11-14T07:15:00Z 2026-11-14T11:00:00Z a small change")).toEqual({ event: "merged", p50: "2026-11-14T07:15:00Z", p90: "2026-11-14T11:00:00Z", basis: "a small change" });
    expect(parseEstimate("merged only")).toBeUndefined();
  });
});
@@ -60,6 +60,7 @@
function paperIssue(n: number, state: "open" | "closed" = "open"): Issue {
    assigneeIsAgent: false,
    authorIsAgent: false,
    sealed: false,
    estimated: false,
  };
}
@@ -382,6 +382,7 @@
describe("the forge over MCP", () => {
      "ssh_keys",
      "steer",
      "email_verify",
      "estimate",
      "parent_unlink",
      "vision",
      "boards",
@@ -56,6 +56,7 @@
const NOT_PAGES = new Set([
/** Patterns with an id in them, and the path the fixture fills them with. */
const FIXTURE: Record<string, string> = {
  "/:owner/:name/issues/:number": "/alice/forge/issues/1",
  "/api/v1/repos/:owner/:name/issues/:number/estimates": "/api/v1/repos/alice/forge/issues/1/estimates",
  "/:owner/:name/pulls/:number": "/alice/forge/pulls/2",
  "/:owner/:name/display": "/alice/forge/display",
  "/api/v1/admin/machines/:machine/disks": "/api/v1/admin/machines/rack1/disks",
@@ -70,6 +70,7 @@
test("a site-admin person is offered the whole roster", () => {
    ["pulls", "Pull requests in a repository", "owner/name"],
    ["milestones", "Milestones in a repository", "owner/name"],
    ["next-up", "Next up in a repository", "owner/name"],
    ["estimates", "Estimates in a repository", "owner/name"],
    ["week", "The week in a repository", "owner/name"],
    ["flows", "Flows of a repository", "owner/name"],
    ["findings", "Findings in a repository", "owner/name"],
@@ -232,6 +233,7 @@
test("a site-admin agent is offered the roster without the person-only entries",
    ["pulls", "Pull requests in a repository", "owner/name"],
    ["milestones", "Milestones in a repository", "owner/name"],
    ["next-up", "Next up in a repository", "owner/name"],
    ["estimates", "Estimates in a repository", "owner/name"],
    ["week", "The week in a repository", "owner/name"],
    ["flows", "Flows of a repository", "owner/name"],
    ["findings", "Findings in a repository", "owner/name"],
@@ -320,6 +322,7 @@
test("a member person is offered the signed-in roster without the admin entries"
    ["pulls", "Pull requests in a repository", "owner/name"],
    ["milestones", "Milestones in a repository", "owner/name"],
    ["next-up", "Next up in a repository", "owner/name"],
    ["estimates", "Estimates in a repository", "owner/name"],
    ["week", "The week in a repository", "owner/name"],
    ["flows", "Flows of a repository", "owner/name"],
    ["findings", "Findings in a repository", "owner/name"],
@@ -403,6 +406,7 @@
test("signed out, the palette offers sign-in and the public entries", () => {
    ["pulls", "Pull requests in a repository", "owner/name"],
    ["milestones", "Milestones in a repository", "owner/name"],
    ["next-up", "Next up in a repository", "owner/name"],
    ["estimates", "Estimates in a repository", "owner/name"],
    ["week", "The week in a repository", "owner/name"],
    ["flows", "Flows of a repository", "owner/name"],
    ["findings", "Findings in a repository", "owner/name"],
@@ -21,6 +21,7 @@
import { seedAdmin } from "./helpers/admin.ts";
const UNTIMED: Record<string, string> = {
  "/api/v1/conversations": "a person's conversation list, one indexed query; no page to phase",
  "/api/v1/admin/machines/:machine/disks": "an owner's per-machine disk summary, one indexed read; no page to phase",
  "/api/v1/repos/:owner/:name/issues/:number/estimates": "an issue's base rate from one indexed read of its history; no page to phase",
  "/metrics": "Prometheus text exposition, scraped by token; not a page read",
};
		@@ -161,3 +161,7 @@ toward no file's heat and is named on the feed (`too wide to count: #4840
161	161	`src/crew/stale_reds.ts` `sweepStaleReds(app, repo, now, room)` runs each autonomy tick and reads only the database, so a restart or roll loses nothing. An open crew pull whose latest check on its head failed, with no run in 30 minutes and no person holding or assigned to it, is re-checked (reason `sweep`); still red, its builder is queued with the failing test named, within the free slots and 3 a tick. Past its tries it is parked and its issue is ready again. Red for over 24 h and conflicting with main, or with its issue closed, it is closed with one line. The flow report's `stale_reds` line (`src/flow/stale_reds.ts`) counts the ones not yet handled, and the keeper names `stale_reds` as a cause from 3.
162	162
163	163	How a person sees stale reds: `bun scripts/flow-report.ts` prints the `stale_reds:` line (count and oldest hours), and the keeper names `stale_reds` as the cause when they are what holds the flow; the terminal Flow dialog draws the keeper's line (`keeperLine`), so it shows there when the keeper picks that cause. It has no line of its own on the dialog.
	164
	165	## Estimates (#11955)
	166
	167	Estimates are recorded against an issue, asked for from the forge's own history and scored: see `docs/features/estimates.md`.
		@@ -98,6 +98,7 @@ bytes in `tools/list`. After changing a tool run `bun scripts/mcp-table.ts`;
98	98	\| `edit` \| — \| Retitle or rewrite an issue or pull: yours, or where you write; an agent only its own \| 310 \|
99	99	\| `egress_grants` \| — \| Private destinations and grants: list, grant or revoke (site admin) \| 289 \|
100	100	\| `email_verify` \| — \| Send yourself a new verification link \| 126 \|
	101	\| `estimate` \| — \| Ask an issue's base rate, or record `event` with `p50`, `p90` (instants) and `basis` \| 399 \|
101	102	\| `events` \| — \| Repository events \| 259 \|
102	103	\| `explore` \| — \| The apps, people (and, for an admin, forges) you can see, ranked \| 627 \|
103	104	\| `family` \| — \| The forge that sent this one and, for a site admin, those it sent, with state, version \| 205 \|
		@@ -0,0 +1,17 @@
	1	# Estimates (#11955)
	2
	3	An estimate is a promise about when one issue's work happens, kept against the issue and scored. Rows are never edited: a new one supersedes and the old stays as data.
	4
	5	1. Ask the base rate for an issue: MCP `estimate` with `{ repo, issue }`, `GET /api/v1/repos/:owner/:name/issues/:n/estimates`, or in the terminal open the repository, choose Estimates in a repository from the palette and press `a` on the issue. It comes from the forge's own history (`src/flow/estimate_base.ts`): merged pulls in the last 30 days of the same repository, size and kind (and builder when assigned), measured from the first agent run on the issue (else its creation) to the pull opening, the merge and the release that carried the merge going live. Quantiles are nearest-rank, `sorted[round((n - 1) * q)]`. Under five samples it says so and widens: builder, kind, size, then 90 days. It adds what history does not know (queue position, runs going, budget left, why a release is held) and your own scorecard. Anyone who may read the issue may ask.
	6	2. Record one: the same tool with `event` (`pull_opened`, `merged`, `live`), `p50`, `p90` (future instants, p50 ≤ p90) and `basis`; `POST` to the same URL; or `r` on the terminal screen, typing `event p50 p90 basis…` (for example `merged 2026-11-14T07:15:00Z 2026-11-14T11:00:00Z a small change`). Only someone with write access, or a crew member on the repository, records, and only on an open issue.
	7	3. See it: the issue page and `/next` carry the line ("live by Fri 07:15 (90%: Fri 11:00) · steward · history says Fri 09:40"); `/flow` carries the scorecard.
	8
	9	## What the forge does
	10
	11	Nobody settles an estimate by hand. `src/actions/estimates_settle.ts` is the one place that hears of the events on the bus: a pull that says `Closes #N` opening or merging sets the actual instant of `pull_opened` or `merged`; `release.verified_live` resolves each open `live` estimate at the first release cut after its merge that served. An issue closed as dropped or split, or moved to Not now (`src/actions/next.ts`), voids what it left open: the rows stay, marked void, never scored. Closing as done voids nothing. `live` resolves only for the forge's own releases, not an app's production deploy.
	12
	13	## Scores
	14
	15	`src/flow/estimate_score.ts`: ratio = actual / p50 duration, both from the moment the estimate was made; the median ratio is the bias; the p90 hit rate should be about 90%. Only an estimator's first estimate per issue and event counts, so revising late cannot improve a score. The base rate shown at the time is scored as the estimator `history`. The scorecards read the newest 5,000 estimates in repositories the viewer may read, so a private repository's estimators, sizes and counts show only to those who can open it.
	16
	17	Tests: `test/estimates.test.ts`.
		@@ -0,0 +1,198 @@
	1	/**
	2	* The `estimate` act (#11955), one tool for two uses: ask the base rate for an
	3	* issue, or record an estimate against it. The page, the API, MCP and the
	4	* terminal call these and say the same words. Validation is here, at the
	5	* boundary; rows and maths are `core/estimates.ts` and `flow/estimate_*`.
	6	*/
	7	import type { App } from "../app.ts";
	8	import { addEstimate, currentOf, estimatesOf, estimatesVisibleTo, isEvent, type EstimateEvent, type EstimateRow } from "../core/estimates.ts";
	9	import { forgeSource } from "../settings/forge_source.ts";
	10	import { getIssue, type Issue } from "../core/issues.ts";
	11	import { mergedPullClosing, openPullsClosing } from "../core/pulls.ts";
	12	import { nextUp } from "../core/next_up.ts";
	13	import { canWrite, type Repo } from "../core/repos.ts";
	14	import { listActiveRuns } from "../core/runs.ts";
	15	import type { User } from "../core/users.ts";
	16	import { budgetLines } from "../crew/forge_budget.ts";
	17	import { baseRate, historySamples, type BaseRate } from "../flow/estimate_base.ts";
	18	import { kindOf, labelsOf, sizeOf } from "../flow/estimate.ts";
	19	import { lastLine } from "../flow/estimate_score.ts";
	20	import { estimateLine } from "../flow/estimate_words.ts";
	21	import { blocking, standingHolds } from "../keeper/hold.ts";
	22	import { err, ok, type Result } from "../kernel/result.ts";
	23
	24	export const ESTIMATE_FORBIDDEN = "Only someone with write access, or a crew member on this repository, records an estimate.";
	25	export const ESTIMATE_NOT_OPEN = "Only an open issue is estimated.";
	26	export const ESTIMATE_SHAPE =
	27	"`event` is pull_opened, merged or live; `p50` and `p90` are instants like 2026-11-14T07:15:00Z, both in the future with p50 no later than p90; `basis` is one line, at most 300 characters.";
	28	export const ESTIMATE_PASSED = "That event has already happened, so it is not estimated.";
	29	const BASIS_MAX = 300;
	30	const INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z\|[+-]\d{2}:\d{2})$/;
	31
	32	export type EstimateError = { kind: "not_found" \| "forbidden" \| "invalid"; message: string };
	33
	34	/** What is true now that history does not know. */
	35	export interface NowFacts {
	36	/** Place on /next, 1 at the top; null when the issue is not on the list. */
	37	readonly queuePosition: number \| null;
	38	readonly listed: number;
	39	/** Agent runs going on this repository now. */
	40	readonly buildersBusy: number;
	41	/** USD left of the forge's day and month budgets. */
	42	readonly budgetLeftUsd: { readonly day: number; readonly month: number };
	43	/** Why the keeper will not cut a release now; null when nothing holds one. */
	44	readonly releasesHeld: string \| null;
	45	}
	46
	47	export interface Asked {
	48	readonly repo: string;
	49	readonly number: number;
	50	readonly size: string;
	51	readonly kind: string;
	52	readonly now: string;
	53	readonly base: BaseRate;
	54	readonly facts: NowFacts;
	55	readonly current: readonly EstimateRow[];
	56	readonly scorecard: string;
	57	readonly line: string \| undefined;
	58	}
	59
	60	function startedAt(app: App, issue: Issue): number \| undefined {
	61	const row = app.db
	62	.query<{ at: string \| null }, [string]>("SELECT MIN(created_at) AS at FROM run WHERE issue_id = ?1 AND kind = 'agent'")
	63	.get(issue.id);
	64	const ms = row?.at == null ? NaN : Date.parse(row.at);
	65	return Number.isFinite(ms) ? ms : undefined;
	66	}
	67
	68	/**
	69	* The base rate for this issue at `now`: one read of the history, the same answer for the same
	70	* history.
	71	*/
	72	export function baseFor(app: App, repo: Repo, issue: Issue, now: Date): BaseRate {
	73	const labels = labelsOf(app.db, [issue.id]).get(issue.id) ?? [];
	74	const started = startedAt(app, issue);
	75	const samples = historySamples(app.db, repo.id, now.getTime() - 90 * 86_400_000, now.getTime());
	76	return baseRate(
	77	samples,
	78	{ size: sizeOf(issue), kind: kindOf(labels), builder: issue.assigneeName ?? null, elapsedMs: started === undefined ? 0 : Math.max(0, now.getTime() - started) },
	79	`${repo.ownerName}/${repo.name}`,
	80	now.getTime(),
	81	);
	82	}
	83
	84	function factsOf(app: App, repo: Repo, issue: Issue, now: Date): NowFacts {
	85	const rows = nextUp(app.db, repo).rows;
	86	const at = rows.findIndex((r) => r.issue.id === issue.id);
	87	const [, day, month] = budgetLines(app.db, now);
	88	const own = forgeSource(app.db, app.config.forgeRepo);
	89	const forge = own !== undefined && own.toLowerCase() === `${repo.ownerName}/${repo.name}`.toLowerCase();
	90	return {
	91	queuePosition: at < 0 ? null : at + 1,
	92	listed: rows.length,
	93	buildersBusy: listActiveRuns(app.db, [repo.id]).length,
	94	budgetLeftUsd: {
	95	day: Math.max(0, Math.round((day!.limitUsd - (day!.spentUsd ?? 0)) * 100) / 100),
	96	month: Math.max(0, Math.round((month!.limitUsd - (month!.spentUsd ?? 0)) * 100) / 100),
	97	},
	98	releasesHeld: forge ? blocking(standingHolds(app.db)) ?? null : null,
	99	};
	100	}
	101
	102	/**
	103	* The issue as the act sees it: an issue, not a pull. Whether it is open is `recordEstimate`'s
	104	* say; asking is for any issue the caller may see.
	105	*/
	106	export function estimateIssue(app: App, repo: Repo, number: number): Issue \| undefined {
	107	const issue = Number.isInteger(number) && number > 0 ? getIssue(app.db, repo.id, number) : undefined;
	108	return issue !== undefined && issue.kind === "issue" ? issue : undefined;
	109	}
	110
	111	/** Ask: the base rate for this issue and what is true now, with the asker's own scorecard. */
	112	export function askEstimate(app: App, actor: User \| undefined, repo: Repo, issue: Issue, now: Date = new Date()): Asked {
	113	const rows = estimatesOf(app.db, issue.id);
	114	const labels = labelsOf(app.db, [issue.id]).get(issue.id) ?? [];
	115	return {
	116	repo: `${repo.ownerName}/${repo.name}`,
	117	number: issue.number,
	118	size: sizeOf(issue),
	119	kind: kindOf(labels),
	120	now: now.toISOString(),
	121	base: baseFor(app, repo, issue, now),
	122	facts: factsOf(app, repo, issue, now),
	123	current: currentOf(rows),
	124	scorecard: actor === undefined ? "" : lastLine(estimatesVisibleTo(app.db, actor, actor.id), actor.username, true),
	125	line: estimateLine(currentOf(rows), now.getTime()),
	126	};
	127	}
	128
	129	export interface EstimateInput {
	130	readonly event?: unknown;
	131	readonly p50?: unknown;
	132	readonly p90?: unknown;
	133	readonly basis?: unknown;
	134	}
	135
	136	const instant = (v: unknown): number \| undefined => {
	137	if (typeof v !== "string" \|\| !INSTANT.test(v)) return undefined;
	138	const ms = Date.parse(v);
	139	return Number.isFinite(ms) ? ms : undefined;
	140	};
	141
	142	/**
	143	* Record: validated, stamped with who and when, and the base rate shown at that moment. A new one
	144	* supersedes; the old rows stay.
	145	*/
	146	export function recordEstimate(
	147	app: App,
	148	actor: User,
	149	repo: Repo,
	150	issue: Issue,
	151	input: EstimateInput,
	152	now: Date = new Date(),
	153	): Result<{ estimate: EstimateRow; base: BaseRate; scorecard: string }, EstimateError> {
	154	const invalid = (message: string) => err<EstimateError>({ kind: "invalid", message });
	155	if (!canWrite(app.db, repo, actor)) return err({ kind: "forbidden", message: ESTIMATE_FORBIDDEN });
	156	if (issue.state !== "open") return invalid(ESTIMATE_NOT_OPEN);
	157	if (!isEvent(input.event)) return invalid(ESTIMATE_SHAPE);
	158	const event: EstimateEvent = input.event;
	159	const p50 = instant(input.p50);
	160	const p90 = instant(input.p90);
	161	if (p50 === undefined \|\| p90 === undefined) return invalid(ESTIMATE_SHAPE);
	162	if (p50 <= now.getTime() \|\| p90 <= now.getTime()) return invalid("Both times are in the future: " + ESTIMATE_SHAPE);
	163	if (p50 > p90) return invalid("p50 is no later than p90.");
	164	const basis = input.basis === undefined ? "" : input.basis;
	165	// eslint-disable-next-line no-control-regex
	166	if (typeof basis !== "string" \|\| basis.length > BASIS_MAX \|\| /[\u0000-\u001f\u007f]/.test(basis)) return invalid(ESTIMATE_SHAPE);
	167	const happened =
	168	event === "pull_opened"
	169	? openPullsClosing(app.db, repo.id).has(issue.number) \|\| mergedPullClosing(app.db, repo.id, issue.number) !== undefined
	170	: event === "merged"
	171	? mergedPullClosing(app.db, repo.id, issue.number) !== undefined
	172	: false;
	173	if (happened) return invalid(ESTIMATE_PASSED);
	174	const base = baseFor(app, repo, issue, now);
	175	const labels = labelsOf(app.db, [issue.id]).get(issue.id) ?? [];
	176	const id = addEstimate(app.db, {
	177	repoId: repo.id,
	178	issueId: issue.id,
	179	event,
	180	p50At: new Date(p50).toISOString(),
	181	p90At: new Date(p90).toISOString(),
	182	madeAt: now.toISOString(),
	183	byId: actor.id,
	184	byKind: actor.kind === "agent" ? "agent" : "person",
	185	basis: basis.trim(),
	186	baseJson: JSON.stringify(base),
	187	size: sizeOf(issue),
	188	kind: kindOf(labels),
	189	});
	190	app.bus.append({
	191	kind: "issue.estimated",
	192	repoId: repo.id,
	193	actorId: actor.id,
	194	payload: { number: issue.number, event, estimate: id },
	195	});
	196	const estimate = estimatesOf(app.db, issue.id).find((e) => e.id === id)!;
	197	return ok({ estimate, base, scorecard: lastLine(estimatesVisibleTo(app.db, actor, actor.id), actor.username, true) });
	198	}
		@@ -0,0 +1,75 @@
	1	/**
	2	* Where an estimate is settled (#11955), the one place: the forge hears of the event on the bus and
	3	* the actual instant is set, or what an abandoned issue promised is voided. Nothing else in the
	4	* core, the pulls or the keeper knows estimates exist. Only reads and writes `issue_estimate`,
	5	* `core/estimates.ts` does the rows.
	6	*
	7	* - `pull.opened`: the issues the pull's description closes had a pull opened (its creation time).
	8	* - `pull.merged`: the same issues merged (the pull's merge time).
	9	* - `release.verified_live`: each open `live` estimate resolves at the first release, cut after
	10	* its merge, that served.
	11	* - `issue.closed` as dropped or split: what it left open is void. (Moving to Not now voids in
	12	* `actions/next.ts`, the act that does it.)
	13	*/
	14	import type { Database } from "bun:sqlite";
	15	import { settleEvent, settleLive, voidOpen, type ServedRelease } from "../core/estimates.ts";
	16	import type { ForgeEvent } from "../core/events.ts";
	17	import { getIssue } from "../core/issues.ts";
	18	import { closesFromBody, mergedPullClosing } from "../core/pulls.ts";
	19
	20	/** The most releases one settling reads: the newest that served. */
	21	const RELEASES_MAX = 200;
	22
	23	const numberOf = (e: ForgeEvent): number \| undefined => {
	24	const n = e.payload["number"];
	25	return typeof n === "number" && Number.isInteger(n) ? n : undefined;
	26	};
	27
	28	/** The pull's description and its two instants. */
	29	function pullFacts(db: Database, repoId: string, number: number): { body: string; openedAt: string; mergedAt: string \| null } \| undefined {
	30	const row = db
	31	.query<{ body: string; created_at: string; merged_at: string \| null }, [string, number]>(
	32	`SELECT i.body, i.created_at, p.merged_at FROM issue i JOIN pull p ON p.issue_id = i.id WHERE i.repo_id = ?1 AND i.number = ?2`,
	33	)
	34	.get(repoId, number);
	35	return row === null ? undefined : { body: row.body, openedAt: row.created_at, mergedAt: row.merged_at };
	36	}
	37
	38	/** Releases that served and were not rolled back, oldest first. */
	39	function servedReleases(db: Database): ServedRelease[] {
	40	return db
	41	.query<{ cut_at: string; live_at: string }, [number]>(
	42	`SELECT cut_at, live_at FROM keeper_release WHERE live_at IS NOT NULL AND stage != 'rolled_back' ORDER BY cut_at DESC LIMIT ?1`,
	43	)
	44	.all(RELEASES_MAX)
	45	.reverse()
	46	.map((r) => ({ cutAt: r.cut_at, liveAt: r.live_at }));
	47	}
	48
	49	/** Settle what this event settles. Subscribed once, in `app.ts`. */
	50	export function settleEstimates(db: Database, e: ForgeEvent): void {
	51	if (e.repoId === null) return;
	52	const number = numberOf(e);
	53	switch (e.kind) {
	54	case "pull.opened": {
	55	const pull = number === undefined ? undefined : pullFacts(db, e.repoId, number);
	56	if (pull !== undefined) settleEvent(db, e.repoId, closesFromBody(pull.body), "pull_opened", pull.openedAt);
	57	return;
	58	}
	59	case "pull.merged": {
	60	const pull = number === undefined ? undefined : pullFacts(db, e.repoId, number);
	61	if (pull !== undefined) settleEvent(db, e.repoId, closesFromBody(pull.body), "merged", pull.mergedAt ?? e.createdAt);
	62	return;
	63	}
	64	case "issue.closed": {
	65	const reason = e.payload["reason"];
	66	const issue = number === undefined ? undefined : getIssue(db, e.repoId, number);
	67	if (issue !== undefined && (reason === "dropped" \|\| reason === "split")) voidOpen(db, issue.id, e.createdAt);
	68	return;
	69	}
	70	case "release.verified_live":
	71	settleLive(db, servedReleases(db), (repoId, n) => mergedPullClosing(db, repoId, n)?.mergedAt ?? undefined);
	72	return;
	73	}
	74	}
	75
		@@ -6,6 +6,7 @@
6	6	*/
7	7	import type { App } from "../app.ts";
8	8	import { addDependency, repoGraph } from "../core/dependencies.ts";
	9	import { voidOpen } from "../core/estimates.ts";
9	10	import { getIssue, type Issue } from "../core/issues.ts";
10	11	import { isStructural, pillarsOf } from "../core/pillars.ts";
11	12	import { clearRank, lift, MAX_RANKED, ranksInRepo, writeOrder } from "../core/rank.ts";
		@@ -79,6 +80,8 @@ export function rankIssue(
79	80	const linked = addDependency(app.db, issue, set.gate!, actor.id);
80	81	if (!linked.ok) return invalid(NEXT_INVALID);
81	82	clearRank(app.db, issue.id);
	83	// Not now: what it promised is void, not scored (#11955).
	84	voidOpen(app.db, issue.id);
82	85	return ok(undefined);
83	86	}
84	87	lift(app.db, repo, issue.id);
		@@ -4,6 +4,7 @@
4	4	* side-effect-contained, so tests boot real forges by the dozen.
5	5	*/
6	6
	7	import { settleEstimates } from "./actions/estimates_settle.ts";
7	8	import { ownHost, setOwnHost } from "./core/trusted_sources.ts";
8	9	import { commitIdentity } from "./core/commit_identity.ts";
9	10	import { getUserById } from "./core/users.ts";
		@@ -258,6 +259,9 @@ export function createApp(config: ForgeConfig): App {
258	259	// sends them. Listener throws are swallowed by the bus, so this can never
259	260	// break the action that produced the event.
260	261	bus.subscribe((event) => enqueueForEvent(db, event));
	262	// A pull opened or merged, a release served, an issue dropped or split:
	263	// estimates settle (#11955).
	264	bus.subscribe((event) => settleEstimates(db, event));
261	265	// A push, a merge, a repository change or a build event may move pins: the kept listings go (`git/pins_kept.ts`).
262	266	bus.subscribe((event) => {
263	267	const k = event.kind;
		@@ -0,0 +1,9 @@
	1	import { REPO, type Route } from "../shared.ts";
	2
	3	export const route: Route = {
	4	method: "get",
	5	path: `${REPO}/issues/{number}/estimates`,
	6	summary: "Read an issue's base rate from the forge's history (p50/p90 per event), the estimates recorded against it and the caller's scorecard",
	7	auth: true,
	8	role: "member",
	9	};
		@@ -159,6 +159,7 @@ export { route as getApiV1ReposOwnerNameIssues } from "./getApiV1ReposOwnerNameI
159	159	export { route as getApiV1ReposOwnerNameIssuesNumber } from "./getApiV1ReposOwnerNameIssuesNumber.ts";
160	160	export { route as getApiV1ReposOwnerNameIssuesNumberComments } from "./getApiV1ReposOwnerNameIssuesNumberComments.ts";
161	161	export { route as getApiV1ReposOwnerNameIssuesNumberDependencies } from "./getApiV1ReposOwnerNameIssuesNumberDependencies.ts";
	162	export { route as getApiV1ReposOwnerNameIssuesNumberEstimates } from "./getApiV1ReposOwnerNameIssuesNumberEstimates.ts";
162	163	export { route as getApiV1ReposOwnerNameIssuesNumberPlan } from "./getApiV1ReposOwnerNameIssuesNumberPlan.ts";
163	164	export { route as getApiV1ReposOwnerNameIssuesNumberTeams } from "./getApiV1ReposOwnerNameIssuesNumberTeams.ts";
164	165	export { route as getApiV1ReposOwnerNameIterations } from "./getApiV1ReposOwnerNameIterations.ts";
		@@ -346,6 +347,7 @@ export { route as postApiV1ReposOwnerNameIssues } from "./postApiV1ReposOwnerNam
346	347	export { route as postApiV1ReposOwnerNameIssuesNumberComments } from "./postApiV1ReposOwnerNameIssuesNumberComments.ts";
347	348	export { route as postApiV1ReposOwnerNameIssuesNumberDependencies } from "./postApiV1ReposOwnerNameIssuesNumberDependencies.ts";
348	349	export { route as postApiV1ReposOwnerNameIssuesNumberDependenciesBlockerConfirm } from "./postApiV1ReposOwnerNameIssuesNumberDependenciesBlockerConfirm.ts";
	350	export { route as postApiV1ReposOwnerNameIssuesNumberEstimates } from "./postApiV1ReposOwnerNameIssuesNumberEstimates.ts";
349	351	export { route as postApiV1ReposOwnerNameIssuesNumberPrivate } from "./postApiV1ReposOwnerNameIssuesNumberPrivate.ts";
350	352	export { route as postApiV1ReposOwnerNameJobsIdAction } from "./postApiV1ReposOwnerNameJobsIdAction.ts";
351	353	export { route as postApiV1ReposOwnerNameLabels } from "./postApiV1ReposOwnerNameLabels.ts";
		@@ -0,0 +1,10 @@
	1	import { REPO, type Route } from "../shared.ts";
	2
	3	export const route: Route = {
	4	method: "post",
	5	path: `${REPO}/issues/{number}/estimates`,
	6	summary: "Record an estimate against an issue: event (pull_opened, merged, live), p50 and p90 instants, a one-line basis; the forge resolves and scores it",
	7	auth: true,
	8	role: "member",
	9	body: { event: "string", p50: "string", p90: "string", basis: "string" },
	10	};