@coreplane/switchboard 1.251.0 → 1.253.0

package/dist/assets/src/core/coordinator/driver.ts

@@ -33,7 +33,8 @@
 // plan's re-issue. A task string's ship branch waits for a person. Node-free:
 // the shim Worker imports this by relative path.
 
-import { DEFAULT_GRANT, GRANT_RENEWALS_MAX, type Grant, type GrantSource } from "../budgets.js";
+import { DEFAULT_GRANT, GRANT_RENEWALS_MAX, IDLE_DAYS_MAX, type Grant, type GrantSource } from "../budgets.js";
+import { DEFAULT_VERBOSITY, isVerbosity, type Verbosity } from "../verbosity.js";
 import {
   applyReturn,
   cursorFinished,
@@ -41,6 +42,8 @@ import {
   openPlanCursor,
   openUnitPipeline,
   readyUnits,
+  type PlanCursor,
+  type UnitStatus,
   renderUnitReport,
   settleUnit,
   startUnit,
@@ -52,6 +55,7 @@ import {
   type AddressSeveritySource,
   type PlanGraph,
   type PlanUnitNode,
+  type RoundChecks,
   type ShipCaps,
   type StepReturn,
   type UnitEnding,
@@ -59,7 +63,14 @@ import {
   stepPrefixOf,
   type UnitSession,
 } from "../ship/coordinator.js";
-import { checksSettledEventType, isCoordinatorUnit, runFinishedEventType, type CoordinatorUnit } from "./contract.js";
+import {
+  checksSettledEventType,
+  childInterruptedEventType,
+  childResumedEventType,
+  isCoordinatorUnit,
+  runFinishedEventType,
+  type CoordinatorUnit,
+} from "./contract.js";
 
 const MIN = 60_000;
 
@@ -83,7 +94,17 @@ export interface StepRunner {
 }
 
 export type CoordinatorStepRoute =
-  "plan" | "unit-start" | "branch" | "spawn" | "read-record" | "pr-check" | "round" | "unit-end" | "merge" | "finish";
+  | "plan"
+  | "unit-start"
+  | "branch"
+  | "spawn"
+  | "read-record"
+  | "pr-check"
+  | "round"
+  | "unit-end"
+  | "checks"
+  | "merge"
+  | "finish";
 
 /** What a step stores: the bot's reply as the wire carried it — its status and
  *  its text, read the same way on replay. Two numbers and a string, so the
@@ -144,8 +165,18 @@ export function readBotAnswer(
 }
 
 /** The answers the bot itself calls a passing condition — the step is asked
- *  again, under the policy. Everything else, refusals included, is the machine's. */
-const TRANSIENT = new Set(["github_unavailable", "no_channel", "thread_failed", "unit_not_started", "not_host"]);
+ *  again, under the policy. Everything else, refusals included, is the machine's.
+ *  `queued` is the plane's hold on a spawn (record 0064, "The queue"): a `409`
+ *  saying the child's admission waits on an event — the step re-asks until the
+ *  child is admitted, and the instance is never failed over a full plane. */
+const TRANSIENT = new Set([
+  "github_unavailable",
+  "no_channel",
+  "thread_failed",
+  "unit_not_started",
+  "not_host",
+  "queued",
+]);
 export function transientRefusal(answer: BotAnswer): string | undefined {
   const { ok, error, message } = answer.body;
   if (ok !== false || typeof error !== "string" || !TRANSIENT.has(error)) return undefined;
@@ -170,6 +201,10 @@ interface PlanFacts {
   /** The grant beside them (decision 0046): what a renewal could spend, and which layer granted it. */
   grant: Grant;
   grantSource: GrantSource;
+  /** The request's verbosity as the plan route answers it (routing-and-config item 28): what the unit threads hear. */
+  verbosity: Verbosity;
+  /** The idle flag beside the grant (record 0051): above zero, an idling ending becomes `idle`. */
+  idleDays: number;
   /** The instance's mark as the plan route answers it: a generated one-unit plan (a `plan` with no `path`). */
   generated: boolean;
   /** The runs page base the bot answered: the report links a child's write-up to its run page with it. */
@@ -199,6 +234,12 @@ function readGrant(raw: unknown): Grant {
   return { renewals: raw.renewals, ...(typeof cap === "number" && cap > 0 ? { costCapUsd: cap } : {}) };
 }
 
+/** The idle flag as the plan route answers it (record 0051): an integer from 0
+ *  to the module's cap; anything unreadable is 0 — nothing idles on a guess. */
+function readIdleDays(raw: unknown): number {
+  return typeof raw === "number" && Number.isInteger(raw) && raw >= 0 && raw <= IDLE_DAYS_MAX ? raw : 0;
+}
+
 function readPlan(a: BotAnswer): PlanFacts {
   const b = a.body;
   if (b.ok !== true) throw new UnreadableAnswer("plan", a, "not ok");
@@ -218,6 +259,8 @@ function readPlan(a: BotAnswer): PlanFacts {
     grant: readGrant(b.grant),
     grantSource:
       b.grantSource === "run" || b.grantSource === "user" || b.grantSource === "channel" ? b.grantSource : "org",
+    verbosity: isVerbosity(b.verbosity) ? b.verbosity : DEFAULT_VERBOSITY,
+    idleDays: readIdleDays(b.idleDays),
     generated: b.generated === true,
     ...(typeof b.runPageBase === "string" && b.runPageBase.length > 0 ? { runPageBase: b.runPageBase } : {}),
     repo: b.repo,
@@ -349,6 +392,12 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
         ...(typeof headSha === "string" ? { headSha } : {}),
         ...(typeof a.body.autoMergeEnabled === "boolean" ? { autoMergeEnabled: a.body.autoMergeEnabled } : {}),
         ...(isCommitChecks(a.body.checks) ? { checks: a.body.checks } : {}),
+        // The ready-state facts beside the checks (agent-ship item 9): the
+        // pull request's mergeable state and its self-declared fix-up commits.
+        ...(typeof a.body.mergeableState === "string" ? { mergeableState: a.body.mergeableState } : {}),
+        ...(Array.isArray(a.body.fixupCommits) && a.body.fixupCommits.every((s: unknown) => typeof s === "string")
+          ? { fixupCommits: a.body.fixupCommits as string[] }
+          : {}),
       },
       at,
     };
@@ -366,6 +415,31 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
   throw new UnreadableAnswer("pr-check", a, "state");
 }
 
+/** The round's checks read as the bot answered it (record 0055): the runs at
+ *  the reviewed head, or none when GitHub could not be read — the machine
+ *  treats an absent read as pending and asks again at the chunk's end. A retry
+ *  ask's answer carries `retried` instead: whether the re-run was dispatched,
+ *  so the machine never waits on a head an undispatched re-run left unchanged. */
+function checksReturn(step: string, a: BotAnswer): StepReturn {
+  const { ok, checks, retried, at } = a.body;
+  if (ok !== true) throw new UnreadableAnswer("checks", a, "ok");
+  return {
+    type: "checks",
+    step,
+    ...(isRoundChecks(checks) ? { checks } : {}),
+    ...(typeof retried === "boolean" ? { retried } : {}),
+    at,
+  };
+}
+
+const isRoundChecks = (v: unknown): v is RoundChecks =>
+  isRecord(v) &&
+  typeof v.total === "number" &&
+  Array.isArray(v.pending) &&
+  v.pending.every((n: unknown) => typeof n === "string") &&
+  Array.isArray(v.failed) &&
+  v.failed.every((f: unknown) => isRecord(f) && typeof f.name === "string" && typeof f.conclusion === "string");
+
 function mergeReturn(step: string, a: BotAnswer): StepReturn {
   const { ok, outcome, by, sha, mergedAt, reason, at } = a.body;
   // The door found the pull request already merged after the approval: the
@@ -403,17 +477,58 @@ function answerOf(route: CoordinatorStepRoute, reply: BotReply): BotAnswer {
   return read.answer;
 }
 
-/** A wait's outcome: the event, or anything else — the machine confirms either by `read-record`. */
+/** A wait's outcome: the event, or anything else — the machine confirms either by `read-record`.
+ *
+ *  Three waits under one chunk (run-history item 47a): the child's finish
+ *  (`run-finished-<runId>`), its deploy-roll interruption
+ *  (`child-interrupted-<runId>`, the reattach path's word that the child
+ *  closed `interrupted` — settled as the finish is, so the round ends at once
+ *  with the child's own reason once `read-record` confirms it) and its resume
+ *  (`child-resumed-<runId>`, the same run carrying on after a roll — consumed
+ *  and re-armed, never a settlement: a resumed child keeps the wait). The
+ *  chunk times out only once the finish AND the interruption waits both have;
+ *  a resumed wait's own timeout decides nothing. */
 async function waitForRun(
   step: StepRunner,
   action: Extract<CoordinatorAction, { type: "wait" }>,
 ): Promise<"event" | "timeout"> {
-  try {
-    await step.waitForEvent(action.step, { type: runFinishedEventType(action.runId), timeout: action.timeoutMs });
-    return "event";
-  } catch {
-    return "timeout";
-  }
+  return await new Promise((resolve) => {
+    let settled = false;
+    let timeouts = 0;
+    const settle = (outcome: "event" | "timeout") => {
+      settled = true;
+      resolve(outcome);
+    };
+    const settling = (name: string, type: string) =>
+      step.waitForEvent(name, { type, timeout: action.timeoutMs }).then(
+        () => settle("event"),
+        () => {
+          timeouts += 1;
+          // Deferred a microtask so a resume that lands with the chunk's own
+          // end is still consumed (re-armed) before the timeout settles.
+          if (timeouts === 2) queueMicrotask(() => settle("timeout"));
+        },
+      );
+    void settling(action.step, runFinishedEventType(action.runId));
+    void settling(`${action.step}/interrupted`, childInterruptedEventType(action.runId));
+    // Each resumed event re-arms under the next durable name, so a second roll
+    // in the same chunk is still heard; a timeout here ends nothing, and a
+    // settled wait arms no further step.
+    const armResumed = (n: number): void => {
+      void step
+        .waitForEvent(n === 1 ? `${action.step}/resumed` : `${action.step}/resumed/${n}`, {
+          type: childResumedEventType(action.runId),
+          timeout: action.timeoutMs,
+        })
+        .then(
+          () => {
+            if (!settled) armResumed(n + 1);
+          },
+          () => {},
+        );
+    };
+    armResumed(1);
+  });
 }
 
 async function perform(
@@ -494,6 +609,24 @@ async function perform(
       }
       return { type: "wait-checks", step: action.step, outcome };
     }
+    case "checks":
+      // The round's checks step (record 0055): the bot reads the check runs at
+      // the reviewed head with the merge door's own reading — or, on a retry
+      // ask, re-runs the named failed checks' jobs first.
+      return checksReturn(
+        action.step,
+        answerOf(
+          "checks",
+          await step.do(action.step, STEP_CONFIG, () =>
+            call(bot, "checks", {
+              ...tag,
+              prNumber: action.prNumber,
+              headSha: action.headSha,
+              ...(action.retry !== undefined ? { retry: action.retry } : {}),
+            }),
+          ),
+        ),
+      );
     case "merge":
       return mergeReturn(
         action.step,
@@ -549,6 +682,8 @@ async function runUnit(
       addressSeveritySource: plan.addressSeveritySource,
       grant: plan.grant,
       grantSource: plan.grantSource,
+      verbosity: plan.verbosity,
+      idleDays: plan.idleDays,
       generated: plan.generated,
       ...(plan.runPageBase !== undefined ? { runPageBase: plan.runPageBase } : {}),
       ...(resume !== undefined ? { resume } : {}),
@@ -600,6 +735,11 @@ async function runUnit(
                 // The checks at the approved head (record 0055): the report's
                 // headline is a claim about them, never "merge-ready" over a red one.
                 ...(check.pr.checks !== undefined ? { checks: check.pr.checks } : {}),
+                // The ready state beside them (agent-ship item 9): a conflicting
+                // head, or one carrying an unsquashed fix-up commit, is reported
+                // approved-but-not-merge-ready, never "merge-ready".
+                ...(check.pr.mergeableState !== undefined ? { mergeableState: check.pr.mergeableState } : {}),
+                ...(check.pr.fixupCommits !== undefined ? { fixupCommits: check.pr.fixupCommits } : {}),
               };
           } catch {
             // the report simply omits the fact
@@ -610,13 +750,34 @@ async function runUnit(
         // ending (agent-ship item 14).
         const body = {
           ...tag,
-          ending: { kind: note.ending.kind, report: renderUnitReport(state, endFacts) },
+          // Two copies (routing-and-config item 28): the full report for the
+          // row and the board, and the thread's at the request's verbosity.
+          ending: {
+            kind: note.ending.kind,
+            report: renderUnitReport(state, endFacts),
+            threadReport: renderUnitReport(state, endFacts, state.input.verbosity ?? DEFAULT_VERBOSITY),
+            // An idle ending carries its continuation facts (record 0051): the
+            // bot writes them on the row's `idle` in place of an ending, with
+            // the coding run id it already receives below.
+            ...(note.ending.kind === "idle"
+              ? {
+                  why: note.ending.why,
+                  renewalsLeft: note.ending.renewalsLeft,
+                  ...(note.ending.from !== undefined ? { from: note.ending.from } : {}),
+                  spendUsd: note.ending.spendUsd,
+                  ...(note.ending.handoff !== undefined ? { handoff: note.ending.handoff } : {}),
+                }
+              : {}),
+          },
           ...(state.pr !== undefined ? { pr: state.pr } : {}),
           // A review_pending ending names the child's own last push so the next
-          // attempt's pre-check can start at the review round (the row's lastPush).
+          // attempt's pre-check can start at the review round (the row's lastPush)
+          // — an idled one the same, off the idle's `from` (record 0051).
           ...(note.ending.kind === "review_pending" && note.ending.headSha !== undefined
             ? { headSha: note.ending.headSha }
-            : {}),
+            : note.ending.kind === "idle" && note.ending.why === "review_pending" && note.ending.from !== undefined
+              ? { headSha: note.ending.from }
+              : {}),
           ...(state.lastCodingRunId !== undefined ? { codingRunId: state.lastCodingRunId } : {}),
           // A continued ending is a segment's end, not the unit's: the bot
           // writes the renewal as a row keyed by the next segment's index
@@ -644,12 +805,9 @@ function blockedReport(unit: string, dep: string, depEnding: string): string {
   return `⛔ Blocked: ${unit} waits on ${dep}, which ended ${depEnding}${person ? " — a person's merge" : ""}. Re-issue the plan naming the remaining units once it is ${person ? "merged" : "resolved"}.`;
 }
 
-/** The plan: its units one at a time in dependency order, then the endings of the units it never reached. */
-async function walk(step: StepRunner, bot: CoordinatorBot, instanceId: string): Promise<PlanRunSummary> {
-  const plan = readPlan(
-    answerOf("plan", await step.do("plan", STEP_CONFIG, () => call(bot, "plan", { parentInstanceId: instanceId }))),
-  );
-  const graph: PlanGraph = {
+/** The graph as one plan answer carries it: the instance's unit rows, in the plan's order. */
+function graphOf(plan: PlanFacts, instanceId: string): PlanGraph {
+  return {
     planId: plan.planId ?? instanceId,
     units: plan.units.map((u) => ({
       id: u.unit,
@@ -659,6 +817,54 @@ async function walk(step: StepRunner, bot: CoordinatorBot, instanceId: string):
       dependsOn: u.dependsOn,
     })),
   };
+}
+
+/** The cursor over a freshly read selection (the orchestration-plane plan's
+ *  re-read requirement): a surviving unit keeps its standing, a row appended
+ *  mid-walk joins pending — walked after the current unit — and a row gone from the selection
+ *  was merged by hand: it is walked as merged with nothing run and nothing
+ *  told (`gone`), a dependency on it counted satisfied like any dependency
+ *  outside the selection. `blocked` is derived state, so it is recomputed over
+ *  the fresh graph rather than carried — a blocked unit whose failing
+ *  dependency left the selection is in play again. */
+function rereadCursor(cursor: PlanCursor, fresh: PlanGraph): { cursor: PlanCursor; gone: string[] } {
+  const gone = cursor.order.filter((id) => !fresh.units.some((u) => u.id === id));
+  const order = fresh.units.map((u) => u.id);
+  const status: Record<string, UnitStatus> = {};
+  for (const id of order) {
+    const prior = cursor.status[id];
+    status[id] = prior === undefined || prior === "blocked" ? "pending" : prior;
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const u of fresh.units) {
+      if (status[u.id] !== "pending") continue;
+      if (u.dependsOn.some((d) => d in status && (status[d] === "failed" || status[d] === "blocked"))) {
+        status[u.id] = "blocked";
+        changed = true;
+      }
+    }
+  }
+  return { cursor: { order, status }, gone };
+}
+
+/** The plan: its units one at a time in dependency order, then the endings of the units it never reached. */
+async function walk(step: StepRunner, bot: CoordinatorBot, instanceId: string): Promise<PlanRunSummary> {
+  // The selection is read at every unit boundary (the orchestration-plane plan): the first read opens
+  // the cursor, and each boundary's — its own durable step, `plan/<n>`, so a
+  // replay meets the same read — rebuilds it, so a later bot can append a unit
+  // to a live instance or drop one merged by hand without killing it.
+  let reads = 0;
+  const readSelection = async (): Promise<PlanFacts> => {
+    reads += 1;
+    const name = reads === 1 ? "plan" : `plan/${reads}`;
+    return readPlan(
+      answerOf("plan", await step.do(name, STEP_CONFIG, () => call(bot, "plan", { parentInstanceId: instanceId }))),
+    );
+  };
+  let plan = await readSelection();
+  let graph = graphOf(plan, instanceId);
   let cursor = openPlanCursor(graph);
   const endings: Record<string, string> = {};
   for (;;) {
@@ -685,7 +891,16 @@ async function walk(step: StepRunner, bot: CoordinatorBot, instanceId: string):
     endings[next] = ending.kind;
     // A unit is done for its dependents when the base carries its scope: the
     // runner's merge, or a scope that had already landed before the attempt.
+    // An `idle` ending settles the unit `failed` for now: nothing waits yet —
+    // the indexed wait and the wake land with the fifth unit of record 0051's
+    // plan — so the walk is unchanged until then and the flag ships at zero.
     cursor = settleUnit(graph, cursor, next, isSettledDone(ending.kind) ? "done" : "failed");
+    // The unit boundary's re-read (the orchestration-plane plan): the fresh rows are the selection now.
+    plan = await readSelection();
+    graph = graphOf(plan, instanceId);
+    const reread = rereadCursor(cursor, graph);
+    cursor = reread.cursor;
+    for (const id of reread.gone) endings[id] ??= "merged";
   }
   // Blocked units, in the plan's order: each told its own ending, so the rows
   // and the summary say why it never ran. Every blocked unit's ending is known

package/dist/assets/src/core/drain.ts

@@ -19,11 +19,61 @@
  *  (docs/reference/specs/run-history.md item 39); this is the wait for the rest. */
 export const DRAIN_DEADLINE_MS = 15 * 60_000;
 
+/** One run holding a drain: the registry-active run's id and why it holds.
+ *  The drain is held by the RUN REGISTRY's live rows, not by the dispatcher's
+ *  in-flight count — the two can disagree (a registry row whose dispatcher-side
+ *  run is gone still holds the drain for its full deadline) — so the lines an
+ *  operator reads name these rows, never the count from the other ledger. */
+export interface HeldRun {
+  id: string;
+  why: string;
+}
+
+/** Why a registry-active run holds the drain: the handoff (run-history item 39)
+ *  did not mark it for the next generation, so this process must wait for it. */
+export const HELD_NOT_HANDED_OFF = "not handed off";
+
+/** One `id (why)` per held run, comma-separated — shared by the drain's hold
+ *  line here and the deploy CLI's still-draining line (src/deploy/liveGate.ts). */
+export function heldRunsText(held: readonly HeldRun[]): string {
+  return held.map((r) => `${r.id} (${r.why})`).join(", ");
+}
+
+/** The drain's hold line (slack-channel.md item 8): what actually holds the
+ *  exit, by run id and reason — printed once the handoff has settled who stays. */
+export function drainHoldLine(held: readonly HeldRun[]): string {
+  return `[drain] holding for ${held.length} registry-active run(s): ${heldRunsText(held)}`;
+}
+
 /** The handoff's own budget (plan D8): after every resumable run is marked
  *  `handoff`, the drain waits this long for pending history writes and
  *  reflections, then exits — the next generation takes the runs. */
 export const HANDOFF_BUDGET_MS = 6_000;
 
+/**
+ * The drain's wait bound, re-read on every poll of the drain loop
+ * (`src/index.ts`). While a run still holds the drain (registry-active, not
+ * handed off) the bound is the full DRAIN_DEADLINE_MS from the signal — the
+ * deadline is the bound for a run that will not end, never the schedule. The
+ * moment the held count reaches zero the bound collapses to HANDOFF_BUDGET_MS
+ * from that instant (never past the full deadline) — the same grace a drain
+ * that started with nothing held gets — so pending reflections and history
+ * writes, including the steady stream a handed-off run still executing here
+ * produces, get seconds to settle, not the deploy's remaining minutes. Once
+ * collapsed the bound never grows back: the socket is closed, so no new run
+ * can arrive to hold the drain again.
+ */
+export function createDrainDeadline(drainStartedAt: number): (now: number, runsHeld: number) => number {
+  const full = drainStartedAt + DRAIN_DEADLINE_MS;
+  let collapsed: number | undefined;
+  return (now, runsHeld) => {
+    if (collapsed !== undefined) return collapsed;
+    if (runsHeld > 0) return full;
+    collapsed = Math.min(full, now + HANDOFF_BUDGET_MS);
+    return collapsed;
+  };
+}
+
 /** Time budgeted for the replacement container to boot and reach Socket Mode
  *  `connected` (image pull + Node start + Bolt handshake), when the catch-up
  *  scan runs. */

package/dist/assets/src/core/memory/engine.ts

@@ -59,15 +59,25 @@ export function planEviction(active: MemoryRecord[], cap: number): MemoryRecord[
     .slice(0, excess);
 }
 
-/** What a store must do for one candidate. `dedup`: bump `target.useCount`,
- *  insert nothing. `insert`: append `record` (already minted) and, when
- *  `supersede` is set, flip that record to `superseded`. */
+/** What a store must do for one candidate. `restate`: bump `target.useCount`,
+ *  set its `lastUsedAt` to the store's now and its confidence to `confidence`
+ *  when the plan carries one (the higher of the two sides), insert nothing.
+ *  `dedup`: bump `target.useCount`, insert nothing. `insert`: append `record`
+ *  (already minted) and, when `supersede` is set, flip that record to
+ *  `superseded`. */
 export type WritePlan =
-  { action: "dedup"; target: MemoryRecord } | { action: "insert"; record: MemoryRecord; supersede?: MemoryRecord };
+  | { action: "restate"; target: MemoryRecord; confidence?: number }
+  | { action: "dedup"; target: MemoryRecord }
+  | { action: "insert"; record: MemoryRecord; supersede?: MemoryRecord };
 
 /**
  * Decide how one candidate lands among a scope's ACTIVE records (docs/reference/specs/
  * memory.md §8):
+ * - **Restate target** = the active same-scope record whose id equals
+ *   `cand.restates`: the fact re-teaches a shown record, so that record is
+ *   refreshed — usage bumped, confidence the higher of the two — and nothing
+ *   is inserted, whatever the candidate's wording. A missing or non-active
+ *   target falls through to the rules below (today's dedup-or-insert).
  * - **Supersede target** = the active same-scope record whose id equals
  *   `cand.supersedes`; an unknown/foreign id resolves to nothing (the new
  *   record still lands, superseding nothing).
@@ -86,6 +96,17 @@ export function planWrite(
   cand: MemoryCandidate,
   mint: (cand: MemoryCandidate) => MemoryRecord,
 ): WritePlan {
+  if (cand.restates) {
+    const restated = active.find((r) => r.status === "active" && r.id === cand.restates);
+    if (restated) {
+      const confidences = [restated.confidence, cand.confidence].filter((c): c is number => c !== undefined);
+      return {
+        action: "restate",
+        target: restated,
+        ...(confidences.length > 0 ? { confidence: Math.max(...confidences) } : {}),
+      };
+    }
+  }
   const norm = normalizeText(cand.text);
   const target = cand.supersedes ? active.find((r) => r.status === "active" && r.id === cand.supersedes) : undefined;
   const dedupPool = cand.supersedes ? (target ? [target] : []) : active.filter((r) => r.status === "active");
@@ -94,6 +115,104 @@ export function planWrite(
   return { action: "insert", record: mint(cand), ...(target ? { supersede: target } : {}) };
 }
 
+// ---- The write gate (docs/reference/specs/memory.md item 13) -----------------
+// Status — the state of one pull request at one moment — and change
+// descriptions — what one change did, which the spec and the diff already say —
+// must never become facts: the prompt has asked for that since the write path
+// shipped, and a rule a model is asked to follow is a rule it follows on
+// average. The gate is therefore code, pure and total, and lives HERE in the
+// shared engine so the bot's write path and the Worker's sweep run the exact
+// same rule. A summary is never gated (episodic by definition).
+
+/** A delivery predicate: words that say a change LANDED — one moment's news,
+ *  never a lesson. Shared by the `delivery` marker and the reference marker's
+ *  same-clause test. The auxiliary may sit up to two words from the participle
+ *  ("is fixed and pushed"). */
+const DELIVERY_PREDICATE =
+  /\b(?:(?:was|were|is|are)\s+(?:\w+\s+){0,2}?(?:pushed|merged|approved)|all\s+green|lgtm|ready\s+for\s+review|awaits?\s+ci|is\s+complete)\b/i;
+
+/** A pull-request / issue / unit reference in subject position: the fact opens
+ *  with the noun and a number, so the reference is what the fact is ABOUT. */
+const REFERENCE_SUBJECT = /^\s*(?:pr|pull\s+request|issue|unit)s?\s*#?\d+\b/i;
+
+/** A reference elsewhere (`#n`, `pull/n`, `issues/n`) rejects only beside a
+ *  delivery predicate in the same clause — a citation inside a lesson ("the
+ *  staged rebuild (issue 170) must budget the swap") is not status. */
+const REFERENCE_IN_CLAUSE = /#\d+|\b(?:pull|issues)\/\d+/i;
+
+/** A commit sha: 7–40 hex chars with at least one digit AND one letter, bounded
+ *  by non-alphanumerics — the letter keeps a timestamp or a plain count out,
+ *  the digit keeps "defaced" and "accede" out. An all-digit or all-letter sha
+ *  is missed and accepted as the cost. */
+const COMMIT_SHA = /(?<![a-z0-9])(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,40}(?![a-z0-9])/i;
+
+/** A run id (`run` + 8 hex chars) or a branch by its path-like name. */
+const RUN_OR_BRANCH = /\brun\s+[0-9a-f]{8}\b|\bbranch\s+\S*\/\S+/i;
+
+/** `now` + a present-tense verb (one intervening word allowed): what a change
+ *  "now does" is a change description, not a lesson. */
+const NOW_VERB =
+  /\bnow\s+(?:\w+\s+)?(?:documents|preserves|displays|includes|carries|has|is|supports|shows|maps|controls|applies|uses)\b/i;
+
+/** A passive change participle: "was implemented", "has been fixed", … */
+const CHANGE_PARTICIPLE =
+  /\b(?:was|were|has\s+been|have\s+been)\s+(?:implemented|added|updated|fixed|documented|removed|renamed|introduced|extended)\b/i;
+
+/** A plan-unit reference. */
+const PLAN_UNIT = /\bunit\s+u?\d+\b/i;
+
+/** "spec row" / "spec rows": what a spec row documents is the spec's to say. */
+const SPEC_ROW = /\bspec\s+rows?\b/i;
+
+/** The words that make a nearby number a test/check count… */
+const COUNT_NOUNS = new Set(["test", "tests", "checks", "rows"]);
+/** …and the outcome words that make that count status. */
+const COUNT_OUTCOME = /\b(?:pass(?:es|ing|ed)?|green|fail(?:s|ing|ed)?)\b/i;
+
+/** A clause: the unit within which the reference and count markers look for
+ *  their second half. */
+function clausesOf(text: string): string[] {
+  return text.split(/[;.!?\n—]+/);
+}
+
+/** A number within three words of a count noun, with an outcome word in the
+ *  same clause — in either order ("all 12 tests passing", "green across 12
+ *  checks"). */
+function hasCountMarker(clause: string): boolean {
+  if (!COUNT_OUTCOME.test(clause)) return false;
+  const words = clause
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+  return words.some(
+    (w, i) => /^\d+$/.test(w) && words.slice(Math.max(0, i - 3), i + 4).some((neighbour) => COUNT_NOUNS.has(neighbour)),
+  );
+}
+
+/** The status and change-description markers a fact text carries, by name —
+ *  a table of named patterns, each firing independently. A non-empty answer
+ *  rejects the fact (`parseReflection`) and, later, sweeps the stored row; the
+ *  names are safe to log (never the text). Pure and total: never throws, and
+ *  empty text carries no markers (it is rejected upstream as empty). */
+export function rejectionMarkers(text: string): string[] {
+  const clauses = clausesOf(text);
+  const table: Array<[name: string, hit: boolean]> = [
+    [
+      "reference",
+      REFERENCE_SUBJECT.test(text) || clauses.some((c) => REFERENCE_IN_CLAUSE.test(c) && DELIVERY_PREDICATE.test(c)),
+    ],
+    ["sha", COMMIT_SHA.test(text)],
+    ["count", clauses.some(hasCountMarker)],
+    ["delivery", DELIVERY_PREDICATE.test(text)],
+    ["identifier", RUN_OR_BRANCH.test(text)],
+    ["now", NOW_VERB.test(text)],
+    ["changed", CHANGE_PARTICIPLE.test(text)],
+    ["unit", PLAN_UNIT.test(text)],
+    ["spec-row", SPEC_ROW.test(text)],
+  ];
+  return table.filter(([, hit]) => hit).map(([name]) => name);
+}
+
 /** Build the record a store persists for a candidate. Ids are namespaced per
  *  AGENTS.md invariant 4 (`mem:<scopeKey>:<seq>`); keywords default to the
  *  text's tokens so keyword retrieval always has something to hit. */

package/dist/assets/src/core/memory/scorer.ts

@@ -20,10 +20,18 @@ export const DEFAULT_WEIGHTS: ScoreWeights = { keyword: 0.7, recency: 0.3 };
  *  sweeper job (decay lives in the score). */
 export const RECENCY_TAU_MS = 7 * 24 * 60 * 60 * 1000;
 
-/** Default read budget: at most 8 records / ~800 tokens injected, regardless of
- *  store size — context never bloats. */
-export const DEFAULT_MEMORY_LIMIT = 8;
-export const DEFAULT_MEMORY_TOKENS = 800;
+/** Default read budget: at most 32 records / ~3000 tokens injected, regardless
+ *  of store size — context never bloats. Raised from 8/800 with the repository
+ *  window (docs/decisions/0061-…): the window's 24 facts plus the keyword hits
+ *  must fit in one pool under one budget. */
+export const DEFAULT_MEMORY_LIMIT = 32;
+export const DEFAULT_MEMORY_TOKENS = 3000;
+
+/** Default size of the repository window (`memory.repoWindow`): the newest
+ *  facts of the run's bound repository, rendered ahead of the keyword hits.
+ *  `0` disables the window. At ~320 chars per repository fact, 24 render in
+ *  about 2000 tokens — the rest of the budget is the hits'. */
+export const DEFAULT_REPO_WINDOW = 24;
 
 export interface MemoryBudget {
   maxRecords: number;