src/tick.ts

Functions

Imports

It imports src/auto-merge-tick.ts, src/digest.ts, src/doc-index.ts, src/env.ts, src/log.ts, src/maintenance.ts, src/merge-resume.ts, src/merge-safety.ts, src/merge-units.ts, src/outcome-prs.ts, src/public-data.ts, src/push.ts, src/task-runs.ts, src/watcher-gather.ts, src/watcher.ts. Imported by src/index.ts.

Source

1import type { Env } from "./env";
2import { autoMergeTick } from "./auto-merge-tick";
3import { mergeResumeTick } from "./merge-resume";
4import { sweepIfDue } from "./outcome-prs";
5import { runTask, type TaskResult } from "./task-runs";
6import { watcherTick } from "./watcher";
7import { gatherFindings } from "./watcher-gather";
8import { maintenanceTick } from "./maintenance";
9import { publicBuildTick } from "./public-data";
10import { docIndexTick } from "./doc-index";
11import { pushTick } from "./push";
12import { digestTick } from "./digest";
13import { unitsTick } from "./merge-units";
14import { mergeSafetyTick } from "./merge-safety";
15import { logEvent } from "./log";
16
17// The five-minute tick's steps, in order. Each is its own task in the run ledger
18// (src/task-runs.ts): runTask records a run, and records and logs a throw without
19// rethrowing it, so one step's throw does not stop the rest of the tick. A step that was
20// not due returns null from its judge and records nothing.
21export async function runTick(env: Env, now: Date): Promise<void> {
22  // Auto-merge. The policy document decides whether it does anything; it ships
23  // disabled, and a disabled policy is not a run. A policy that cannot be read or is
24  // refused is.
25  await runTask(
26    env,
27    "auto-merge",
28    () => autoMergeTick(env, now),
29    (merged): TaskResult => {
30      if (merged.ran) {
31        logEvent("log", "AUTO_MERGE", { message: `AUTO_MERGE ${merged.note}` });
32        return { outcome: "ok", reason: merged.note };
33      }
34      return merged.policy_version === null ? { outcome: "refused", reason: merged.note } : null;
35    },
36    { tag: "AUTO_MERGE_THREW:", rethrow: false }
37  );
38
39  // The watcher, on its own half-hourly stamp. It only posts jobs, so the worst a
40  // broken pass can do is add a row to the queue.
41  await runTask(
42    env,
43    "watcher",
44    () => watcherTick(env, now, () => gatherFindings(env, now)),
45    (watched): TaskResult => {
46      if (!watched.ran) return null;
47      logEvent("log", "WATCHER", { message: `WATCHER ${watched.note}` });
48      return { outcome: "ok", reason: watched.note };
49    },
50    { tag: "WATCHER_THREW:", rethrow: false }
51  );
52
53  // Merge units (src/merge-units.ts): after the watcher, which records rollbacks in
54  // deploy_outcomes. It proposes promotions and demotions and suspends a unit whose
55  // unattended merge was rolled back; the suspension only narrows, and the auto-merge
56  // step reads it on the next tick. Recorded only when something changed.
57  await runTask(
58    env,
59    "merge-units",
60    () => unitsTick(env, now),
61    (report): TaskResult => {
62      if (!report.ran) return null;
63      logEvent(report.newly_suspended.length ? "error" : "log", "MERGE_UNITS", { message: `MERGE_UNITS ${report.note}` });
64      return { outcome: "ok", reason: report.note };
65    },
66    { tag: "MERGE_UNITS_THREW:", rethrow: false }
67  );
68
69  // The auto-merge safety meter and shutoff (src/merge-safety.ts): after merge-units. Its
70  // revert pass runs at most half-hourly; the counts and the shutoff read D1 only, every
71  // tick. A namespace it pauses only narrows: the auto-merge step reads the pause on the
72  // next tick. Recorded only when something changed.
73  await runTask(
74    env,
75    "merge-safety",
76    () => mergeSafetyTick(env, now),
77    (report): TaskResult => {
78      if (!report.ran) return null;
79      logEvent(report.newly_paused.length ? "error" : "log", "MERGE_SAFETY", { message: `MERGE_SAFETY ${report.note}` });
80      return { outcome: "ok", reason: report.note };
81    },
82    { tag: "MERGE_SAFETY_THREW:", rethrow: false }
83  );
84
85  // Stale jobs: a blocked job whose named pull requests have all merged goes back to its
86  // holder with a note. It resumes and never completes; see src/merge-resume.ts. Recorded
87  // only when it resumed something, so the ledger is not one empty pass every five minutes.
88  await runTask(
89    env,
90    "merge-resume",
91    () => mergeResumeTick(env, now),
92    (report): TaskResult => {
93      // A stale:prs cache that could not be written is recorded even on a pass that
94      // resumed nothing, so the stale view's missing rows have a cause on the ledger.
95      if (report.cache_error) {
96        logEvent("error", "MERGE_RESUME_CACHE", { message: `MERGE_RESUME_CACHE ${report.note}` });
97        return { outcome: "refused", reason: report.note };
98      }
99      if (report.resumed.length === 0) return null;
100      logEvent("log", "MERGE_RESUME", { message: `MERGE_RESUME ${report.note}` });
101      return { outcome: "ok", reason: report.note };
102    },
103    { tag: "MERGE_RESUME_THREW:", rethrow: false }
104  );
105
106  // The daily maintenance pass (src/maintenance.ts): once a UTC day after 11:00, it lists
107  // what has gone stale for the seat's morning read. Its writes are pruning merged
108  // branches, off until the seat turns it on, and tagging a shared package's merged version
109  // bump (src/maintenance-releases.ts), on until the seat turns it off. Each delete and each
110  // tag is audit-logged before the next, so a broken pass costs a missing list, not an
111  // unrecorded write. Not due is not a run.
112  await runTask(
113    env,
114    "maintenance",
115    () => maintenanceTick(env, now),
116    (report): TaskResult => {
117      if (!report.ran) return null;
118      logEvent("log", "MAINTENANCE", { message: `MAINTENANCE ${report.note}` });
119      return { outcome: "ok", reason: report.note };
120    },
121    { tag: "MAINTENANCE_THREW:", rethrow: false }
122  );
123
124  // The public system model (src/public-data.ts): once a UTC day, repo visibility read
125  // from GitHub, the model filtered by toPublic and stored for /public/model/v1.json,
126  // and the public repos' code maps for /public/code/v1.json, rebuilt hourly. A
127  // failed read throws before anything is written, so the last good document stays
128  // served and the ledger shows the failure. Not due is not a run.
129  await runTask(
130    env,
131    "public-build",
132    () => publicBuildTick(env, now),
133    (report): TaskResult => {
134      if (!report.ran) return null;
135      // A code map that would not parse is a refusal the ledger shows; the model was still built.
136      const failed = "codeFailed" in report;
137      logEvent(failed ? "error" : "log", "PUBLIC_BUILD", { message: `PUBLIC_BUILD ${report.note}` });
138      return { outcome: failed ? "refused" : "ok", reason: report.note };
139    },
140    { tag: "PUBLIC_BUILD_THREW:", rethrow: false }
141  );
142
143  // The meaning index (src/doc-index.ts): documents changed since the last tick go to
144  // AI Search, and once a day stale items are removed and missing ones re-sent. A
145  // refused upload is recorded as refused; the next edit or the daily pass retries it.
146  await runTask(
147    env,
148    "doc-index",
149    () => docIndexTick(env, now),
150    (report): TaskResult => {
151      if (!report.ran) return null;
152      logEvent(report.failed > 0 ? "error" : "log", "DOC_INDEX", { message: `DOC_INDEX ${report.note}` });
153      return { outcome: report.failed > 0 ? "refused" : "ok", reason: report.note };
154    },
155    { tag: "DOC_INDEX_THREW:", rethrow: false }
156  );
157
158  // The daily merge-state sweep. Outcome rows record a pull request as unmerged when
159  // written, because the driver blocks and the seat merges afterwards. The merge path
160  // corrects the rows it can see; this catches the rest (a merge done with gh rather
161  // than capsid_close_pr action merge, and rows written before the join table existed). Bounded per
162  // sweep, so the cost is fixed however far behind it is.
163  await runTask(
164    env,
165    "outcome-sweep",
166    () => sweepIfDue(env, now),
167    (swept): TaskResult => {
168      if (!swept) return null;
169      const line = `checked ${swept.checked}, changed ${swept.changed}, seeded ${swept.seeded}, backfilled ${swept.backfilled}`;
170      logEvent("log", "OUTCOME_SWEEP", { message: `OUTCOME_SWEEP ${line}` });
171      return { outcome: "ok", reason: line };
172    },
173    { tag: "OUTCOME_SWEEP_THREW:", rethrow: false }
174  );
175
176  // Phone alerts (src/push.ts): after the auto-merge step and the watcher, so a typed
177  // pull request or a rollback they just recorded is seen this tick. It spends no model
178  // tokens. Recorded only when an alert was due, so the ledger is not one empty pass
179  // every five minutes; no key or no device is not a run.
180  await runTask(
181    env,
182    "push",
183    () => pushTick(env, now),
184    (report): TaskResult => {
185      if (!report.ran) return null;
186      logEvent("log", "PUSH", { message: `PUSH ${report.note}` });
187      return { outcome: report.sent.length > 0 ? "ok" : "refused", reason: report.note };
188    },
189    { tag: "PUSH_THREW:", rethrow: false }
190  );
191
192  // The daily email digest (src/digest.ts): once a UTC day, and only once Email Routing is
193  // on. Off or not due is not a run; a send Cloudflare refused is recorded as refused.
194  await runTask(
195    env,
196    "digest",
197    () => digestTick(env, now),
198    (report): TaskResult => {
199      if (!report.ran) return null;
200      logEvent(report.sent ? "log" : "error", "DIGEST", { message: `DIGEST ${report.note}` });
201      return { outcome: report.sent ? "ok" : "refused", reason: report.note };
202    },
203    { tag: "DIGEST_THREW:", rethrow: false }
204  );
205}