@kubitnodes/stellaris 0.3.21 → 0.3.22

package/dist/server/index.js

@@ -9,7 +9,7 @@ import { serve } from "@hono/node-server";
 import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
 import path6 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // packages/shared/dist/ids.js
 import { z } from "zod";
@@ -169,7 +169,7 @@ var SEED_ROLES = [
 ];
 
 // packages/shared/dist/board.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // packages/shared/dist/crons.js
 import { Cron as Pattern } from "croner";
@@ -303,6 +303,115 @@ function localTime(date, timeZone) {
   return `${part("weekday")} ${part("year")}-${part("month")}-${part("day")} ${part("hour")}:${part("minute")}`;
 }
 
+// packages/shared/dist/quota.js
+import { z as z4 } from "zod";
+var QUOTA_WARNING_PERCENT = 80;
+var QuotaWindowSchema = z4.object({
+  /**
+   * The CLI's own name for the window: Claude's `five_hour`, `seven_day`, `seven_day_opus`, and
+   * `model:<label>` for a model's weekly window; Codex's `primary` and `secondary`.
+   */
+  key: z4.string().min(1).max(80),
+  /** What a scoped window counts, as the CLI labels it, such as a model's name. */
+  label: z4.string().min(1).max(80).optional(),
+  /** The window's length in minutes, when known. */
+  minutes: z4.number().int().positive().nullable().default(null),
+  /** How much of the window is used, in percent, or null when the CLI did not say. */
+  usedPercent: z4.number().nonnegative().nullable().default(null),
+  /** When the window starts afresh, when known. */
+  resetsAt: IsoDateTimeSchema.nullable().default(null),
+  /** When the CLI last reported this window. */
+  observedAt: IsoDateTimeSchema
+});
+var QuotaStatusSchema = z4.enum(["allowed", "warning", "limited", "none"]);
+var QuotaCreditsSchema = z4.object({
+  hasCredits: z4.boolean(),
+  unlimited: z4.boolean(),
+  balance: z4.string().max(40).nullable()
+});
+var QuotaExtraUsageSchema = z4.object({
+  enabled: z4.boolean(),
+  monthlyLimit: z4.number().nonnegative().nullable(),
+  usedCredits: z4.number().nonnegative().nullable(),
+  currency: z4.string().min(1).max(8).nullable()
+});
+var CliQuotaSchema = z4.object({
+  /** When the CLI last reported anything here. */
+  observedAt: IsoDateTimeSchema,
+  /** Whether it came from a turn's stream or from asking the CLI. */
+  source: z4.enum(["turn", "read"]),
+  status: QuotaStatusSchema,
+  /** While `limited`: when work can go on, when known, and the window that stopped it. */
+  limitedUntil: IsoDateTimeSchema.nullable().default(null),
+  limitedBy: z4.string().min(1).max(80).nullable().default(null),
+  /** The plan's name as the CLI gives it, such as `max` or `pro`. */
+  plan: z4.string().min(1).max(40).nullable().default(null),
+  windows: z4.array(QuotaWindowSchema).max(24).default([]),
+  credits: QuotaCreditsSchema.nullable().default(null),
+  extraUsage: QuotaExtraUsageSchema.nullable().default(null)
+});
+function mergeQuota(previous, next) {
+  if (previous === void 0) {
+    return next;
+  }
+  const windows = new Map(previous.windows.map((window) => [window.key, window]));
+  for (const window of next.windows) {
+    windows.set(window.key, window);
+  }
+  return {
+    ...next,
+    plan: next.plan ?? previous.plan,
+    credits: next.credits ?? previous.credits,
+    extraUsage: next.extraUsage ?? previous.extraUsage,
+    windows: [...windows.values()]
+  };
+}
+function windowCurrent(window, now) {
+  return window.resetsAt === null || Date.parse(window.resetsAt) > now.getTime();
+}
+function quotaLevel(quota, now) {
+  if (quota.status === "none") {
+    return "none";
+  }
+  if (quota.status === "limited" && (quota.limitedUntil === null || Date.parse(quota.limitedUntil) > now.getTime())) {
+    return "limited";
+  }
+  const high = quota.windows.some((window) => windowCurrent(window, now) && window.usedPercent !== null && window.usedPercent >= QUOTA_WARNING_PERCENT);
+  return quota.status === "warning" || high ? "warning" : "ok";
+}
+var WINDOW_NAMES = {
+  five_hour: "5h",
+  seven_day: "7d",
+  seven_day_opus: "7d Opus",
+  seven_day_sonnet: "7d Sonnet",
+  seven_day_oauth_apps: "7d apps",
+  seven_day_overage_included: "7d extra",
+  overage: "extra usage"
+};
+function windowName(window) {
+  if (window.label !== void 0) {
+    return window.minutes === 10080 ? `7d ${window.label}` : window.label;
+  }
+  const named = WINDOW_NAMES[window.key];
+  if (named !== void 0) {
+    return named;
+  }
+  if (window.minutes !== null) {
+    return window.minutes % 1440 === 0 ? `${window.minutes / 1440}d` : window.minutes % 60 === 0 ? `${window.minutes / 60}h` : `${window.minutes}m`;
+  }
+  return window.key;
+}
+function readings(quota) {
+  const windows = quota.windows.map((window) => `${window.key}=${window.usedPercent === null ? "?" : Math.round(window.usedPercent)}@${window.resetsAt === null ? "?" : Math.round(Date.parse(window.resetsAt) / 6e4)}`).toSorted();
+  return windows.join(",");
+}
+function quotaChanged(previous, next) {
+  if (previous === void 0) {
+    return true;
+  }
+  return previous.status !== next.status || previous.limitedUntil !== next.limitedUntil || previous.plan !== next.plan || previous.credits?.balance !== next.credits?.balance || previous.extraUsage?.usedCredits !== next.extraUsage?.usedCredits || readings(previous) !== readings(next);
+}
+
 // packages/shared/dist/board.js
 var ASK_CHANNEL = "asks";
 var SOCIETY_CHANNELS = ["general", "governance", ASK_CHANNEL];
@@ -315,24 +424,24 @@ var SOCIETY_SCOPE = "society";
 function wakeScope(member, project) {
   return project !== null && member.memberships.includes(project) ? project : SOCIETY_SCOPE;
 }
-var CliKindSchema = z4.enum(["claude", "codex"]);
-var ArchivedChannelSchema = z4.object({
+var CliKindSchema = z5.enum(["claude", "codex"]);
+var ArchivedChannelSchema = z5.object({
   name: NameSchema,
   at: IsoDateTimeSchema,
   by: NameSchema,
-  reason: z4.string().min(1)
+  reason: z5.string().min(1)
 });
-var SocietySchema = z4.object({
-  name: z4.string().min(1),
-  version: z4.literal(1),
+var SocietySchema = z5.object({
+  name: z5.string().min(1),
+  version: z5.literal(1),
   createdAt: IsoDateTimeSchema,
   /** The channels that take posts; an archived one moves to `archivedChannels`. */
-  channels: z4.array(NameSchema),
-  archivedChannels: z4.array(ArchivedChannelSchema).default([]),
+  channels: z5.array(NameSchema),
+  archivedChannels: z5.array(ArchivedChannelSchema).default([]),
   /** The time zone crons are read in when they name none, and every prompt tells the time in; the user's to set. */
   timezone: TimeZoneSchema.default(DEFAULT_TIME_ZONE)
 });
-var CompletionEffectSchema = z4.enum(["none", "merge", "ghpr"]);
+var CompletionEffectSchema = z5.enum(["none", "merge", "ghpr"]);
 var GITHUB_REMOTE = [
   /^https:\/\/github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/,
   /^git@github\.com:([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?$/,
@@ -348,7 +457,7 @@ function githubRepository(remote) {
   return null;
 }
 var PULL_REQUEST_URL = /^https:\/\/github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+)\/pull\/([1-9]\d*)\/?$/;
-var PullRequestUrlSchema = z4.string().trim().regex(PULL_REQUEST_URL, "a pull request's address, https://github.com/<owner>/<repo>/pull/<number>");
+var PullRequestUrlSchema = z5.string().trim().regex(PULL_REQUEST_URL, "a pull request's address, https://github.com/<owner>/<repo>/pull/<number>");
 function parsePullRequestUrl(url) {
   const match = PULL_REQUEST_URL.exec(url.trim());
   return match?.[1] === void 0 || match[2] === void 0 || match[3] === void 0 ? null : { owner: match[1], name: match[2], number: Number(match[3]) };
@@ -356,72 +465,72 @@ function parsePullRequestUrl(url) {
 function sameRepository(a, b) {
   return a.owner.toLowerCase() === b.owner.toLowerCase() && a.name.toLowerCase() === b.name.toLowerCase();
 }
-var MergeSubjectSchema = z4.string().trim().min(1).max(300).regex(/^[^\n]+$/, "a merge commit's subject is one line");
-var PullRequestLinkSchema = z4.object({
+var MergeSubjectSchema = z5.string().trim().min(1).max(300).regex(/^[^\n]+$/, "a merge commit's subject is one line");
+var PullRequestLinkSchema = z5.object({
   url: PullRequestUrlSchema,
-  number: z4.number().int().positive(),
+  number: z5.number().int().positive(),
   subject: MergeSubjectSchema.optional(),
-  body: z4.string().max(2e4).optional(),
+  body: z5.string().max(2e4).optional(),
   linkedBy: NameSchema,
   linkedAt: IsoDateTimeSchema,
   /**
    * Once its `ghpr` task was abandoned, how the board's closing of it on GitHub went: `ok` false
    * leaves it open, for the reason `detail` gives.
    */
-  closed: z4.object({ at: IsoDateTimeSchema, ok: z4.boolean(), detail: z4.string() }).optional()
+  closed: z5.object({ at: IsoDateTimeSchema, ok: z5.boolean(), detail: z5.string() }).optional()
 });
-var DefaultBranchSchema = z4.string().trim().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "a branch name is letters, digits, and . _ / -").refine((branch) => !branch.includes("..") && !branch.includes("//") && !branch.endsWith("/") && !branch.endsWith(".") && !branch.endsWith(".lock"), "not a branch name git takes").refine((branch) => !branch.startsWith("task/") && !branch.startsWith("agent/"), "task/ and agent/ hold the board's own branches");
-var StageIdSchema = z4.string().regex(/^s[1-9][0-9]*$/, "expected a stage id such as s1");
+var DefaultBranchSchema = z5.string().trim().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "a branch name is letters, digits, and . _ / -").refine((branch) => !branch.includes("..") && !branch.includes("//") && !branch.endsWith("/") && !branch.endsWith(".") && !branch.endsWith(".lock"), "not a branch name git takes").refine((branch) => !branch.startsWith("task/") && !branch.startsWith("agent/"), "task/ and agent/ hold the board's own branches");
+var StageIdSchema = z5.string().regex(/^s[1-9][0-9]*$/, "expected a stage id such as s1");
 var stageFields = {
-  name: z4.string().trim().min(1).max(120),
+  name: z5.string().trim().min(1).max(120),
   role: NameSchema.optional(),
   agent: NameSchema.optional(),
-  gate: z4.boolean().default(false)
+  gate: z5.boolean().default(false)
 };
 function oneAssignee(stage) {
   return stage.role === void 0 || stage.agent === void 0;
 }
 var ONE_ASSIGNEE = { message: "a stage names a role or an agent, not both" };
-var PlanStageSchema = z4.object(stageFields).refine(oneAssignee, ONE_ASSIGNEE);
-var PlanEditStageSchema = z4.object({ id: StageIdSchema.optional(), ...stageFields }).refine(oneAssignee, ONE_ASSIGNEE);
-var PlanSchema = z4.array(PlanStageSchema);
-var PlanEditSchema = z4.array(PlanEditStageSchema);
-var ProjectSchema = z4.object({
+var PlanStageSchema = z5.object(stageFields).refine(oneAssignee, ONE_ASSIGNEE);
+var PlanEditStageSchema = z5.object({ id: StageIdSchema.optional(), ...stageFields }).refine(oneAssignee, ONE_ASSIGNEE);
+var PlanSchema = z5.array(PlanStageSchema);
+var PlanEditSchema = z5.array(PlanEditStageSchema);
+var ProjectSchema = z5.object({
   slug: NameSchema,
-  name: z4.string().min(1),
-  repo: z4.string().nullable(),
-  defaultBranch: z4.string().min(1),
+  name: z5.string().min(1),
+  repo: z5.string().nullable(),
+  defaultBranch: z5.string().min(1),
   /** The channels that take posts; an archived one moves to `archivedChannels`. */
-  channels: z4.array(NameSchema),
-  archivedChannels: z4.array(ArchivedChannelSchema).default([]),
-  members: z4.array(NameSchema),
-  approvers: z4.array(NameSchema),
-  requiredCapabilities: z4.array(z4.string()),
+  channels: z5.array(NameSchema),
+  archivedChannels: z5.array(ArchivedChannelSchema).default([]),
+  members: z5.array(NameSchema),
+  approvers: z5.array(NameSchema),
+  requiredCapabilities: z5.array(z5.string()),
   createdAt: IsoDateTimeSchema,
   onDone: CompletionEffectSchema.default("none"),
   /** The runner the project lives on, which holds its repository; set on the project's first turn. */
   runner: NameSchema.optional(),
   /** Set once the project is archived: nobody belongs to it, and nothing more is posted, filed, or joined there. */
-  archived: z4.object({ at: IsoDateTimeSchema, by: NameSchema, reason: z4.string().min(1) }).optional()
+  archived: z5.object({ at: IsoDateTimeSchema, by: NameSchema, reason: z5.string().min(1) }).optional()
 });
-var TaskStepSchema = z4.object({
-  action: z4.enum(["advanced", "returned", "abandoned", "landed", "reopened"]),
+var TaskStepSchema = z5.object({
+  action: z5.enum(["advanced", "returned", "abandoned", "landed", "reopened"]),
   stage: StageIdSchema,
   to: StageIdSchema.nullable()
 });
-var ProposalStepSchema = z4.object({ action: z4.enum(["approved", "rejected"]) });
-var MessageStepSchema = z4.union([TaskStepSchema, ProposalStepSchema]);
+var ProposalStepSchema = z5.object({ action: z5.enum(["approved", "rejected"]) });
+var MessageStepSchema = z5.union([TaskStepSchema, ProposalStepSchema]);
 function isTaskStep(step) {
   return "stage" in step;
 }
-var KnowledgeNoticeSchema = z4.object({
-  kind: z4.literal("knowledge"),
-  action: z4.enum(["written", "updated", "removed"]),
+var KnowledgeNoticeSchema = z5.object({
+  kind: z5.literal("knowledge"),
+  action: z5.enum(["written", "updated", "removed"]),
   topic: NameSchema,
   project: NameSchema.nullable()
 });
-var MessageNoticeSchema = z4.discriminatedUnion("kind", [KnowledgeNoticeSchema]);
-var MessageFrontmatterSchema = z4.object({
+var MessageNoticeSchema = z5.discriminatedUnion("kind", [KnowledgeNoticeSchema]);
+var MessageFrontmatterSchema = z5.object({
   id: UlidSchema,
   author: NameSchema,
   channel: ChannelRefSchema,
@@ -435,7 +544,7 @@ var MessageFrontmatterSchema = z4.object({
   /** On a post a verb made about its work, such as a knowledge topic's note: what it records. */
   notice: MessageNoticeSchema.optional(),
   ts: IsoDateTimeSchema,
-  mentions: z4.array(NameSchema)
+  mentions: z5.array(NameSchema)
 });
 var MessageRefSchema = MessageFrontmatterSchema.pick({
   id: true,
@@ -445,16 +554,16 @@ var MessageRefSchema = MessageFrontmatterSchema.pick({
   ts: true
 });
 var MESSAGE_LOOKUP_LIMIT = 50;
-var TaskStatusSchema = z4.enum(["open", "claimed", "done", "abandoned"]);
-var ThreadStateSchema = z4.enum(["open", "closed"]);
-var ThreadSubjectSchema = z4.object({
-  kind: z4.enum(["task", "proposal"]),
+var TaskStatusSchema = z5.enum(["open", "claimed", "done", "abandoned"]);
+var ThreadStateSchema = z5.enum(["open", "closed"]);
+var ThreadSubjectSchema = z5.object({
+  kind: z5.enum(["task", "proposal"]),
   id: UlidSchema
 });
-var ThreadFrontmatterSchema = z4.object({
+var ThreadFrontmatterSchema = z5.object({
   id: UlidSchema,
   channel: ChannelRefSchema,
-  title: z4.string().min(1).max(200),
+  title: z5.string().min(1).max(200),
   subject: ThreadSubjectSchema.optional(),
   state: ThreadStateSchema,
   openedBy: NameSchema,
@@ -462,28 +571,28 @@ var ThreadFrontmatterSchema = z4.object({
   closedBy: NameSchema.optional(),
   closedAt: IsoDateTimeSchema.optional()
 });
-var StageSchema = z4.object({
+var StageSchema = z5.object({
   id: StageIdSchema,
-  name: z4.string().min(1),
+  name: z5.string().min(1),
   role: NameSchema.optional(),
   agent: NameSchema.optional(),
-  gate: z4.boolean().default(false),
+  gate: z5.boolean().default(false),
   /** Everyone who has held the stage, oldest first. */
-  holders: z4.array(NameSchema).default([]),
+  holders: z5.array(NameSchema).default([]),
   completedBy: NameSchema.optional(),
   completedAt: IsoDateTimeSchema.optional()
 });
-var TaskReturnSchema = z4.object({
+var TaskReturnSchema = z5.object({
   from: StageIdSchema,
   by: NameSchema,
   at: IsoDateTimeSchema
 });
-var TaskFrontmatterSchema = z4.object({
+var TaskFrontmatterSchema = z5.object({
   id: UlidSchema,
   project: NameSchema,
   /** The channel of the project the task is filed in, where its thread hangs. */
   channel: NameSchema.default("general"),
-  title: z4.string().min(1),
+  title: z5.string().min(1),
   status: TaskStatusSchema,
   createdBy: NameSchema,
   createdAt: IsoDateTimeSchema,
@@ -492,19 +601,19 @@ var TaskFrontmatterSchema = z4.object({
   claimedBy: NameSchema.optional(),
   leaseExpiresAt: IsoDateTimeSchema.optional(),
   parentId: UlidSchema.optional(),
-  blockedBy: z4.array(UlidSchema),
-  requiredCapabilities: z4.array(z4.string()),
-  stages: z4.array(StageSchema).min(1),
+  blockedBy: z5.array(UlidSchema),
+  requiredCapabilities: z5.array(z5.string()),
+  stages: z5.array(StageSchema).min(1),
   stage: StageIdSchema,
   /** When the current stage last became current or lost its holder: the waiting clock. */
   stageSince: IsoDateTimeSchema,
   /** The highest stage number issued, so a removed stage's id is never reused. */
-  stageSeq: z4.number().int().positive(),
+  stageSeq: z5.number().int().positive(),
   onDone: CompletionEffectSchema.default("none"),
   /** The pull request a `ghpr` task lands through. */
   pullRequest: PullRequestLinkSchema.optional(),
   /** The last stage is complete and the completion effect is running. */
-  completing: z4.boolean().default(false),
+  completing: z5.boolean().default(false),
   /** The latest send-back while its rework lasts: cleared once the task reaches that stage again. */
   returned: TaskReturnSchema.optional()
 });
@@ -528,79 +637,90 @@ function mayHoldStage(member, task) {
   }
   return !(stage.gate && task.stages.slice(0, index).some((s) => s.holders.includes(member.name)));
 }
-var ModelNameSchema = z4.string().trim().min(1).max(120).regex(/^[\w.:/[\]-]+$/, "a model name is one word of letters, digits, and . _ : / - [ ]");
-var EffortSchema = z4.string().trim().min(1).max(32).regex(/^[a-z][a-z0-9_-]*$/, "an effort is one lowercase word, such as high");
-var EffortOptionSchema = z4.object({
+var ModelNameSchema = z5.string().trim().min(1).max(120).regex(/^[\w.:/[\]-]+$/, "a model name is one word of letters, digits, and . _ : / - [ ]");
+var EffortSchema = z5.string().trim().min(1).max(32).regex(/^[a-z][a-z0-9_-]*$/, "an effort is one lowercase word, such as high");
+var EffortOptionSchema = z5.object({
   id: EffortSchema,
-  description: z4.string().default("")
+  description: z5.string().default("")
 });
-var ModelOptionSchema = z4.object({
+var ModelOptionSchema = z5.object({
   id: ModelNameSchema,
-  name: z4.string(),
-  description: z4.string().default(""),
-  isDefault: z4.boolean().default(false),
-  efforts: z4.array(EffortOptionSchema).default([]),
+  name: z5.string(),
+  description: z5.string().default(""),
+  isDefault: z5.boolean().default(false),
+  efforts: z5.array(EffortOptionSchema).default([]),
   defaultEffort: EffortSchema.optional()
 });
-var RunnerModelsSchema = z4.object({
+var RunnerModelsSchema = z5.object({
   runner: NameSchema,
   cli: CliKindSchema,
-  models: z4.array(ModelOptionSchema)
+  models: z5.array(ModelOptionSchema)
 });
-var AgentStatusSchema = z4.enum(["active", "retired"]);
-var AgentSchema = z4.object({
+var AgentStatusSchema = z5.enum(["active", "retired"]);
+var AgentSchema = z5.object({
   name: NameSchema,
   role: NameSchema,
   cli: CliKindSchema.nullable(),
-  model: z4.string().optional(),
+  model: z5.string().optional(),
   /** The reasoning effort set for the agent's turns; the model's own default applies otherwise. */
-  effort: z4.string().optional(),
+  effort: z5.string().optional(),
   /** The runner preferred for the agent's turns where nothing else decides; any runner with its CLI otherwise. */
   homeRunner: NameSchema.optional(),
-  memberships: z4.array(NameSchema),
-  subscriptions: z4.array(ChannelRefSchema),
+  memberships: z5.array(NameSchema),
+  subscriptions: z5.array(ChannelRefSchema),
   status: AgentStatusSchema,
   createdAt: IsoDateTimeSchema,
-  tokenHash: z4.string().min(1),
+  tokenHash: z5.string().min(1),
   retiredAt: IsoDateTimeSchema.optional(),
-  retiredReason: z4.string().optional()
+  retiredReason: z5.string().optional()
 });
-var MemberSchema = z4.object({
+var MemberSchema = z5.object({
   name: NameSchema,
   role: NameSchema,
   cli: CliKindSchema.nullable(),
   homeRunner: NameSchema.optional(),
   status: AgentStatusSchema,
-  resident: z4.boolean().default(false),
+  resident: z5.boolean().default(false),
   /** The model configured on the record, if any; the CLI's own default applies otherwise. */
-  model: z4.string().optional(),
+  model: z5.string().optional(),
   /** The model the CLI reported on the citizen's last turn. */
-  lastModel: z4.string().optional(),
+  lastModel: z5.string().optional(),
   /** The reasoning effort configured on the record, if any; the model's own default applies otherwise. */
-  effort: z4.string().optional(),
+  effort: z5.string().optional(),
   /** The citizen's own skills, by name. */
-  skills: z4.array(NameSchema).default([]),
-  memberships: z4.array(NameSchema),
-  subscriptions: z4.array(ChannelRefSchema),
-  claimsHeld: z4.number().int().nonnegative().default(0),
-  tasksDone: z4.number().int().nonnegative().default(0),
+  skills: z5.array(NameSchema).default([]),
+  memberships: z5.array(NameSchema),
+  subscriptions: z5.array(ChannelRefSchema),
+  claimsHeld: z5.number().int().nonnegative().default(0),
+  tasksDone: z5.number().int().nonnegative().default(0),
   lastTurnAt: IsoDateTimeSchema.optional(),
-  lastTurnOutcome: z4.string().optional(),
+  lastTurnOutcome: z5.string().optional(),
   createdAt: IsoDateTimeSchema,
   retiredAt: IsoDateTimeSchema.optional()
 });
-var RunnerOsSchema = z4.enum(["linux", "windows", "darwin"]);
-var RunnerSchema = z4.object({
+var RunnerOsSchema = z5.enum(["linux", "windows", "darwin"]);
+var GitIdentityPartSchema = z5.enum(["name", "email"]);
+var RunnerSchema = z5.object({
   name: NameSchema,
   os: RunnerOsSchema,
-  clis: z4.array(CliKindSchema),
-  capabilities: z4.array(z4.string()),
+  clis: z5.array(CliKindSchema),
+  capabilities: z5.array(z5.string()),
   /** The release the runner reported when it last registered; absent until it has. */
-  version: z4.string().optional(),
-  status: z4.enum(["connected", "disconnected"]),
-  lastSeen: IsoDateTimeSchema.optional()
+  version: z5.string().optional(),
+  /**
+   * What the runner's account lacked of a git identity when it last registered, empty when it had
+   * both; absent while the runner has not said, as one from before runners checked never does.
+   */
+  gitIdentityMissing: z5.array(GitIdentityPartSchema).optional(),
+  status: z5.enum(["connected", "disconnected"]),
+  lastSeen: IsoDateTimeSchema.optional(),
+  /**
+   * Each CLI's plan quota as its login on this runner last reported it, from a turn's stream or a
+   * read; absent until one has.
+   */
+  quotas: z5.partialRecord(CliKindSchema, CliQuotaSchema).optional()
 });
-var ProposalKindSchema = z4.enum([
+var ProposalKindSchema = z5.enum([
   "role",
   "member",
   "channel",
@@ -609,42 +729,42 @@ var ProposalKindSchema = z4.enum([
   "skill",
   "archive"
 ]);
-var ProposalStatusSchema = z4.enum([
+var ProposalStatusSchema = z5.enum([
   "proposed",
   "approved",
   "rejected",
   "provisioned",
   "retired"
 ]);
-var MemberProposalSchema = z4.object({
+var MemberProposalSchema = z5.object({
   name: NameSchema,
   role: NameSchema,
   cli: CliKindSchema,
-  model: z4.string().optional(),
+  model: z5.string().optional(),
   homeRunner: NameSchema.optional(),
-  memberships: z4.array(NameSchema).default([]),
-  subscriptions: z4.array(ChannelRefSchema).default([]),
-  seedInstructions: z4.string().optional()
+  memberships: z5.array(NameSchema).default([]),
+  subscriptions: z5.array(ChannelRefSchema).default([]),
+  seedInstructions: z5.string().optional()
 });
-var ChannelProposalSchema = z4.object({
+var ChannelProposalSchema = z5.object({
   project: NameSchema.nullable().default(null),
   name: NameSchema,
-  purpose: z4.string().min(1)
+  purpose: z5.string().min(1)
 });
-var RoleChangesSchema = z4.strictObject({
-  maxReplicas: z4.number().int().min(1).optional(),
-  backlogThreshold: z4.number().positive().optional(),
-  wakeTriggers: z4.array(CharterTriggerSchema).optional(),
-  verbs: z4.array(VerbNameSchema).optional()
+var RoleChangesSchema = z5.strictObject({
+  maxReplicas: z5.number().int().min(1).optional(),
+  backlogThreshold: z5.number().positive().optional(),
+  wakeTriggers: z5.array(CharterTriggerSchema).optional(),
+  verbs: z5.array(VerbNameSchema).optional()
 }).refine((changes) => Object.values(changes).some((value) => value !== void 0), {
   message: "a reallocation changes at least one of maxReplicas, backlogThreshold, wakeTriggers, verbs"
 });
-var ReallocationProposalSchema = z4.object({
+var ReallocationProposalSchema = z5.object({
   role: NameSchema,
   changes: RoleChangesSchema,
-  description: z4.string().min(1)
+  description: z5.string().min(1)
 });
-var LegacyReallocationSchema = z4.object({ description: z4.string().min(1) });
+var LegacyReallocationSchema = z5.object({ description: z5.string().min(1) });
 function applyRoleChanges(role, changes) {
   return {
     ...role,
@@ -679,18 +799,18 @@ function roleChangeLines(role, changes) {
   }
   return lines;
 }
-var RetirementProposalSchema = z4.object({
+var RetirementProposalSchema = z5.object({
   agent: NameSchema,
-  reason: z4.string().min(1)
+  reason: z5.string().min(1)
 });
-var ArchiveProposalSchema = z4.object({
+var ArchiveProposalSchema = z5.object({
   project: NameSchema,
-  reason: z4.string().min(1)
+  reason: z5.string().min(1)
 });
-var SkillProposalSchema = z4.object({
+var SkillProposalSchema = z5.object({
   name: NameSchema,
-  summary: z4.string().min(1).max(200),
-  body: z4.string().min(1).optional()
+  summary: z5.string().min(1).max(200),
+  body: z5.string().min(1).optional()
 });
 var ProposalCharterSchemas = {
   role: RoleCharterSchema,
@@ -793,23 +913,23 @@ function describeCharter(kind, charter) {
   }
   return `${kind} ${JSON.stringify(charter)}`;
 }
-var SkillSchema = z4.object({
+var SkillSchema = z5.object({
   name: NameSchema,
-  summary: z4.string().default(""),
-  scope: z4.enum(["own", "society"]),
-  path: z4.string().min(1)
+  summary: z5.string().default(""),
+  scope: z5.enum(["own", "society"]),
+  path: z5.string().min(1)
 });
-var RemovedSkillSchema = z4.object({
+var RemovedSkillSchema = z5.object({
   name: NameSchema,
-  reason: z4.string().min(1),
+  reason: z5.string().min(1),
   removedBy: NameSchema,
   removedAt: IsoDateTimeSchema
 });
-var HomeConflictSchema = z4.object({
+var HomeConflictSchema = z5.object({
   /** The copy, relative to the home. */
-  path: z4.string().min(1),
+  path: z5.string().min(1),
   /** The file beside it, whose version the board kept. */
-  file: z4.string().min(1),
+  file: z5.string().min(1),
   /** When the copy reached the board. */
   since: IsoDateTimeSchema
 });
@@ -817,79 +937,79 @@ var CONFLICT_COPY = /^(.+)\.conflict-[^/.]+$/;
 function conflictCopyOf(copy) {
   return CONFLICT_COPY.exec(copy)?.[1] ?? null;
 }
-var CommitIdSchema = z4.string().regex(/^[0-9a-f]{40}([0-9a-f]{24})?$/);
-var HomeFileChangeSchema = z4.object({
-  path: z4.string().min(1),
-  status: z4.enum(["added", "modified", "deleted"]),
+var CommitIdSchema = z5.string().regex(/^[0-9a-f]{40}([0-9a-f]{24})?$/);
+var HomeFileChangeSchema = z5.object({
+  path: z5.string().min(1),
+  status: z5.enum(["added", "modified", "deleted"]),
   /** Lines added and removed, or null for a binary file. */
-  added: z4.number().int().nonnegative().nullable(),
-  removed: z4.number().int().nonnegative().nullable()
+  added: z5.number().int().nonnegative().nullable(),
+  removed: z5.number().int().nonnegative().nullable()
 });
-var HomeChangeSchema = z4.object({
+var HomeChangeSchema = z5.object({
   commit: CommitIdSchema,
   at: IsoDateTimeSchema,
-  kind: z4.enum(["turn", "board", "merge"]),
-  author: z4.string(),
+  kind: z5.enum(["turn", "board", "merge"]),
+  author: z5.string(),
   /** The turn that made it, from the runner's commit message. */
   turnId: UlidSchema.optional(),
-  subject: z4.string(),
-  files: z4.array(HomeFileChangeSchema)
+  subject: z5.string(),
+  files: z5.array(HomeFileChangeSchema)
 });
-var HomeHistorySchema = z4.object({
-  changes: z4.array(HomeChangeSchema),
+var HomeHistorySchema = z5.object({
+  changes: z5.array(HomeChangeSchema),
   /** Whether older commits remain past the ones read. */
-  more: z4.boolean()
+  more: z5.boolean()
 });
 var HomeFileDiffSchema = HomeFileChangeSchema.pick({ path: true, status: true }).extend({
-  patch: z4.string().nullable(),
+  patch: z5.string().nullable(),
   /** The patch was cut at its size limit. */
-  truncated: z4.boolean()
+  truncated: z5.boolean()
 });
-var KnowledgeSchema = z4.object({
+var KnowledgeSchema = z5.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
-  revision: z4.number().int().min(0),
+  revision: z5.number().int().min(0),
   updatedBy: NameSchema,
   updatedAt: IsoDateTimeSchema
 });
-var RemovedKnowledgeSchema = z4.object({
+var RemovedKnowledgeSchema = z5.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
   removedBy: NameSchema,
   removedAt: IsoDateTimeSchema
 });
-var DashboardSchema = z4.object({
+var DashboardSchema = z5.object({
   project: NameSchema,
-  revision: z4.number().int().min(0),
+  revision: z5.number().int().min(0),
   /** Absent until someone updates the dashboard the project began with. */
   updatedBy: NameSchema.optional(),
   updatedAt: IsoDateTimeSchema.optional(),
-  body: z4.string()
+  body: z5.string()
 });
-var ProposalOriginSchema = z4.object({
+var ProposalOriginSchema = z5.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional()
 });
 var SKILL_FILES_LIMIT = 100;
 var SKILL_BYTES_LIMIT = 10 * 1024 * 1024;
-var SkillFileSchema = z4.object({
-  path: z4.string().min(1),
-  size: z4.number().int().nonnegative(),
-  executable: z4.boolean()
+var SkillFileSchema = z5.object({
+  path: z5.string().min(1),
+  size: z5.number().int().nonnegative(),
+  executable: z5.boolean()
 });
-var SkillFilesSchema = z4.object({
+var SkillFilesSchema = z5.object({
   /** The commit of the proposer's home the files came from. */
   commit: CommitIdSchema,
   takenAt: IsoDateTimeSchema,
-  files: z4.array(SkillFileSchema)
+  files: z5.array(SkillFileSchema)
 });
 var SkillFileContentSchema = SkillFileSchema.extend({
-  text: z4.string().nullable(),
+  text: z5.string().nullable(),
   /** The text was cut at its size limit. */
-  truncated: z4.boolean()
+  truncated: z5.boolean()
 });
-var ProposalFrontmatterSchema = z4.object({
+var ProposalFrontmatterSchema = z5.object({
   id: UlidSchema,
   kind: ProposalKindSchema,
   proposedBy: NameSchema,
@@ -901,146 +1021,146 @@ var ProposalFrontmatterSchema = z4.object({
   skillFiles: SkillFilesSchema.optional(),
   decidedBy: NameSchema.optional(),
   decidedAt: IsoDateTimeSchema.optional(),
-  reason: z4.string().optional(),
-  charter: z4.record(z4.string(), z4.unknown()),
+  reason: z5.string().optional(),
+  charter: z5.record(z5.string(), z5.unknown()),
   /** What approval created, for kinds the board provisions: the agent, channel, role, or retirement. */
   provisionedAt: IsoDateTimeSchema.optional(),
-  provision: z4.record(z4.string(), z4.unknown()).optional()
+  provision: z5.record(z5.string(), z5.unknown()).optional()
 });
-var DecisionSchema = z4.object({
+var DecisionSchema = z5.object({
   id: UlidSchema,
   proposalId: UlidSchema,
   decidedBy: NameSchema,
-  outcome: z4.enum(["approved", "rejected"]),
-  reason: z4.string().optional(),
+  outcome: z5.enum(["approved", "rejected"]),
+  reason: z5.string().optional(),
   ts: IsoDateTimeSchema
 });
 
 // packages/shared/dist/verbs.js
-import { z as z5 } from "zod";
-var MomentSchema = z5.iso.datetime({ offset: true });
-var CronTitleSchema = z5.string().trim().min(1).max(120);
-var CronNoteSchema = z5.string().trim().min(1).max(4e3);
+import { z as z6 } from "zod";
+var MomentSchema = z6.iso.datetime({ offset: true });
+var CronTitleSchema = z6.string().trim().min(1).max(120);
+var CronNoteSchema = z6.string().trim().min(1).max(4e3);
 var VerbInputs = {
-  post_message: z5.object({
+  post_message: z6.object({
     /** Required outside a thread; in one it may be left out, and must otherwise be the thread's. */
     channel: ChannelRefSchema.optional(),
-    body: z5.string().min(1),
+    body: z6.string().min(1),
     thread_id: UlidSchema.optional()
   }),
-  read_inbox: z5.object({
+  read_inbox: z6.object({
     since_cursor: UlidSchema.nullable().optional(),
-    limit: z5.number().int().positive().max(200).default(50),
-    advance: z5.boolean().default(true)
+    limit: z6.number().int().positive().max(200).default(50),
+    advance: z6.boolean().default(true)
   }),
-  search: z5.object({
-    query: z5.string().min(1),
+  search: z6.object({
+    query: z6.string().min(1),
     project: NameSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    limit: z5.number().int().positive().max(100).default(20)
+    limit: z6.number().int().positive().max(100).default(20)
   }),
   /** On a task or a proposal, whose id the thread takes, or on a channel with a title. */
-  open_thread: z5.object({
+  open_thread: z6.object({
     task_id: UlidSchema.optional(),
     proposal_id: UlidSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    title: z5.string().min(1).max(200).optional()
+    title: z6.string().min(1).max(200).optional()
   }),
-  close_thread: z5.object({ thread_id: UlidSchema, summary: z5.string().min(1) }),
-  create_task: z5.object({
+  close_thread: z6.object({ thread_id: UlidSchema, summary: z6.string().min(1) }),
+  create_task: z6.object({
     project: NameSchema,
-    title: z5.string().min(1).max(200),
-    body: z5.string().default(""),
+    title: z6.string().min(1).max(200),
+    body: z6.string().default(""),
     parent_id: UlidSchema.optional(),
-    required_capabilities: z5.array(z5.string()).default([]),
+    required_capabilities: z6.array(z6.string()).default([]),
     /** The plan; without it the task gets one stage, work, that anyone in the project may take. */
-    stages: z5.array(PlanStageSchema).min(1).optional(),
+    stages: z6.array(PlanStageSchema).min(1).optional(),
     /** A channel of the project the task belongs to, such as a release's; its thread opens there. */
     channel: NameSchema.default("general")
   }),
-  claim_task: z5.object({ task_id: UlidSchema }),
-  release_task: z5.object({ task_id: UlidSchema }),
-  update_task: z5.object({
+  claim_task: z6.object({ task_id: UlidSchema }),
+  release_task: z6.object({ task_id: UlidSchema }),
+  update_task: z6.object({
     task_id: UlidSchema,
     /** Move the task back to this earlier stage. */
     stage: StageIdSchema.optional(),
-    status: z5.enum(["abandoned"]).optional(),
+    status: z6.enum(["abandoned"]).optional(),
     /** Posted to the task's thread as the caller, marked with the step when the task moved. */
-    note: z5.string().min(1).optional(),
-    blocked_by: z5.array(UlidSchema).optional(),
+    note: z6.string().min(1).optional(),
+    blocked_by: z6.array(UlidSchema).optional(),
     /**
      * The pull request a `ghpr` task lands through, on its project's repository, with the merge
      * commit's subject and body; null unlinks it.
      */
-    pull_request: z5.object({
+    pull_request: z6.object({
       url: PullRequestUrlSchema,
       merge_subject: MergeSubjectSchema.optional(),
-      merge_body: z5.string().max(2e4).optional()
+      merge_body: z6.string().max(2e4).optional()
     }).nullable().optional()
   }),
-  get_task: z5.object({ task_id: UlidSchema }),
-  subscribe: z5.object({ channel: ChannelRefSchema }),
-  unsubscribe: z5.object({ channel: ChannelRefSchema }),
-  propose: z5.object({
+  get_task: z6.object({ task_id: UlidSchema }),
+  subscribe: z6.object({ channel: ChannelRefSchema }),
+  unsubscribe: z6.object({ channel: ChannelRefSchema }),
+  propose: z6.object({
     kind: ProposalKindSchema,
-    charter: z5.record(z5.string(), z5.unknown()),
-    rationale: z5.string().default("")
+    charter: z6.record(z6.string(), z6.unknown()),
+    rationale: z6.string().default("")
   }),
-  approve: z5.object({ proposal_id: UlidSchema, reason: z5.string().optional() }),
-  reject: z5.object({ proposal_id: UlidSchema, reason: z5.string().min(1) }),
-  create_project: z5.object({
+  approve: z6.object({ proposal_id: UlidSchema, reason: z6.string().optional() }),
+  reject: z6.object({ proposal_id: UlidSchema, reason: z6.string().min(1) }),
+  create_project: z6.object({
     slug: NameSchema,
-    name: z5.string().min(1).optional(),
-    repo: z5.string().min(1).nullable().default(null),
+    name: z6.string().min(1).optional(),
+    repo: z6.string().min(1).nullable().default(null),
     default_branch: DefaultBranchSchema.default("main"),
     on_done: CompletionEffectSchema.optional()
   }),
-  join_project: z5.object({ project: NameSchema, agent: NameSchema.optional() }),
-  leave_project: z5.object({ project: NameSchema, agent: NameSchema.optional() }),
-  write_knowledge: z5.object({
+  join_project: z6.object({ project: NameSchema, agent: NameSchema.optional() }),
+  leave_project: z6.object({ project: NameSchema, agent: NameSchema.optional() }),
+  write_knowledge: z6.object({
     /** A project you belong to, or null for society knowledge, which the steward and the user curate. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema,
-    body: z5.string().min(1),
+    body: z6.string().min(1),
     /** The `revision` in the frontmatter of the topic you read, 0 when it names none or for a new topic. */
-    revision: z5.number().int().min(0)
+    revision: z6.number().int().min(0)
   }),
-  remove_knowledge: z5.object({
+  remove_knowledge: z6.object({
     /** As for write_knowledge: a project you belong to, or null for society knowledge. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema
   }),
-  plan_task: z5.object({
+  plan_task: z6.object({
     task_id: UlidSchema,
-    stages: z5.array(PlanEditStageSchema),
+    stages: z6.array(PlanEditStageSchema),
     on_done: CompletionEffectSchema.optional()
   }),
   /** The note is posted to the task's thread as the caller, marked with the step. */
-  advance_task: z5.object({ task_id: UlidSchema, note: z5.string().min(1).optional() }),
-  configure_project: z5.object({
+  advance_task: z6.object({ task_id: UlidSchema, note: z6.string().min(1).optional() }),
+  configure_project: z6.object({
     project: NameSchema,
     on_done: CompletionEffectSchema.optional(),
     /** A new display name; the slug, which everything refers to the project by, never changes. */
-    name: z5.string().trim().min(1).max(120).optional(),
+    name: z6.string().trim().min(1).max(120).optional(),
     /** The branch tasks start from and land on from now; tasks in play keep their branches. */
     default_branch: DefaultBranchSchema.optional()
   }),
-  archive_project: z5.object({ project: NameSchema, reason: z5.string().min(1) }),
-  create_channel: z5.object({
+  archive_project: z6.object({ project: NameSchema, reason: z6.string().min(1) }),
+  create_channel: z6.object({
     /** A project, or null for a channel of the society. */
     project: NameSchema.nullable().default(null),
     name: NameSchema,
-    purpose: z5.string().min(1)
+    purpose: z6.string().min(1)
   }),
-  archive_channel: z5.object({ channel: ChannelRefSchema, reason: z5.string().min(1) }),
-  update_dashboard: z5.object({
+  archive_channel: z6.object({ channel: ChannelRefSchema, reason: z6.string().min(1) }),
+  update_dashboard: z6.object({
     project: NameSchema,
     /** The whole dashboard as markdown; the board keeps its frontmatter. */
-    body: z5.string().min(1),
+    body: z6.string().min(1),
     /** The `revision` in the frontmatter of the dashboard you read, 0 when it names none. */
-    revision: z5.number().int().min(0)
+    revision: z6.number().int().min(0)
   }),
-  create_cron: z5.object({
+  create_cron: z6.object({
     title: CronTitleSchema,
     /** What to do when it fires; quoted in the prompt of every turn it starts. */
     note: CronNoteSchema,
@@ -1059,10 +1179,10 @@ var VerbInputs = {
     /** An open channel of that place other than general, whose conversation it fires in. */
     channel: NameSchema.optional()
   }),
-  update_cron: z5.object({
+  update_cron: z6.object({
     cron_id: UlidSchema,
     /** Pause it, or resume it, which starts its schedule afresh from now. */
-    paused: z5.boolean().optional(),
+    paused: z6.boolean().optional(),
     title: CronTitleSchema.optional(),
     note: CronNoteSchema.optional(),
     /** A new expression, or `at` for one time; either starts the schedule afresh. */
@@ -1071,8 +1191,8 @@ var VerbInputs = {
     timezone: TimeZoneSchema.nullable().optional(),
     at: MomentSchema.optional()
   }),
-  remove_cron: z5.object({ cron_id: UlidSchema, reason: z5.string().trim().min(1) }),
-  remove_skill: z5.object({ name: NameSchema, reason: z5.string().trim().min(1) })
+  remove_cron: z6.object({ cron_id: UlidSchema, reason: z6.string().trim().min(1) }),
+  remove_skill: z6.object({ name: NameSchema, reason: z6.string().trim().min(1) })
 };
 var VERB_DESCRIPTIONS = {
   post_message: "Post a markdown message to a channel, or into a thread when thread_id is given; a thread's message goes to the thread's channel.",
@@ -1109,7 +1229,7 @@ var VERB_DESCRIPTIONS = {
 };
 
 // packages/shared/dist/events.js
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var BOARD_EVENT_TYPES = [
   "society.initialized",
   "project.added",
@@ -1154,6 +1274,7 @@ var BOARD_EVENT_TYPES = [
   "user.signed_out",
   "user.token_rotated",
   "runner.changed",
+  "runner.quota",
   "ops.signal",
   "paused.changed",
   "wake.requested",
@@ -1174,28 +1295,36 @@ var BOARD_EVENT_TYPES = [
   "cron.skipped",
   "cron.ended"
 ];
-var BoardEventTypeSchema = z6.enum(BOARD_EVENT_TYPES);
-var BoardEventSchema = z6.object({
+var BoardEventTypeSchema = z7.enum(BOARD_EVENT_TYPES);
+var BoardEventSchema = z7.object({
   id: UlidSchema,
   ts: IsoDateTimeSchema,
   type: BoardEventTypeSchema,
   actor: NameSchema,
-  payload: z6.record(z6.string(), z6.unknown())
+  payload: z7.record(z7.string(), z7.unknown())
 });
-var UsageSchema = z6.object({
-  inputTokens: z6.number().int().nonnegative(),
-  outputTokens: z6.number().int().nonnegative(),
-  cacheReadTokens: z6.number().int().nonnegative().default(0),
-  cacheWriteTokens: z6.number().int().nonnegative().default(0)
+var UsageSchema = z7.object({
+  inputTokens: z7.number().int().nonnegative(),
+  outputTokens: z7.number().int().nonnegative(),
+  cacheReadTokens: z7.number().int().nonnegative().default(0),
+  cacheWriteTokens: z7.number().int().nonnegative().default(0)
 });
-var TurnStatusSchema = z6.object({
-  summary: z6.string().min(1),
-  claimsHeld: z6.array(UlidSchema).default([]),
-  blockedOn: z6.array(z6.string()).default([]),
-  needsUserDecision: z6.boolean().default(false),
-  memoryUpdated: z6.boolean().default(false)
+function addUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
+    cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens
+  };
+}
+var TurnStatusSchema = z7.object({
+  summary: z7.string().min(1),
+  claimsHeld: z7.array(UlidSchema).default([]),
+  blockedOn: z7.array(z7.string()).default([]),
+  needsUserDecision: z7.boolean().default(false),
+  memoryUpdated: z7.boolean().default(false)
 });
-var TurnExitReasonSchema = z6.enum([
+var TurnExitReasonSchema = z7.enum([
   "completed",
   "timeout",
   "error",
@@ -1203,50 +1332,50 @@ var TurnExitReasonSchema = z6.enum([
   "blocked",
   "stopped"
 ]);
-var AgentEventSchema = z6.discriminatedUnion("type", [
-  z6.object({
-    type: z6.literal("turn_started"),
+var AgentEventSchema = z7.discriminatedUnion("type", [
+  z7.object({
+    type: z7.literal("turn_started"),
     agent: NameSchema,
-    session: z6.string(),
+    session: z7.string(),
     runner: NameSchema,
     /** The model the CLI reports running, when it reports one. */
-    model: z6.string().optional()
+    model: z7.string().optional()
   }),
   /**
    * The CLI took a steer into the running turn. Adapters name the steer; the server adds the
    * messages it delivered and the text the CLI was given.
    */
-  z6.object({
-    type: z6.literal("steered"),
-    steer: z6.string().min(1),
-    messages: z6.array(UlidSchema).optional(),
-    text: z6.string().optional()
+  z7.object({
+    type: z7.literal("steered"),
+    steer: z7.string().min(1),
+    messages: z7.array(UlidSchema).optional(),
+    text: z7.string().optional()
   }),
-  z6.object({ type: z6.literal("text"), delta: z6.string() }),
-  z6.object({ type: z6.literal("tool_call"), name: z6.string(), input: z6.unknown() }),
-  z6.object({
-    type: z6.literal("tool_result"),
-    name: z6.string(),
-    ok: z6.boolean(),
+  z7.object({ type: z7.literal("text"), delta: z7.string() }),
+  z7.object({ type: z7.literal("tool_call"), name: z7.string(), input: z7.unknown() }),
+  z7.object({
+    type: z7.literal("tool_result"),
+    name: z7.string(),
+    ok: z7.boolean(),
     /** What the tool returned, cut to `OUTPUT_LIMIT` characters by `capOutput`. */
-    output: z6.string().optional()
+    output: z7.string().optional()
   }),
-  z6.object({ type: z6.literal("approval_requested"), kind: z6.string(), detail: z6.unknown() }),
-  z6.object({
-    type: z6.literal("turn_completed"),
+  z7.object({ type: z7.literal("approval_requested"), kind: z7.string(), detail: z7.unknown() }),
+  z7.object({
+    type: z7.literal("turn_completed"),
     usage: UsageSchema,
-    costUsd: z6.number().nonnegative(),
+    costUsd: z7.number().nonnegative(),
     status: TurnStatusSchema.nullable(),
     exitReason: TurnExitReasonSchema
   }),
-  z6.object({ type: z6.literal("error"), message: z6.string() })
+  z7.object({ type: z7.literal("error"), message: z7.string() })
 ]);
-var TranscriptEntrySchema = z6.object({
+var TranscriptEntrySchema = z7.object({
   ts: IsoDateTimeSchema,
   event: AgentEventSchema
 });
-var LiveTurnEventSchema = z6.object({
-  seq: z6.number().int().positive(),
+var LiveTurnEventSchema = z7.object({
+  seq: z7.number().int().positive(),
   ts: IsoDateTimeSchema,
   agent: NameSchema,
   project: NameSchema,
@@ -1258,10 +1387,10 @@ var LiveTurnEventSchema = z6.object({
 });
 
 // packages/shared/dist/turns.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // packages/shared/dist/runner.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var RUNNER_PROTOCOL = 1;
 var PATH_TOKENS = {
   home: "{{stellaris:home}}",
@@ -1272,67 +1401,75 @@ var SERVER_TOKEN = "{{stellaris:server}}";
 var WORKSPACE_TOKEN = "{{stellaris:workspace}}";
 var HOME_SCRATCH = "scratch";
 var HOME_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var RunnerHelloSchema = z7.object({
-  protocol: z7.number().int().positive(),
-  version: z7.string().min(1),
+var RunnerHelloSchema = z8.object({
+  protocol: z8.number().int().positive(),
+  version: z8.string().min(1),
   os: RunnerOsSchema,
-  clis: z7.array(CliKindSchema),
+  clis: z8.array(CliKindSchema),
   /** The CLIs whose adapter can keep a session warm between turns. */
-  residentClis: z7.array(CliKindSchema).default([]),
+  residentClis: z8.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can take input into a running turn; the server steers only these. */
-  steerableClis: z7.array(CliKindSchema).default([]),
+  steerableClis: z8.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can stop a running turn; the server stops only these. */
-  stoppableClis: z7.array(CliKindSchema).default([]),
+  stoppableClis: z8.array(CliKindSchema).default([]),
   /** Whether the runner answers file reads on its projects' branches; one from before never does. */
-  branchReads: z7.boolean().default(false),
+  branchReads: z8.boolean().default(false),
   /** Whether the runner lists what a branch changed; one from before never does. */
-  branchChanges: z7.boolean().default(false),
-  capabilities: z7.array(z7.string()).default([]),
+  branchChanges: z8.boolean().default(false),
+  /** Whether the runner answers a read of a CLI's quota; one from before never does. */
+  quotaReads: z8.boolean().default(false),
+  capabilities: z8.array(z8.string()).default([]),
+  /**
+   * What the runner's account lacks of the git identity citizens' own commits carry, checked
+   * before each hello outside any repository; empty when it has both. Absent from a runner from
+   * before the check, which no default fills in, so the board marks only what a runner reported.
+   */
+  gitIdentityMissing: z8.array(GitIdentityPartSchema).optional(),
   /** Turns the runner runs at once, or null for no limit. */
-  slots: z7.number().int().positive().nullable(),
+  slots: z8.number().int().positive().nullable(),
   /** Turns the runner is still running, when it registers again; the server fails the rest of its turns. */
-  turns: z7.array(UlidSchema).default([])
+  turns: z8.array(UlidSchema).default([])
 });
-var RunnerWelcomeSchema = z7.object({ name: NameSchema, version: z7.string() });
-var RunnerEnrollRequestSchema = z7.object({
-  protocol: z7.number().int().positive(),
-  version: z7.string().min(1).max(64),
-  hostname: z7.string().min(1).max(253),
+var RunnerWelcomeSchema = z8.object({ name: NameSchema, version: z8.string() });
+var RunnerEnrollRequestSchema = z8.object({
+  protocol: z8.number().int().positive(),
+  version: z8.string().min(1).max(64),
+  hostname: z8.string().min(1).max(253),
   os: RunnerOsSchema,
-  clis: z7.array(CliKindSchema).max(8),
-  capabilities: z7.array(z7.string().min(1).max(64)).max(32).default([])
+  clis: z8.array(CliKindSchema).max(8),
+  capabilities: z8.array(z8.string().min(1).max(64)).max(32).default([])
 });
-var RunnerEnrollmentSchema = z7.object({
-  deviceCode: z7.string().min(1),
-  userCode: z7.string().min(1),
+var RunnerEnrollmentSchema = z8.object({
+  deviceCode: z8.string().min(1),
+  userCode: z8.string().min(1),
   expiresAt: IsoDateTimeSchema,
-  intervalMs: z7.number().int().positive()
+  intervalMs: z8.number().int().positive()
 });
-var RunnerEnrollPollSchema = z7.object({ deviceCode: z7.string().min(1) });
-var RunnerEnrollStatusSchema = z7.discriminatedUnion("status", [
-  z7.object({ status: z7.literal("pending") }),
-  z7.object({ status: z7.literal("approved"), name: NameSchema, token: z7.string().min(1) }),
-  z7.object({ status: z7.literal("denied") })
+var RunnerEnrollPollSchema = z8.object({ deviceCode: z8.string().min(1) });
+var RunnerEnrollStatusSchema = z8.discriminatedUnion("status", [
+  z8.object({ status: z8.literal("pending") }),
+  z8.object({ status: z8.literal("approved"), name: NameSchema, token: z8.string().min(1) }),
+  z8.object({ status: z8.literal("denied") })
 ]);
-var PendingEnrollmentSchema = z7.object({
-  userCode: z7.string().min(1),
-  hostname: z7.string(),
+var PendingEnrollmentSchema = z8.object({
+  userCode: z8.string().min(1),
+  hostname: z8.string(),
   os: RunnerOsSchema,
-  clis: z7.array(CliKindSchema),
-  capabilities: z7.array(z7.string()),
-  version: z7.string(),
+  clis: z8.array(CliKindSchema),
+  capabilities: z8.array(z8.string()),
+  version: z8.string(),
   requestedAt: IsoDateTimeSchema,
   expiresAt: IsoDateTimeSchema
 });
-var ProjectRepoSchema = z7.object({
+var ProjectRepoSchema = z8.object({
   slug: NameSchema,
-  origin: z7.string().nullable(),
-  defaultBranch: z7.string().min(1),
+  origin: z8.string().nullable(),
+  defaultBranch: z8.string().min(1),
   /**
    * The board lands finished tasks on the default branch, itself or through their pull requests,
    * so the runner lets nothing else move it.
    */
-  boardLands: z7.boolean()
+  boardLands: z8.boolean()
 });
 function projectRepo(project) {
   return {
@@ -1342,29 +1479,29 @@ function projectRepo(project) {
     boardLands: project.onDone !== "none"
   };
 }
-var TurnWorkspaceSchema = z7.discriminatedUnion("kind", [
-  z7.object({
-    kind: z7.literal("home"),
+var TurnWorkspaceSchema = z8.discriminatedUnion("kind", [
+  z8.object({
+    kind: z8.literal("home"),
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  z7.object({
-    kind: z7.literal("project"),
+  z8.object({
+    kind: z8.literal("project"),
     repo: ProjectRepoSchema,
-    branches: z7.array(z7.string().min(1)),
+    branches: z8.array(z8.string().min(1)),
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  z7.object({ kind: z7.literal("task"), repo: ProjectRepoSchema, taskId: UlidSchema })
+  z8.object({ kind: z8.literal("task"), repo: ProjectRepoSchema, taskId: UlidSchema })
 ]);
-var TurnJobSchema = z7.object({
+var TurnJobSchema = z8.object({
   turnId: UlidSchema,
   agent: NameSchema,
   role: NameSchema,
   cli: CliKindSchema,
-  model: z7.string().optional(),
+  model: z8.string().optional(),
   /** The reasoning effort set on the agent; absent for the model's own default. */
-  effort: z7.string().optional(),
+  effort: z8.string().optional(),
   /** A project slug, or the society scope. */
   scope: NameSchema,
   /** The thread whose conversation the turn is in; absent for the home conversation. */
@@ -1375,125 +1512,130 @@ var TurnJobSchema = z7.object({
    * The session to resume, or null to start one: the CLI's adapter picks a fresh session's id, and
    * the outcome reports it.
    */
-  session: z7.string().min(1).nullable(),
+  session: z8.string().min(1).nullable(),
   /** The running total the session reported after its last turn, which a resumed session starts from. */
-  costSoFarUsd: z7.number().nonnegative(),
+  costSoFarUsd: z8.number().nonnegative(),
   /** The rendered charter, norms, memory core, and skills index, with `PATH_TOKENS` for places. */
-  instructions: z7.string(),
-  prompt: z7.string(),
-  mcp: z7.object({ url: z7.string().min(1), token: z7.string().min(1) }),
-  limits: z7.object({
-    timeoutMs: z7.number().int().positive().nullable(),
-    maxTurns: z7.number().int().positive().nullable()
+  instructions: z8.string(),
+  prompt: z8.string(),
+  mcp: z8.object({ url: z8.string().min(1), token: z8.string().min(1) }),
+  limits: z8.object({
+    timeoutMs: z8.number().int().positive().nullable(),
+    maxTurns: z8.number().int().positive().nullable()
   }),
   /** Present when the runner keeps the conversation's session warm between turns, under `key`. */
-  resident: z7.object({ key: z7.string().min(1), idleMs: z7.number().int().positive() }).optional(),
+  resident: z8.object({ key: z8.string().min(1), idleMs: z8.number().int().positive() }).optional(),
   workspace: TurnWorkspaceSchema
 });
-var TurnWorkSchema = z7.object({ branch: z7.string().min(1), head: z7.string().min(1) });
-var TurnEventsSchema = z7.object({ entries: z7.array(TranscriptEntrySchema) });
-var TurnOutcomeSchema = z7.object({
+var TurnWorkSchema = z8.object({ branch: z8.string().min(1), head: z8.string().min(1) });
+var TurnEventsSchema = z8.object({ entries: z8.array(TranscriptEntrySchema) });
+var TurnOutcomeSchema = z8.object({
   exitReason: TurnExitReasonSchema,
   status: TurnStatusSchema.nullable(),
-  error: z7.string().nullable(),
+  error: z8.string().nullable(),
   usage: UsageSchema,
-  costUsd: z7.number().nonnegative(),
+  costUsd: z8.number().nonnegative(),
   /** The session's running total after this turn, for CLIs that report one. */
-  sessionCostUsd: z7.number().nonnegative().optional(),
+  sessionCostUsd: z8.number().nonnegative().optional(),
   /** The session the CLI used, which differs from the job's for CLIs that assign their own ids. */
-  session: z7.string().min(1),
+  session: z8.string().min(1),
   /** The model the CLI reported, when it reported one. */
-  model: z7.string().nullable(),
+  model: z8.string().nullable(),
   work: TurnWorkSchema.nullable(),
   /**
    * Whether the turn's own workspace, a thread's, a channel's, or a task's, holds work on no
    * branch after the hand-back: uncommitted changes, or commits no branch contains.
    */
-  leftovers: z7.boolean().default(false)
+  leftovers: z8.boolean().default(false),
+  /**
+   * The CLI's plan quota as the turn's stream last reported it, when it reported any; a runner from
+   * before never sends it.
+   */
+  quota: CliQuotaSchema.optional()
 });
-var TurnAckSchema = z7.object({ dropWorkspace: z7.boolean() });
-var LandRequestSchema = z7.object({
+var TurnAckSchema = z8.object({ dropWorkspace: z8.boolean() });
+var LandRequestSchema = z8.object({
   repo: ProjectRepoSchema,
-  branch: z7.string().min(1),
+  branch: z8.string().min(1),
   /**
    * For a `ghpr` task, the pull request to merge in place of the branch, which must hold the
    * branch's files, and the merge commit's subject and body, the pull request's title and an
    * empty body when left out.
    */
-  pullRequest: z7.object({
-    url: z7.string().min(1),
-    subject: z7.string().min(1).optional(),
-    body: z7.string().optional()
+  pullRequest: z8.object({
+    url: z8.string().min(1),
+    subject: z8.string().min(1).optional(),
+    body: z8.string().optional()
   }).optional()
 });
-var CloseRequestSchema = z7.object({
+var CloseRequestSchema = z8.object({
   repo: ProjectRepoSchema,
-  url: z7.string().min(1),
-  comment: z7.string().min(1)
+  url: z8.string().min(1),
+  comment: z8.string().min(1)
 });
-var MergeOutcomeSchema = z7.object({ ok: z7.boolean(), detail: z7.string() });
-var ModelListSchema = z7.array(ModelOptionSchema);
+var MergeOutcomeSchema = z8.object({ ok: z8.boolean(), detail: z8.string() });
+var ModelListSchema = z8.array(ModelOptionSchema);
 var BRANCH_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var BranchPathSchema = z7.string().max(4096).refine((value) => value === "" || value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".." && !segment.includes("\0")), { message: "a path inside the branch, with no empty, `.`, or `..` segment" });
-var BranchNameSchema = z7.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/);
-var BranchReadSchema = z7.object({
+var BranchPathSchema = z8.string().max(4096).refine((value) => value === "" || value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".." && !segment.includes("\0")), { message: "a path inside the branch, with no empty, `.`, or `..` segment" });
+var BranchNameSchema = z8.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/);
+var BranchReadSchema = z8.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema,
   path: BranchPathSchema
 });
-var BranchCommitSchema = z7.object({
-  id: z7.string().min(1),
+var BranchCommitSchema = z8.object({
+  id: z8.string().min(1),
   at: IsoDateTimeSchema,
-  author: z7.string()
+  author: z8.string()
 });
-var BranchFileSchema = z7.discriminatedUnion("kind", [
-  z7.object({
-    kind: z7.literal("file"),
+var BranchFileSchema = z8.discriminatedUnion("kind", [
+  z8.object({
+    kind: z8.literal("file"),
     path: BranchPathSchema,
     commit: BranchCommitSchema,
-    size: z7.number().int().nonnegative(),
-    content: z7.string().nullable()
+    size: z8.number().int().nonnegative(),
+    content: z8.string().nullable()
   }),
-  z7.object({
-    kind: z7.literal("dir"),
+  z8.object({
+    kind: z8.literal("dir"),
     path: BranchPathSchema,
     commit: BranchCommitSchema,
-    entries: z7.array(z7.object({
-      name: z7.string().min(1),
-      kind: z7.enum(["file", "dir"]),
-      size: z7.number().int().nonnegative().nullable()
+    entries: z8.array(z8.object({
+      name: z8.string().min(1),
+      kind: z8.enum(["file", "dir"]),
+      size: z8.number().int().nonnegative().nullable()
     }))
   })
 ]);
-var BranchChangesReadSchema = z7.object({
+var BranchChangesReadSchema = z8.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema
 });
-var BranchFileChangeSchema = z7.object({
-  path: z7.string().min(1),
-  status: z7.enum(["added", "modified", "deleted"]),
+var BranchFileChangeSchema = z8.object({
+  path: z8.string().min(1),
+  status: z8.enum(["added", "modified", "deleted"]),
   /** Lines added and removed, or null for a binary file. */
-  added: z7.number().int().nonnegative().nullable(),
-  removed: z7.number().int().nonnegative().nullable(),
+  added: z8.number().int().nonnegative().nullable(),
+  removed: z8.number().int().nonnegative().nullable(),
   /** Absent when the file changed only through a merge of another branch. */
-  lastChange: z7.object({ author: z7.string(), at: IsoDateTimeSchema }).optional()
+  lastChange: z8.object({ author: z8.string(), at: IsoDateTimeSchema }).optional()
 });
-var BranchChangesSchema = z7.object({
+var BranchChangesSchema = z8.object({
   head: BranchCommitSchema,
-  files: z7.array(BranchFileChangeSchema),
-  total: z7.number().int().nonnegative()
+  files: z8.array(BranchFileChangeSchema),
+  total: z8.number().int().nonnegative()
 });
-var BranchDiffReadSchema = z7.object({
+var BranchDiffReadSchema = z8.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema,
   path: BranchPathSchema.min(1)
 });
-var BranchFileDiffSchema = z7.object({
+var BranchFileDiffSchema = z8.object({
   head: BranchCommitSchema,
   path: BranchPathSchema,
   status: BranchFileChangeSchema.shape.status,
-  patch: z7.string().nullable(),
-  truncated: z7.boolean()
+  patch: z8.string().nullable(),
+  truncated: z8.boolean()
 });
 function patchHunks(patch, limit2) {
   if (/^Binary files .* differ$/m.test(patch)) {
@@ -1507,9 +1649,9 @@ function patchHunks(patch, limit2) {
   const cut = hunks.lastIndexOf("\n", limit2);
   return { patch: hunks.slice(0, cut === -1 ? limit2 : cut), truncated: true };
 }
-var WorkspaceConversationSchema = z7.discriminatedUnion("kind", [
-  z7.object({ kind: z7.literal("thread"), id: UlidSchema }),
-  z7.object({ kind: z7.literal("channel"), scope: NameSchema, name: NameSchema })
+var WorkspaceConversationSchema = z8.discriminatedUnion("kind", [
+  z8.object({ kind: z8.literal("thread"), id: UlidSchema }),
+  z8.object({ kind: z8.literal("channel"), scope: NameSchema, name: NameSchema })
 ]);
 function workspaceConversationOf(turn) {
   if (turn.thread !== void 0) {
@@ -1517,60 +1659,65 @@ function workspaceConversationOf(turn) {
   }
   return turn.channel === void 0 ? null : { kind: "channel", scope: turn.scope, name: turn.channel };
 }
-var HeldWorkspaceSchema = z7.object({
+var HeldWorkspaceSchema = z8.object({
   agent: NameSchema,
   scope: NameSchema,
   conversation: WorkspaceConversationSchema
 });
-var HeldWorkspacesSchema = z7.object({ workspaces: z7.array(HeldWorkspaceSchema) });
-var SweepResultSchema = z7.object({ kept: z7.array(HeldWorkspaceSchema) });
-var TurnSteerSchema = z7.object({ id: z7.uuid(), text: z7.string().min(1) });
-var RunnerMessageSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("turn"), job: TurnJobSchema }),
-  z7.object({ type: z7.literal("land"), request: z7.string().min(1), land: LandRequestSchema }),
+var HeldWorkspacesSchema = z8.object({ workspaces: z8.array(HeldWorkspaceSchema) });
+var SweepResultSchema = z8.object({ kept: z8.array(HeldWorkspaceSchema) });
+var TurnSteerSchema = z8.object({ id: z8.uuid(), text: z8.string().min(1) });
+var RunnerMessageSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("turn"), job: TurnJobSchema }),
+  z8.object({ type: z8.literal("land"), request: z8.string().min(1), land: LandRequestSchema }),
   /** Answered with a `MergeOutcome`. */
-  z7.object({ type: z7.literal("close"), request: z7.string().min(1), close: CloseRequestSchema }),
-  z7.object({ type: z7.literal("models"), request: z7.string().min(1), cli: CliKindSchema }),
+  z8.object({ type: z8.literal("close"), request: z8.string().min(1), close: CloseRequestSchema }),
+  z8.object({ type: z8.literal("models"), request: z8.string().min(1), cli: CliKindSchema }),
+  /**
+   * Answered with a `CliQuota` read from the CLI without a turn, or null when its adapter cannot
+   * read one. Sent only to runners whose hello says `quotaReads`.
+   */
+  z8.object({ type: z8.literal("quota"), request: z8.string().min(1), cli: CliKindSchema }),
   /** Answered with a `BranchFile`, or null when the branch or the path does not exist. */
-  z7.object({ type: z7.literal("file"), request: z7.string().min(1), read: BranchReadSchema }),
+  z8.object({ type: z8.literal("file"), request: z8.string().min(1), read: BranchReadSchema }),
   /** Answered with `BranchChanges`, or null when the repository or the branch does not exist. */
-  z7.object({
-    type: z7.literal("changes"),
-    request: z7.string().min(1),
+  z8.object({
+    type: z8.literal("changes"),
+    request: z8.string().min(1),
     read: BranchChangesReadSchema
   }),
   /** Answered with a `BranchFileDiff`, or null when the branch does not exist or left the path alone. */
-  z7.object({ type: z7.literal("diff"), request: z7.string().min(1), read: BranchDiffReadSchema }),
+  z8.object({ type: z8.literal("diff"), request: z8.string().min(1), read: BranchDiffReadSchema }),
   /** Answered with whether the CLI accepted it; that it took it comes as a `steered` event. */
-  z7.object({
-    type: z7.literal("steer"),
-    request: z7.string().min(1),
+  z8.object({
+    type: z8.literal("steer"),
+    request: z8.string().min(1),
     turnId: UlidSchema,
     steer: TurnSteerSchema
   }),
   /** Answered with whether the turn was there to stop; it ends `stopped`. */
-  z7.object({ type: z7.literal("stop"), request: z7.string().min(1), turnId: UlidSchema }),
+  z8.object({ type: z8.literal("stop"), request: z8.string().min(1), turnId: UlidSchema }),
   /**
    * A conversation ended: the runner removes every citizen's workspace for it but those a turn
    * still uses, and answers with a `SweepResult` naming those it kept for holding work on no branch.
    */
-  z7.object({
-    type: z7.literal("sweep"),
-    request: z7.string().min(1),
+  z8.object({
+    type: z8.literal("sweep"),
+    request: z8.string().min(1),
     conversation: WorkspaceConversationSchema
   })
 ]);
-var RunnerAnswerSchema = z7.discriminatedUnion("ok", [
-  z7.object({ ok: z7.literal(true), value: z7.unknown() }),
-  z7.object({ ok: z7.literal(false), error: z7.string() })
+var RunnerAnswerSchema = z8.discriminatedUnion("ok", [
+  z8.object({ ok: z8.literal(true), value: z8.unknown() }),
+  z8.object({ ok: z8.literal(false), error: z8.string() })
 ]);
-var WarmSessionsSchema = z7.object({ warm: z7.array(z7.string()) });
-var FileManifestSchema = z7.object({ files: z7.record(z7.string(), z7.string()) });
+var WarmSessionsSchema = z8.object({ warm: z8.array(z8.string()) });
+var FileManifestSchema = z8.object({ files: z8.record(z8.string(), z8.string()) });
 function fileVersion(sha, executable) {
   return executable ? `${sha}+x` : sha;
 }
-var FileReadSchema = z7.object({ paths: z7.array(z7.string()) });
-var FileContentsSchema = z7.object({ files: z7.record(z7.string(), z7.string()) });
+var FileReadSchema = z8.object({ paths: z8.array(z8.string()) });
+var FileContentsSchema = z8.object({ files: z8.record(z8.string(), z8.string()) });
 function isSafeRelativePath(file) {
   if (file.length === 0 || file.startsWith("/") || file.includes("\\") || file.includes("\0")) {
     return false;
@@ -1579,7 +1726,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z8.enum([
+var TriggerKindSchema = z9.enum([
   "mention",
   "stage",
   "task_done",
@@ -1593,11 +1740,11 @@ var TriggerKindSchema = z8.enum([
   "closing",
   "cron"
 ]);
-var TriggerSchema = z8.object({
+var TriggerSchema = z9.object({
   kind: TriggerKindSchema,
   from: NameSchema.optional(),
-  fromUser: z8.boolean().default(false),
-  reason: z8.string().default(""),
+  fromUser: z9.boolean().default(false),
+  reason: z9.string().default(""),
   taskId: UlidSchema.optional(),
   messageId: UlidSchema.optional(),
   /** The channel the waking message was posted in. */
@@ -1605,17 +1752,17 @@ var TriggerSchema = z8.object({
   /** The cron that came due, for a `cron` wake. */
   cronId: UlidSchema.optional()
 });
-var TurnThreadSchema = z8.object({ id: UlidSchema, task: z8.boolean() });
-var TurnDispatchSchema = z8.object({
+var TurnThreadSchema = z9.object({ id: UlidSchema, task: z9.boolean() });
+var TurnDispatchSchema = z9.object({
   agent: NameSchema,
   project: NameSchema,
   thread: TurnThreadSchema.optional(),
   channel: NameSchema.optional(),
   trigger: TriggerSchema,
-  priority: z8.number().int().min(0).max(2),
-  onboarding: z8.boolean().default(false),
+  priority: z9.number().int().min(0).max(2),
+  onboarding: z9.boolean().default(false),
   /** Every cron that came due for this turn, whatever wake it merged into; its prompt quotes each. */
-  crons: z8.array(UlidSchema).optional()
+  crons: z9.array(UlidSchema).optional()
 });
 function conversationPart(conversation) {
   return conversation.thread ?? (conversation.channel === void 0 ? void 0 : `#${conversation.channel}`);
@@ -1639,7 +1786,7 @@ function channelConversation(scope, channel) {
   const name = at < 0 ? channel : channel.slice(at + 1);
   return place === scope && name !== "general" ? name : void 0;
 }
-var TurnRecordSchema = z8.object({
+var TurnRecordSchema = z9.object({
   /** Assigned by the board when the turn begins; the turn's transcript is filed under it. */
   id: UlidSchema.optional(),
   agent: NameSchema,
@@ -1650,31 +1797,31 @@ var TurnRecordSchema = z8.object({
   channel: NameSchema.optional(),
   runner: NameSchema,
   cli: CliKindSchema.nullable(),
-  session: z8.string().nullable(),
+  session: z9.string().nullable(),
   trigger: TriggerSchema,
   startedAt: IsoDateTimeSchema,
   endedAt: IsoDateTimeSchema.nullable(),
   exitReason: TurnExitReasonSchema.nullable(),
   status: TurnStatusSchema.nullable(),
-  error: z8.string().nullable(),
+  error: z9.string().nullable(),
   usage: UsageSchema.nullable(),
-  costUsd: z8.number().nonnegative().default(0),
+  costUsd: z9.number().nonnegative().default(0),
   /**
    * The running total the CLI reported for the session after this turn, when it reports one. A
    * resumed session starts from it, so the next turn's own cost is measured from here.
    */
-  sessionCostUsd: z8.number().nonnegative().optional(),
-  toolCalls: z8.number().int().nonnegative().default(0),
+  sessionCostUsd: z9.number().nonnegative().optional(),
+  toolCalls: z9.number().int().nonnegative().default(0),
   /** The model the CLI reported for this turn, else the model configured for the agent, else null. */
-  model: z8.string().nullable().default(null),
+  model: z9.string().nullable().default(null),
   /** The task branch the turn left work on, with its commit, as the runner reported it. */
   work: TurnWorkSchema.optional(),
   /** Who stopped the turn, for one that ended `stopped`. */
   stoppedBy: NameSchema.optional(),
   /** The crons whose fire started the turn, which record how it ended. */
-  crons: z8.array(UlidSchema).optional()
+  crons: z9.array(UlidSchema).optional()
 });
-var RunningTurnSchema = z8.object({
+var RunningTurnSchema = z9.object({
   turnId: UlidSchema,
   agent: NameSchema,
   scope: NameSchema,
@@ -1682,49 +1829,49 @@ var RunningTurnSchema = z8.object({
   channel: NameSchema.optional(),
   cli: CliKindSchema,
   askedIn: ChannelRefSchema.optional(),
-  steerable: z8.boolean(),
-  stoppable: z8.boolean()
+  steerable: z9.boolean(),
+  stoppable: z9.boolean()
 });
-var SessionsFileSchema = z8.object({
-  claude: z8.string().optional(),
-  codex: z8.string().optional(),
+var SessionsFileSchema = z9.object({
+  claude: z9.string().optional(),
+  codex: z9.string().optional(),
   runner: NameSchema.optional()
 });
-var WakeRequestSchema = z8.object({
+var WakeRequestSchema = z9.object({
   agent: NameSchema,
   project: NameSchema,
-  reason: z8.string().default("manual wake"),
+  reason: z9.string().default("manual wake"),
   /** A manual wake, or a reflection turn requested ahead of the cadence. */
-  kind: z8.enum(["manual", "reflection"]).default("manual")
+  kind: z9.enum(["manual", "reflection"]).default("manual")
 });
-var TurnHistoryEntrySchema = z8.object({
+var TurnHistoryEntrySchema = z9.object({
   /** The id of the event that ended the turn. */
   id: UlidSchema,
   /** The turn's own id, when it has a transcript to open; turns before transcripts have none. */
   turnId: UlidSchema.optional(),
   ts: IsoDateTimeSchema,
-  outcome: z8.enum(["completed", "failed"]),
+  outcome: z9.enum(["completed", "failed"]),
   /** A project slug, or the society scope. */
   project: NameSchema,
   /** The thread whose conversation the turn was in; absent for the home conversation. */
   thread: UlidSchema.optional(),
   /** The channel, never general, whose conversation the turn was in. */
   channel: NameSchema.optional(),
-  trigger: z8.string(),
-  exitReason: z8.string().nullable(),
-  costUsd: z8.number(),
+  trigger: z9.string(),
+  exitReason: z9.string().nullable(),
+  costUsd: z9.number(),
   /** The tokens the turn used; absent for turns logged before turns recorded them. */
   usage: UsageSchema.optional(),
-  model: z8.string().nullable(),
-  summary: z8.string().nullable(),
-  error: z8.string().nullable(),
+  model: z9.string().nullable(),
+  summary: z9.string().nullable(),
+  error: z9.string().nullable(),
   /** When the log recorded the turn's start; absent when the start is missing from the log. */
   startedAt: IsoDateTimeSchema.optional(),
-  toolCalls: z8.number().int().nonnegative().optional()
+  toolCalls: z9.number().int().nonnegative().optional()
 });
 
 // packages/shared/dist/ops.js
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var OPS_SIGNAL_KINDS = [
   "waiting_stage",
   "backlog",
@@ -1740,7 +1887,7 @@ var OPS_SIGNAL_KINDS = [
   "stuck_workspace",
   "cron_failing"
 ];
-var OpsSignalKindSchema = z9.enum(OPS_SIGNAL_KINDS);
+var OpsSignalKindSchema = z10.enum(OPS_SIGNAL_KINDS);
 var WAKING_SIGNAL_KINDS = [
   "backlog",
   "role_gap",
@@ -1750,15 +1897,15 @@ var WAKING_SIGNAL_KINDS = [
   "blocked_capability",
   "scaled"
 ];
-var OpsSignalSchema = z9.object({
+var OpsSignalSchema = z10.object({
   kind: OpsSignalKindSchema,
   /** Identifies the condition, for example `backlog:demo:engineer`, so a persisting one is not logged again every pass. */
-  key: z9.string().min(1),
+  key: z10.string().min(1),
   /** One line a reader can act on. */
-  summary: z9.string().min(1),
+  summary: z10.string().min(1),
   /** The counter or timer value behind the signal. */
-  value: z9.number(),
-  threshold: z9.number().optional(),
+  value: z10.number(),
+  threshold: z10.number().optional(),
   project: NameSchema.optional(),
   agent: NameSchema.optional(),
   role: NameSchema.optional(),
@@ -1766,8 +1913,8 @@ var OpsSignalSchema = z9.object({
 });
 
 // packages/shared/dist/metrics.js
-import { z as z10 } from "zod";
-var MetricsWindowSchema = z10.enum(["24h", "7d", "all"]);
+import { z as z11 } from "zod";
+var MetricsWindowSchema = z11.enum(["24h", "7d", "all"]);
 var METRICS_WINDOW_MS = {
   "24h": 24 * 36e5,
   "7d": 7 * 24 * 36e5,
@@ -1778,9 +1925,9 @@ function isBoardAction(tool) {
   const verb = /^mcp__board__(.+)$/.exec(tool)?.[1];
   return verb !== void 0 && !READ_VERBS.some((read2) => read2 === verb);
 }
-var CountSchema = z10.number().int().nonnegative();
-var MsSchema = z10.number().nonnegative();
-var MetricsSchema = z10.object({
+var CountSchema = z11.number().int().nonnegative();
+var MsSchema = z11.number().nonnegative();
+var MetricsSchema = z11.object({
   window: MetricsWindowSchema,
   since: IsoDateTimeSchema.nullable(),
   until: IsoDateTimeSchema,
@@ -1788,12 +1935,12 @@ var MetricsSchema = z10.object({
    * Finished turns that changed nothing on the board. Reflections are left out, since they write
    * memory, not the board; turns without a transcript are counted apart, their actions unknown.
    */
-  idle: z10.object({
+  idle: z11.object({
     turns: CountSchema,
     idle: CountSchema,
     unknown: CountSchema,
-    byTrigger: z10.array(z10.object({ trigger: z10.string(), turns: CountSchema, idle: CountSchema })),
-    byAgent: z10.array(z10.object({
+    byTrigger: z11.array(z11.object({ trigger: z11.string(), turns: CountSchema, idle: CountSchema })),
+    byAgent: z11.array(z11.object({
       agent: NameSchema,
       role: NameSchema.nullable(),
       turns: CountSchema,
@@ -1801,33 +1948,33 @@ var MetricsSchema = z10.object({
     }))
   }),
   /** Work sent back to an earlier stage: over the tasks finished in the window, and by where. */
-  sentBack: z10.object({
+  sentBack: z11.object({
     finished: CountSchema,
     sendBacks: CountSchema,
     tasksSentBack: CountSchema,
-    byStage: z10.array(z10.object({ project: NameSchema, stage: z10.string(), count: CountSchema })),
-    bySender: z10.array(z10.object({ agent: NameSchema, count: CountSchema }))
+    byStage: z11.array(z11.object({ project: NameSchema, stage: z11.string(), count: CountSchema })),
+    bySender: z11.array(z11.object({ agent: NameSchema, count: CountSchema }))
   }),
   /** Posts in the threads of the tasks finished in the window, the board's own notices left out. */
-  messages: z10.object({
+  messages: z11.object({
     finished: CountSchema,
     messages: CountSchema,
-    byProject: z10.array(z10.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
-    busiest: z10.array(z10.object({
+    byProject: z11.array(z11.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
+    busiest: z11.array(z11.object({
       taskId: UlidSchema,
-      title: z10.string(),
+      title: z11.string(),
       project: NameSchema,
       messages: CountSchema
     }))
   }),
   /** Time from a mention to the start of the turn it woke, in the conversation it was made in. */
-  latency: z10.object({
+  latency: z11.object({
     mentions: CountSchema,
     /** Mentions no turn has followed yet. */
     unanswered: CountSchema,
     medianMs: MsSchema.nullable(),
     slowestMs: MsSchema.nullable(),
-    byAgent: z10.array(z10.object({
+    byAgent: z11.array(z11.object({
       agent: NameSchema,
       mentions: CountSchema,
       medianMs: MsSchema,
@@ -1835,61 +1982,73 @@ var MetricsSchema = z10.object({
     }))
   }),
   /** The user's decisions: proposals decided, questions answered, and stages passed or sent back. */
-  decisions: z10.object({
+  decisions: z11.object({
     total: CountSchema,
-    byDay: z10.array(z10.object({
-      day: z10.string(),
+    byDay: z11.array(z11.object({
+      day: z11.string(),
       proposals: CountSchema,
       answers: CountSchema,
       stages: CountSchema
     }))
   }),
   /** Tasks that needed a capability no connected runner offered, and whether they still do. */
-  blocked: z10.array(z10.object({
+  blocked: z11.array(z11.object({
     taskId: UlidSchema,
-    title: z10.string().nullable(),
+    title: z11.string().nullable(),
     project: NameSchema.nullable(),
-    summary: z10.string(),
+    summary: z11.string(),
     firstAt: IsoDateTimeSchema,
     lastAt: IsoDateTimeSchema,
-    holds: z10.boolean()
+    holds: z11.boolean()
   }))
 });
+var CitizenTokensSchema = z11.object({
+  agent: NameSchema,
+  turns: CountSchema,
+  withUsage: CountSchema,
+  usage: UsageSchema.nullable()
+});
+var TokenUseSchema = z11.object({
+  window: MetricsWindowSchema,
+  since: IsoDateTimeSchema.nullable(),
+  until: IsoDateTimeSchema,
+  citizens: z11.array(CitizenTokensSchema)
+});
 
 // packages/shared/dist/config.js
-import { z as z11 } from "zod";
-var LogLevelSchema = z11.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
-var GithubSignInSchema = z11.object({
-  clientId: z11.string().min(1),
-  clientSecret: z11.string().min(1),
+import { z as z12 } from "zod";
+var LogLevelSchema = z12.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
+var GithubSignInSchema = z12.object({
+  clientId: z12.string().min(1),
+  clientSecret: z12.string().min(1),
   /** Logins, lowercased; GitHub logins are case-insensitive. */
-  users: z11.array(z11.string().min(1)).min(1)
+  users: z12.array(z12.string().min(1)).min(1)
 });
-var ServerConfigSchema = z11.object({
-  dataDir: z11.string().min(1),
-  host: z11.string().min(1),
-  port: z11.number().int().positive().max(65535),
+var ServerConfigSchema = z12.object({
+  dataDir: z12.string().min(1),
+  host: z12.string().min(1),
+  port: z12.number().int().positive().max(65535),
   /**
    * An address every runner's agents reach this server at, for example https://board.example, or
    * null for each runner to use the address it reaches the server at itself.
    */
-  publicUrl: z11.string().min(1).nullable(),
+  publicUrl: z12.string().min(1).nullable(),
   logLevel: LogLevelSchema,
   /** Turns running at once across every runner, or null for no limit beyond each runner's own. */
-  concurrency: z11.number().int().positive().nullable(),
+  concurrency: z12.number().int().positive().nullable(),
   /** How long one turn may run before it is stopped, or null for no limit. */
-  turnTimeoutMs: z11.number().int().positive().nullable(),
+  turnTimeoutMs: z12.number().int().positive().nullable(),
   /** Rounds of tool calls one Claude turn may take, or null for no limit. */
-  toolRounds: z11.number().int().positive().nullable(),
+  toolRounds: z12.number().int().positive().nullable(),
   /** How long a resident session stays warm after its last turn. */
-  residentIdleMs: z11.number().int().positive(),
+  residentIdleMs: z12.number().int().positive(),
   /** Signing in to the board with GitHub, or null when only a token lets anyone in. */
   github: GithubSignInSchema.nullable(),
   /**
    * Reverse proxies in front of the server whose X-Forwarded-For entries name the client, for the
    * rate limits on what anyone may ask without a token: 0 when clients connect directly.
    */
-  trustedProxies: z11.number().int().min(0).max(16)
+  trustedProxies: z12.number().int().min(0).max(16)
 });
 function limit(value, fallback) {
   if (value === void 0 || value.trim() === "") {
@@ -1927,25 +2086,73 @@ function loadServerConfig(env) {
     trustedProxies: Number(env["STELLARIS_TRUSTED_PROXIES"] ?? "0")
   });
 }
-var RunnerConfigSchema = z11.object({
+var RunnerConfigSchema = z12.object({
   /** The board server, for example http://127.0.0.1:4700. */
-  serverUrl: z11.string().url(),
+  serverUrl: z12.string().url(),
   /**
    * The runner's token, from `runner add`, or null for the one it saved when it was enrolled, or
    * to enroll it.
    */
-  token: z11.string().min(1).nullable(),
+  token: z12.string().min(1).nullable(),
   /** The runner's own data directory: the board mirror, agent homes, repositories, worktrees. */
-  dataDir: z11.string().min(1),
+  dataDir: z12.string().min(1),
   logLevel: LogLevelSchema,
   /** Turns this machine runs at once, or null for no limit. */
-  slots: z11.number().int().positive().nullable(),
-  clis: z11.array(CliKindSchema).min(1),
-  capabilities: z11.array(z11.string())
+  slots: z12.number().int().positive().nullable(),
+  clis: z12.array(CliKindSchema).min(1),
+  capabilities: z12.array(z12.string())
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.21";
+var STELLARIS_VERSION = "0.3.22";
+
+// packages/shared/dist/mentions.js
+import { parse, postprocess, preprocess } from "micromark";
+import { gfm } from "micromark-extension-gfm";
+var MENTION_PATTERN = /(^|[^\w@])@([a-z0-9][a-z0-9-]{0,31})(?![\w-])/g;
+var CODE = /* @__PURE__ */ new Set(["codeText", "codeFenced", "codeIndented"]);
+var SLOW = {
+  disable: {
+    null: [
+      "wwwAutolink",
+      "protocolAutolink",
+      "emailAutolink",
+      "gfmFootnoteCall",
+      "gfmPotentialFootnoteCall"
+    ]
+  }
+};
+function codeRanges(markdown) {
+  const shift = markdown.startsWith("\uFEFF") ? 1 : 0;
+  const events = postprocess(parse({ extensions: [gfm(), SLOW] }).document().write(preprocess()(markdown, void 0, true)));
+  return events.flatMap(([kind, token]) => kind === "enter" && CODE.has(token.type) ? [[token.start.offset + shift, token.end.offset + shift]] : []);
+}
+function addMentions(found, text) {
+  for (const match of text.matchAll(MENTION_PATTERN)) {
+    const name = match[2];
+    if (name !== void 0) {
+      found.add(name);
+    }
+  }
+}
+function mentionsIn(markdown) {
+  if (markdown.search(MENTION_PATTERN) === -1) {
+    return [];
+  }
+  const found = /* @__PURE__ */ new Set();
+  let from = 0;
+  for (const [start, end] of codeRanges(markdown)) {
+    addMentions(found, markdown.slice(from, start));
+    from = end;
+  }
+  addMentions(found, markdown.slice(from));
+  return [...found].toSorted();
+}
+function mentionsAnywhere(text) {
+  const found = /* @__PURE__ */ new Set();
+  addMentions(found, text);
+  return [...found].toSorted();
+}
 
 // packages/board-core/dist/errors.js
 var BoardError = class extends Error {
@@ -2591,33 +2798,59 @@ function filesOf(lines, status) {
   return [...files.values()];
 }
 
+// packages/board-core/dist/mentions.js
+import vm from "node:vm";
+var MENTION_PARSE_MS = 500;
+var context = vm.createContext({});
+var call = new vm.Script("work()");
+function within(work, ms) {
+  let result;
+  context["work"] = () => {
+    result = work();
+  };
+  try {
+    call.runInContext(context, { timeout: ms });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
+      return void 0;
+    }
+    throw error;
+  } finally {
+    context["work"] = void 0;
+  }
+  return result;
+}
+function postMentions(body) {
+  return within(() => mentionsIn(body), MENTION_PARSE_MS) ?? mentionsAnywhere(body);
+}
+
 // packages/board-core/dist/metrics.js
-import { z as z12 } from "zod";
-var TurnPayload = z12.object({
-  turnId: z12.string().optional(),
-  project: z12.string(),
-  thread: z12.string().optional(),
-  channel: z12.string().optional(),
-  trigger: z12.string()
+import { z as z13 } from "zod";
+var TurnPayload = z13.object({
+  turnId: z13.string().optional(),
+  project: z13.string(),
+  thread: z13.string().optional(),
+  channel: z13.string().optional(),
+  trigger: z13.string()
 });
-var TaskPayload = z12.object({
-  taskId: z12.string(),
-  project: z12.string(),
-  from: z12.string().optional()
+var TaskPayload = z13.object({
+  taskId: z13.string(),
+  project: z13.string(),
+  from: z13.string().optional()
 });
-var MessagePayload = z12.object({
-  id: z12.string().optional(),
-  channel: z12.string(),
-  thread: z12.string().nullable().optional(),
-  mentions: z12.array(z12.string()).default([])
+var MessagePayload = z13.object({
+  id: z13.string().optional(),
+  channel: z13.string(),
+  thread: z13.string().nullable().optional(),
+  mentions: z13.array(z13.string()).default([])
 });
-var SteeredPayload = z12.object({ messages: z12.array(z12.string()) });
-var SignalPayload = z12.object({
-  kind: z12.string(),
-  key: z12.string(),
-  summary: z12.string(),
-  taskId: z12.string().optional(),
-  project: z12.string().optional()
+var SteeredPayload = z13.object({ messages: z13.array(z13.string()) });
+var SignalPayload = z13.object({
+  kind: z13.string(),
+  key: z13.string(),
+  summary: z13.string(),
+  taskId: z13.string().optional(),
+  project: z13.string().optional()
 });
 function median(values) {
   const sorted = values.toSorted((a, b) => a - b);
@@ -2906,6 +3139,59 @@ function computeMetrics(input) {
   };
 }
 
+// packages/board-core/dist/turn-history.js
+import { z as z14 } from "zod";
+var TurnHistoryPayloadSchema = z14.object({
+  project: NameSchema,
+  thread: UlidSchema.optional(),
+  channel: NameSchema.optional(),
+  trigger: z14.string().default("manual"),
+  exitReason: z14.string().nullable().default(null),
+  costUsd: z14.number().default(0),
+  usage: UsageSchema.optional(),
+  model: z14.string().nullable().default(null),
+  summary: z14.string().nullable().default(null),
+  error: z14.string().nullable().default(null),
+  toolCalls: z14.number().int().nonnegative().optional(),
+  turnId: UlidSchema.optional()
+});
+function tokenUse(events, window, now) {
+  const span = METRICS_WINDOW_MS[window];
+  const since = span === null ? null : now.getTime() - span;
+  const rows = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "turn.completed" && event.type !== "turn.failed") {
+      continue;
+    }
+    if (since !== null && Date.parse(event.ts) < since) {
+      continue;
+    }
+    const turn = TurnHistoryPayloadSchema.safeParse(event.payload);
+    if (!turn.success) {
+      continue;
+    }
+    const row = rows.get(event.actor) ?? {
+      agent: event.actor,
+      turns: 0,
+      withUsage: 0,
+      usage: null
+    };
+    const usage = turn.data.usage;
+    rows.set(event.actor, {
+      agent: event.actor,
+      turns: row.turns + 1,
+      withUsage: row.withUsage + (usage === void 0 ? 0 : 1),
+      usage: usage === void 0 ? row.usage : row.usage === null ? usage : addUsage(row.usage, usage)
+    });
+  }
+  return {
+    window,
+    since: since === null ? null : new Date(since).toISOString(),
+    until: now.toISOString(),
+    citizens: [...rows.values()].toSorted((a, b) => a.agent.localeCompare(b.agent))
+  };
+}
+
 // packages/board-core/dist/mutex.js
 var Mutex = class {
   tail = Promise.resolve();
@@ -3147,41 +3433,27 @@ function namesList(names) {
   return names.length <= 1 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names.at(-1) ?? ""}`;
 }
 var SKIPPED_IN_HOME = /* @__PURE__ */ new Set([".git", "turns", ".claude", ".codex"]);
-var RunnerTokensSchema = z13.object({
-  runners: z13.record(z13.string(), z13.object({ tokenHash: z13.string().min(1) }))
+var RunnerTokensSchema = z15.object({
+  runners: z15.record(z15.string(), z15.object({ tokenHash: z15.string().min(1) }))
 });
-var SignInsSchema = z13.object({
-  signIns: z13.array(z13.object({
-    tokenHash: z13.string().min(1),
-    login: z13.string().min(1),
+var SignInsSchema = z15.object({
+  signIns: z15.array(z15.object({
+    tokenHash: z15.string().min(1),
+    login: z15.string().min(1),
     /** The account's picture at the identity provider; sign-ins from before it have none. */
-    avatarUrl: z13.url().optional(),
+    avatarUrl: z15.url().optional(),
     createdAt: IsoDateTimeSchema,
     expiresAt: IsoDateTimeSchema
   })).default([])
 });
-var TurnHistoryPayloadSchema = z13.object({
-  project: NameSchema,
-  thread: UlidSchema.optional(),
-  channel: NameSchema.optional(),
-  trigger: z13.string().default("manual"),
-  exitReason: z13.string().nullable().default(null),
-  costUsd: z13.number().default(0),
-  usage: UsageSchema.optional(),
-  model: z13.string().nullable().default(null),
-  summary: z13.string().nullable().default(null),
-  error: z13.string().nullable().default(null),
-  toolCalls: z13.number().int().nonnegative().optional(),
-  turnId: UlidSchema.optional()
-});
-var TurnStartPayloadSchema = z13.object({ project: NameSchema, turnId: UlidSchema.optional() });
-var CursorsSchema = z13.object({
-  digest: z13.string().nullable(),
-  scopes: z13.record(z13.string(), z13.string()).default({}),
-  threadsFrom: z13.record(z13.string(), z13.string().nullable()).default({}),
-  channelsFrom: z13.record(z13.string(), z13.string().nullable()).default({}),
+var TurnStartPayloadSchema = z15.object({ project: NameSchema, turnId: UlidSchema.optional() });
+var CursorsSchema = z15.object({
+  digest: z15.string().nullable(),
+  scopes: z15.record(z15.string(), z15.string()).default({}),
+  threadsFrom: z15.record(z15.string(), z15.string().nullable()).default({}),
+  channelsFrom: z15.record(z15.string(), z15.string().nullable()).default({}),
   /** How far a work role has read news, which goes to whichever of its general conversations reads first. */
-  news: z13.string().optional()
+  news: z15.string().optional()
 });
 var NO_CURSORS = { digest: null, scopes: {}, threadsFrom: {}, channelsFrom: {} };
 function conversationKey(scope, part) {
@@ -3220,9 +3492,8 @@ function byId(a, b) {
 function turnTime(record) {
   return record.endedAt ?? record.startedAt;
 }
-var PausedSchema = z13.object({ paused: z13.boolean() });
+var PausedSchema = z15.object({ paused: z15.boolean() });
 var DEFAULT_LEASE_MS = 30 * 60 * 1e3;
-var MENTION_PATTERN = /(^|[^\w@])@([a-z0-9][a-z0-9-]{0,31})(?![\w-])/g;
 function withoutMentions(text) {
   return text.replaceAll(MENTION_PATTERN, "$1$2");
 }
@@ -3246,7 +3517,7 @@ var OPS_WAKE_TRIGGER = "ops_event";
 var FRONT_DESK_TRIGGER = "user_post";
 var OPS_CHANNELS = ["governance"];
 var FRONT_DESK_CHANNELS = [ASK_CHANNEL];
-var AlignmentsSchema = z13.object({ applied: z13.array(z13.string()).default([]) });
+var AlignmentsSchema = z15.object({ applied: z15.array(z15.string()).default([]) });
 var FOLLOW_DECISIONS = "ops-readers-follow-decisions";
 var THREAD_RECORDS = "threads-as-records";
 var DIGEST_CURSORS = "digest-replaces-inbox";
@@ -3260,10 +3531,10 @@ var CHANNEL_CONVERSATIONS = "channel-conversations";
 var DASHBOARD_UPDATES = "dashboard-updates-granted";
 var CRON_VERBS = "cron-verbs-granted";
 var KNOWLEDGE_NOTICES = "knowledge-notices";
-var KnowledgeEventSchema = z13.object({
+var KnowledgeEventSchema = z15.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
-  replaced: z13.boolean().optional()
+  replaced: z15.boolean().optional()
 });
 var CRON_VERB_NAMES = ["create_cron", "update_cron", "remove_cron"];
 var OLD_DASHBOARD_LINE = "Agents may edit this file. It is rendered by the board UI.";
@@ -3381,16 +3652,6 @@ function unanswered(messages) {
   }
   return waiting;
 }
-function extractMentions(body) {
-  const found = /* @__PURE__ */ new Set();
-  for (const match of body.matchAll(MENTION_PATTERN)) {
-    const name = match[2];
-    if (name !== void 0) {
-      found.add(name);
-    }
-  }
-  return [...found].toSorted();
-}
 function snippetAround(text, query, radius = 80) {
   const index = text.toLowerCase().indexOf(query.toLowerCase());
   if (index === -1) {
@@ -3718,7 +3979,7 @@ var Board = class _Board {
         }
       }
       for (const file of await listFiles(this.paths.tasks(slug))) {
-        const raw = await readMarkdown(path6.join(this.paths.tasks(slug), file), z13.record(z13.string(), z13.unknown()));
+        const raw = await readMarkdown(path6.join(this.paths.tasks(slug), file), z15.record(z15.string(), z15.unknown()));
         const legacy = raw.data["thread"];
         if (legacy === void 0) {
           continue;
@@ -3796,7 +4057,7 @@ var Board = class _Board {
    * turns, so it follows nothing now.
    */
   async renameInboxCursors() {
-    const Legacy = z13.object({ inbox: z13.string().nullable() });
+    const Legacy = z15.object({ inbox: z15.string().nullable() });
     for (const agent of await this.listAgents()) {
       const file = this.paths.agentCursors(agent.name);
       if (await exists(file)) {
@@ -3842,7 +4103,7 @@ ${charter.purpose}
    */
   async alignSeedRole(seed) {
     const file = this.paths.role(seed.name);
-    const raw = await readMarkdown(file, z13.record(z13.string(), z13.unknown()));
+    const raw = await readMarkdown(file, z15.record(z15.string(), z15.unknown()));
     const current = RoleCharterSchema.parse(raw.data);
     const verbsAdded = seed.verbs.filter((verb) => !current.verbs.includes(verb));
     const fieldsAligned = RoleCharterSchema.keyof().options.filter((key) => key === "verbs" || seed[key] === void 0 ? false : seed.name === USER_ROLE ? JSON.stringify(seed[key]) !== JSON.stringify(current[key]) : !(key in raw.data));
@@ -4159,7 +4420,7 @@ ${charter.purpose}
   /** The society's norms, the one knowledge topic every turn loads. Empty until the steward writes it. */
   async readSocietyNorms() {
     const file = this.paths.societyKnowledgeFile("norms");
-    return await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
   }
   /** Knowledge topics of a project, or of the society when the project is null. */
   async listKnowledge(project) {
@@ -4179,7 +4440,7 @@ ${charter.purpose}
    */
   async knowledgeAt(file, project, topic) {
     const { data, body } = await readLooseMarkdown(file);
-    const revision = z13.number().int().min(0).safeParse(data["revision"]);
+    const revision = z15.number().int().min(0).safeParse(data["revision"]);
     const updatedBy = NameSchema.safeParse(data["updatedBy"]);
     const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
     return {
@@ -4512,8 +4773,11 @@ ${DASHBOARD_LINE}
         throw new BoardError("NOT_FOUND", `runner ${name} not found`);
       }
       const doc = await readMarkdown(file, RunnerSchema);
+      const { gitIdentityMissing: reported, ...rest } = doc.data;
+      const gitIdentityMissing = patch.gitIdentityMissing === void 0 ? reported : patch.gitIdentityMissing ?? void 0;
       const next = RunnerSchema.parse({
-        ...doc.data,
+        ...rest,
+        ...gitIdentityMissing === void 0 ? {} : { gitIdentityMissing: [...gitIdentityMissing] },
         ...patch.status === void 0 ? {} : { status: patch.status },
         ...patch.os === void 0 ? {} : { os: patch.os },
         ...patch.clis === void 0 ? {} : { clis: [...patch.clis] },
@@ -4541,6 +4805,36 @@ ${DASHBOARD_LINE}
       return next;
     });
   }
+  /**
+   * Records a CLI's plan quota as a runner reported it, from a turn's stream or a read, merged over
+   * what the record held. The record is written on every report, so it says when the numbers were
+   * last seen; `runner.quota` is appended only when what a reader would see changes, since every
+   * turn reports.
+   */
+  async recordQuota(name, cli, quota) {
+    return this.mutex.run(async () => {
+      const file = this.paths.runner(name);
+      if (!await exists(file)) {
+        throw new BoardError("NOT_FOUND", `runner ${name} not found`);
+      }
+      const doc = await readMarkdown(file, RunnerSchema);
+      const previous = doc.data.quotas?.[cli];
+      const merged = mergeQuota(previous, quota);
+      const next = RunnerSchema.parse({
+        ...doc.data,
+        quotas: { ...doc.data.quotas, [cli]: merged }
+      });
+      await writeMarkdown(file, next, doc.body);
+      if (quotaChanged(previous, merged)) {
+        await this.events.append("runner.quota", SYSTEM_ACTOR.name, {
+          name,
+          cli,
+          status: merged.status
+        });
+      }
+      return next;
+    });
+  }
   /**
    * Logs an operations signal as an `ops.signal` event. No channel carries it: the scheduler wakes
    * its readers from the event, the runner lists it in their prompts, and the interface's log shows
@@ -6375,7 +6669,7 @@ ${rationale}`}`);
   }
   async readAgentRoleBody(agent) {
     const file = this.paths.agentRole(agent);
-    return await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
   }
   /** The steps of one finished turn, as the runner handed them over when it ended. */
   /**
@@ -6406,6 +6700,14 @@ ${rationale}`}`);
     }
     return computeMetrics({ events, tasks, citizens, actions, activeSignals, window, now });
   }
+  /**
+   * Each citizen's finished turns over a window and the tokens of those that counted them, from
+   * the event log alone, which holds every turn's end whatever runner it ran on.
+   */
+  async tokenUse(window) {
+    const events = await this.events.readSince(null, Number.MAX_SAFE_INTEGER);
+    return tokenUse(events, window, this.now());
+  }
   /** The board actions a finished turn took, from its transcript; null when it kept none. */
   async turnActions(agent, turnId) {
     const known = this.actionCounts.get(turnId);
@@ -6775,7 +7077,7 @@ ${rationale}`}`);
       return { project: slug, revision: 0, body: "" };
     }
     const { data, body } = await readLooseMarkdown(file);
-    const revision = z13.number().int().min(0).safeParse(data["revision"]);
+    const revision = z15.number().int().min(0).safeParse(data["revision"]);
     const updatedBy = NameSchema.safeParse(data["updatedBy"]);
     const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
     return {
@@ -7066,7 +7368,7 @@ ${seed}
         continue;
       }
       const file = this.paths.agentRole(agent.name);
-      const body = await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
+      const body = await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
       const at = body.indexOf(`
 ${SEED_INSTRUCTIONS_HEADING}
 `);
@@ -7904,7 +8206,7 @@ ${charter.purpose}
       id: this.newId(),
       ...head,
       ts: this.now().toISOString(),
-      mentions: extractMentions(body)
+      mentions: postMentions(body)
     });
     const { author } = head;
     await writeMarkdown(this.paths.messageFile(dir, frontmatter.id, author), frontmatter, body);
@@ -8282,7 +8584,7 @@ function decideWake(input) {
 }
 
 // packages/scheduler/dist/scheduler.js
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 function besideFields(beside) {
   if (beside === void 0) {
     return {};
@@ -8309,21 +8611,21 @@ var DEFAULT_TIMINGS = Object.freeze({
   scaleCooldownMs: 36e5,
   reflectionMs: 24 * 36e5
 });
-var SchedulerTimingsSchema = z14.object({
-  pollMs: z14.number().positive(),
-  debounceMs: z14.number().nonnegative(),
-  userDebounceMs: z14.number().nonnegative(),
-  heartbeatMs: z14.number().positive(),
-  waitingStageMs: z14.number().positive(),
-  leaseSweepMs: z14.number().positive(),
-  opsIntervalMs: z14.number().positive(),
-  signalRepeatMs: z14.number().positive(),
-  costReportMs: z14.number().positive(),
-  staleThreadMs: z14.number().positive(),
-  idleMemberMs: z14.number().positive(),
-  homeConflictMs: z14.number().positive(),
-  scaleCooldownMs: z14.number().positive(),
-  reflectionMs: z14.number().positive()
+var SchedulerTimingsSchema = z16.object({
+  pollMs: z16.number().positive(),
+  debounceMs: z16.number().nonnegative(),
+  userDebounceMs: z16.number().nonnegative(),
+  heartbeatMs: z16.number().positive(),
+  waitingStageMs: z16.number().positive(),
+  leaseSweepMs: z16.number().positive(),
+  opsIntervalMs: z16.number().positive(),
+  signalRepeatMs: z16.number().positive(),
+  costReportMs: z16.number().positive(),
+  staleThreadMs: z16.number().positive(),
+  idleMemberMs: z16.number().positive(),
+  homeConflictMs: z16.number().positive(),
+  scaleCooldownMs: z16.number().positive(),
+  reflectionMs: z16.number().positive()
 }).partial();
 function parseTimings(input) {
   const parsed = SchedulerTimingsSchema.parse(input);
@@ -8335,32 +8637,32 @@ function parseTimings(input) {
   }
   return overrides;
 }
-var PendingSchema = z14.object({
+var PendingSchema = z16.object({
   dispatch: TurnDispatchSchema,
-  readyAt: z14.number(),
-  stageWakes: z14.array(TriggerSchema).optional(),
-  holder: z14.boolean().optional(),
+  readyAt: z16.number(),
+  stageWakes: z16.array(TriggerSchema).optional(),
+  holder: z16.boolean().optional(),
   newestMessage: UlidSchema.optional(),
-  onlyMessages: z14.boolean().optional(),
+  onlyMessages: z16.boolean().optional(),
   steeredThrough: UlidSchema.optional(),
-  onlyCrons: z14.boolean().optional()
+  onlyCrons: z16.boolean().optional()
 });
-var StateSchema = z14.object({
-  cursor: z14.string().nullable(),
-  lastHeartbeat: z14.record(z14.string(), z14.string()),
+var StateSchema = z16.object({
+  cursor: z16.string().nullable(),
+  lastHeartbeat: z16.record(z16.string(), z16.string()),
   /** Waiting stages already signalled, as `task:stage`, so each is logged once while it waits. */
-  waitingSeen: z14.record(z14.string(), z14.string()).default({}),
+  waitingSeen: z16.record(z16.string(), z16.string()).default({}),
   /** Queued dispatches survive a restart; the cursor has already moved past the events that made them. */
-  pending: z14.record(z14.string(), PendingSchema).default({}),
-  opsReported: z14.record(z14.string(), z14.string()).default({}),
-  releaseCounts: z14.record(z14.string(), z14.number().int().nonnegative()).default({}),
-  lastOps: z14.string().nullable().default(null),
-  lastScaled: z14.record(z14.string(), z14.string()).default({}),
-  lastCostReport: z14.string().nullable().default(null),
-  costSinceReport: z14.number().nonnegative().default(0),
-  turnsSinceReport: z14.number().int().nonnegative().default(0),
+  pending: z16.record(z16.string(), PendingSchema).default({}),
+  opsReported: z16.record(z16.string(), z16.string()).default({}),
+  releaseCounts: z16.record(z16.string(), z16.number().int().nonnegative()).default({}),
+  lastOps: z16.string().nullable().default(null),
+  lastScaled: z16.record(z16.string(), z16.string()).default({}),
+  lastCostReport: z16.string().nullable().default(null),
+  costSinceReport: z16.number().nonnegative().default(0),
+  turnsSinceReport: z16.number().int().nonnegative().default(0),
   /** When each member last reflected, or was first seen; the cadence counts from here. */
-  lastReflection: z14.record(z14.string(), z14.string()).default({})
+  lastReflection: z16.record(z16.string(), z16.string()).default({})
 });
 function messageOf(trigger) {
   return trigger.kind === "mention" || trigger.kind === "user_post" ? trigger.messageId : void 0;
@@ -9933,7 +10235,7 @@ var TURN_CONTRACT = [
   "- Posts that would wake this conversation may arrive while you work, delivered into the turn under a heading that says so and formatted like the digest. They are part of this turn: act on them now, after the step in hand, or not at all, as with the digest. The user may also stop a turn; the next turn is told.",
   "- Silence is allowed. If the digest needs no reply, post nothing.",
   "- To come back to something later, set a cron with create_cron: a note on what to do then, and a five-field cron expression or one time with at. It wakes you in this conversation unless you name another, at most every fifteen minutes, and every fire is a paid turn, so end a cron with remove_cron once it has done its job. Never wait by holding a stage, sleeping, or leaving a process running: a turn's board token ends with the turn, so nothing it leaves behind can act on the board. The society's crons are under society/crons/ in the board projection.",
-  "- An @mention wakes the citizen named, and every wake costs a turn. Address someone with @ only when you need them to act; when you merely refer to citizens, write their names plainly. @user wakes nobody, since the user takes no turns; it is what puts a question before the user, so use it only when you need the user to answer or decide.",
+  "- An @mention wakes the citizen named, and every wake costs a turn. Address someone with @ only when you need them to act; when you merely refer to citizens, write their names plainly. A name in a code span or a code block is no mention, so code keeps its @ as written. @user wakes nobody, since the user takes no turns; it is what puts a question before the user, so use it only when you need the user to answer or decide.",
   "- A thread is a conversation off a channel that reaches only its participants and whoever is mentioned in it. Every task has one, opened with it under the task's id on the channel of its project it was filed in, general unless it was filed in another: talk about a task there, with post_message and its thread_id, and the notes you give advance_task and update_task are posted there as you. Its participants are the task's creator, its stage holders and assignees, whoever may take the stage that waits, and anyone who posted; it closes when the task ends. Every proposal has one too, in governance, opened with its pitch and closed by its decision. Open other threads with open_thread on a channel with a title, for any other topic; close_thread posts your summary to its channel.",
   "- To show an image in a post, such as a screenshot or a chart, commit the file to a task's branch and link it by its path in the task's worktree, as `![what it shows](<path>)`: the board shows a file on a task's branch in place once it is committed, at the latest when your turn ends. An image at an https address shows too. Never put an image or any other file into a message as base64 or a data: URL: the board does not show it, and every reader of the conversation gets it in full in their prompt.",
   "- Route every lesson: about you, your craft, or the user, write it to memory/core.md in your home directory, and keep that file short by moving detail to memory/<topic>.md, your archive; a durable fact about a project's codebase or process goes through `write_knowledge` on that project; something the whole project should know now, post it to the project channel, and anything about one task, in the task's thread.",
@@ -9967,15 +10269,15 @@ var GOVERNANCE = [
   "- Prefer scaling an existing role over inventing one, with a reallocation of its replicas, backlog threshold, wakes, or verbs; a new role is justified by work a project needs that no existing role covers. A role that needs a tool the board lacks is an engineering task, not a hiring request.",
   "- Operations signals are counters and timers the board logs, listed in the prompt of a role that reads them: stages waiting for a holder, backlog per role, stages waiting on a role nobody fills, churn, stale threads, idle members, missing capabilities, replicas added, spend. They are not posts in any channel; interpreting them is your judgment."
 ].join("\n");
-function renderOnboardingPreamble(context) {
+function renderOnboardingPreamble(context2) {
   return [
-    `This is your first turn as ${context.agentName}.`,
+    `This is your first turn as ${context2.agentName}.`,
     "",
-    `Your role in one paragraph: ${context.roleSummary}`,
+    `Your role in one paragraph: ${context2.roleSummary}`,
     "",
-    `You are working on project "${context.project}" in the worktree at ${context.worktree}.`,
-    ...(context.otherChannels ?? []).length === 0 ? [] : [
-      `You follow its general channel. It also has ${(context.otherChannels ?? []).map((ref) => `#${ref}`).join(", ")}, each a workstream such as a release: subscribe to one when your work there needs its posts. Its tasks and mentions reach you either way.`
+    `You are working on project "${context2.project}" in the worktree at ${context2.worktree}.`,
+    ...(context2.otherChannels ?? []).length === 0 ? [] : [
+      `You follow its general channel. It also has ${(context2.otherChannels ?? []).map((ref) => `#${ref}`).join(", ")}, each a workstream such as a release: subscribe to one when your work there needs its posts. Its tasks and mentions reach you either way.`
     ],
     "Your memory is empty. Write durable lessons about yourself, your craft, or the user to memory/core.md in your home directory.",
     "Write profile.md in your home directory: one paragraph on what you do well and what to send your way. The roster the front desk routes with is built from it.",
@@ -10061,10 +10363,25 @@ function signalLine(ts, signal) {
   ].filter((fact) => fact.length > 0);
   return `- [${ts}] ${signal.kind}: ${signal.summary} (${facts.join("; ")})`;
 }
-function runnerLine(runner, projects) {
+function quotaPhrase(cli, quota, now) {
+  const level = quotaLevel(quota, now);
+  if (level === "none") {
+    return `${cli} reports no plan limits`;
+  }
+  if (level === "limited") {
+    return `${cli} limited until ${quota.limitedUntil ?? "an unknown time"}`;
+  }
+  const windows = quota.windows.map((window) => !windowCurrent(window, now) ? `${windowName(window)} reset since` : `${windowName(window)} ${window.usedPercent === null ? "?" : Math.floor(window.usedPercent)}%`);
+  return `${cli} ${windows.length === 0 ? "allowed" : windows.join(", ")}${level === "warning" ? " (near a limit)" : ""} as of ${quota.observedAt}`;
+}
+function runnerLine(runner, projects, now) {
   const living = projects.filter((project) => project.runner === runner.name).map((project) => project.slug);
   const state = runner.status === "connected" ? "connected" : `away${runner.lastSeen === void 0 ? "" : ` since ${runner.lastSeen}`}`;
-  return `- ${runner.name}: ${state}; ${runner.os}; CLIs ${runner.clis.length === 0 ? "none" : runner.clis.join(", ")}; offers ${runner.capabilities.length === 0 ? "nothing beyond its CLIs" : runner.capabilities.join(", ")}; ${living.length === 0 ? "no projects" : `projects ${living.join(", ")}`}`;
+  const quotas = runner.clis.flatMap((cli) => {
+    const quota = runner.quotas?.[cli];
+    return quota === void 0 ? [] : [quotaPhrase(cli, quota, now)];
+  });
+  return `- ${runner.name}: ${state}; ${runner.os}; CLIs ${runner.clis.length === 0 ? "none" : runner.clis.join(", ")}; offers ${runner.capabilities.length === 0 ? "nothing beyond its CLIs" : runner.capabilities.join(", ")}; ${living.length === 0 ? "no projects" : `projects ${living.join(", ")}`}${quotas.length === 0 ? "" : `; quota ${quotas.join("; ")}`}`;
 }
 function profileLine(profile) {
   const line = profile.split("\n").map((entry) => entry.trim()).find((entry) => entry.length > 0 && !entry.startsWith("#"));
@@ -10214,12 +10531,12 @@ function buildTurnPrompt(input) {
   }
   const machines = input.runners;
   if (machines !== void 0 && machines !== null) {
-    lines.push("", "## Runners", "", "The machines turns run on. A project lives on the runner that takes its first turn, one that offers every capability the project and that turn's task require, and never moves. A task's required_capabilities must name capabilities exactly as a runner below offers them; a task needing one its project's runner lacks waits.", "");
+    lines.push("", "## Runners", "", "The machines turns run on. A project lives on the runner that takes its first turn, one that offers every capability the project and that turn's task require, and never moves. A task's required_capabilities must name capabilities exactly as a runner below offers them; a task needing one its project's runner lacks waits. A runner's quota is what each CLI's login there last reported of its plan, in percent of each window; a CLI limited until a time fails its turns there until then.", "");
     if (machines.runners.length === 0) {
       lines.push("None registered yet.");
     }
     for (const runner of machines.runners) {
-      lines.push(runnerLine(runner, machines.projects));
+      lines.push(runnerLine(runner, machines.projects, input.clock?.now ?? /* @__PURE__ */ new Date()));
     }
   }
   const knowledge = input.knowledge;
@@ -10752,6 +11069,11 @@ var TurnHost = class {
         }
       }
     });
+    if (outcome.quota !== void 0) {
+      await this.board.recordQuota(turn.runner, job.cli, outcome.quota).catch((error) => {
+        this.log.warn({ runner: turn.runner, cli: job.cli, error: String(error) }, "could not record a quota");
+      });
+    }
     if (recorded) {
       this.log.info({
         agent: job.agent,
@@ -11081,7 +11403,8 @@ var RunnerHub = class {
       os: hello.os,
       clis: hello.clis,
       capabilities: hello.capabilities,
-      version: hello.version
+      version: hello.version,
+      gitIdentityMissing: hello.gitIdentityMissing ?? null
     });
     this.runnerChanged(name);
     this.log.info({ runner: name, version: hello.version, clis: hello.clis, slots: hello.slots }, "runner registered");
@@ -11523,6 +11846,26 @@ var RunnerHub = class {
     }
     return ModelListSchema.parse(await this.request(seat, (request) => ({ type: "models", request, cli })));
   }
+  /**
+   * A CLI's plan quota, read on a runner without a turn and recorded on the runner's record.
+   * Refused for a runner not connected with the CLI, and for one from before quota reads, which
+   * would skip the request and leave the reader waiting.
+   */
+  async quota(runner, cli) {
+    const seat = this.seats.get(runner);
+    if (seat === void 0 || seat.send === null || !seat.hello.clis.includes(cli)) {
+      throw new RunnerAwayError(`runner ${runner} is not connected with ${cli}`);
+    }
+    if (!seat.hello.quotaReads) {
+      throw new BoardError("INVALID_STATE", `runner ${runner} cannot read quotas yet; upgrade it`);
+    }
+    const quota = CliQuotaSchema.nullable().parse(await this.request(seat, (request) => ({ type: "quota", request, cli }), FILE_TIMEOUT_MS));
+    if (quota === null) {
+      throw new BoardError("NOT_FOUND", `${cli} on runner ${runner} cannot read its quota`);
+    }
+    await this.board.recordQuota(runner, cli, quota);
+    return quota;
+  }
   /** Calls `listener` whenever a runner registers, connects, or goes away. */
   onRunnerChange(listener) {
     this.runnerListeners.add(listener);
@@ -11755,20 +12098,20 @@ async function handleMcpRequest(board2, actor, request, version) {
 import { Hono as Hono3 } from "hono";
 import { compress } from "hono/compress";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { z as z16, ZodError } from "zod";
+import { z as z18, ZodError } from "zod";
 
 // apps/server/dist/github-auth.js
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { Hono } from "hono";
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var SIGN_IN_TTL_MS = 30 * 24 * 36e5;
 var STATE_TTL_MS = 10 * 6e4;
 var MAX_STATES = 1e3;
-var TokenAnswerSchema = z15.object({ access_token: z15.string().min(1) });
-var GithubUserSchema = z15.object({
-  login: z15.string().min(1),
-  id: z15.number().int(),
-  avatar_url: z15.string().optional()
+var TokenAnswerSchema = z17.object({ access_token: z17.string().min(1) });
+var GithubUserSchema = z17.object({
+  login: z17.string().min(1),
+  id: z17.number().int(),
+  avatar_url: z17.string().optional()
 });
 function githubAvatar(url) {
   try {
@@ -12191,7 +12534,7 @@ async function isFile(file) {
     return false;
   }
 }
-function within(root, pathname) {
+function within2(root, pathname) {
   let decoded;
   try {
     decoded = decodeURIComponent(pathname);
@@ -12208,7 +12551,7 @@ function spaHandler(staticDir) {
     if (pathname.startsWith("/api/")) {
       return c.json({ error: "NOT_FOUND", message: `no route ${pathname}` }, 404);
     }
-    const file = within(root, pathname);
+    const file = within2(root, pathname);
     const headers = { "x-content-type-options": "nosniff" };
     if (file !== null && await isFile(file)) {
       return c.body(await readFile5(file), 200, {
@@ -12243,19 +12586,19 @@ var ERROR_STATUS = {
   INVALID_STATE: 409
 };
 var EVENT_PAGE = 100;
-var RetireBodySchema = z16.object({ reason: z16.string().min(1) });
-var RunnerBodySchema = z16.object({ name: NameSchema });
-var EnrollmentApprovalSchema = z16.object({ name: NameSchema });
-var HomeRunnerBodySchema = z16.object({ runner: NameSchema.nullable() });
-var ModelBodySchema = z16.object({ model: ModelNameSchema.nullable() });
-var EffortBodySchema = z16.object({ effort: EffortSchema.nullable() });
-var HistoryLimitSchema = z16.coerce.number().int().min(1).max(500);
-var MessageIdsSchema = z16.string().transform((ids) => ids.split(",").filter((id) => id !== "")).pipe(z16.array(UlidSchema).min(1).max(MESSAGE_LOOKUP_LIMIT));
-var TimezoneBodySchema = z16.object({ timezone: TimeZoneSchema });
-var ChannelBodySchema = z16.object({
+var RetireBodySchema = z18.object({ reason: z18.string().min(1) });
+var RunnerBodySchema = z18.object({ name: NameSchema });
+var EnrollmentApprovalSchema = z18.object({ name: NameSchema });
+var HomeRunnerBodySchema = z18.object({ runner: NameSchema.nullable() });
+var ModelBodySchema = z18.object({ model: ModelNameSchema.nullable() });
+var EffortBodySchema = z18.object({ effort: EffortSchema.nullable() });
+var HistoryLimitSchema = z18.coerce.number().int().min(1).max(500);
+var MessageIdsSchema = z18.string().transform((ids) => ids.split(",").filter((id) => id !== "")).pipe(z18.array(UlidSchema).min(1).max(MESSAGE_LOOKUP_LIMIT));
+var TimezoneBodySchema = z18.object({ timezone: TimeZoneSchema });
+var ChannelBodySchema = z18.object({
   project: NameSchema.nullable().default(null),
   name: NameSchema,
-  purpose: z16.string().min(1)
+  purpose: z18.string().min(1)
 });
 function bearer2(c) {
   const header = c.req.header("authorization") ?? "";
@@ -12263,7 +12606,7 @@ function bearer2(c) {
   return match?.[1]?.trim() ?? null;
 }
 function createApp(deps) {
-  const { board: board2, version, turns: turns2, scheduler: scheduler2, models } = deps;
+  const { board: board2, version, turns: turns2, scheduler: scheduler2, models, quotas } = deps;
   const eventStreamPingMs = deps.eventStreamPingMs ?? 15e3;
   const app2 = new Hono3();
   app2.get("/health", (c) => c.json({ ok: true, version }));
@@ -12333,6 +12676,17 @@ function createApp(deps) {
   api.get("/agents/:name/history/:commit", async (c) => c.json(await board2.homeChange(c.req.param("name"), c.req.param("commit"))));
   api.get("/roles", async (c) => c.json(await board2.listRoles()));
   api.get("/runners", async (c) => c.json(await board2.listRunners()));
+  api.post("/runners/:name/quota/:cli", async (c) => {
+    if (c.get("actor").role !== USER_ROLE) {
+      throw new BoardError("FORBIDDEN", "only the user reads a runner's quota");
+    }
+    const runner = NameSchema.parse(c.req.param("name"));
+    const cli = CliKindSchema.parse(c.req.param("cli"));
+    if (quotas === void 0) {
+      throw new RunnerAwayError("this server asks no runner for quotas");
+    }
+    return c.json(await quotas.read(runner, cli));
+  });
   api.post("/runners", async (c) => {
     const body = RunnerBodySchema.parse(await c.req.json());
     return c.json(await board2.addRunner(c.get("actor"), body.name));
@@ -12369,6 +12723,10 @@ function createApp(deps) {
     const window = MetricsWindowSchema.parse(c.req.query("window") ?? "7d");
     return c.json(await board2.metrics(window, new Set(scheduler2?.activeSignals ?? [])));
   });
+  api.get("/tokens", async (c) => {
+    const window = MetricsWindowSchema.parse(c.req.query("window") ?? "24h");
+    return c.json(await board2.tokenUse(window));
+  });
   api.get("/society/knowledge", async (c) => c.json(await board2.listKnowledge(null)));
   api.get("/skills", async (c) => c.json(await board2.listSocietySkills()));
   api.post("/agents/:name/retire", async (c) => {
@@ -12412,7 +12770,7 @@ function createApp(deps) {
   });
   api.put("/roles/:name", async (c) => {
     const charter = RoleCharterSchema.parse({
-      ...z16.record(z16.string(), z16.unknown()).parse(await c.req.json()),
+      ...z18.record(z18.string(), z18.unknown()).parse(await c.req.json()),
       name: c.req.param("name")
     });
     return c.json(await board2.setRoleCharter(c.get("actor"), charter));
@@ -12762,6 +13120,35 @@ var ModelCatalog = class {
   }
 };
 
+// apps/server/dist/quotas.js
+var MINUTE = 6e4;
+var QuotaReads = class {
+  runners;
+  floorMs;
+  now;
+  kept = /* @__PURE__ */ new Map();
+  constructor(runners2, floorMs = MINUTE, now = Date.now) {
+    this.runners = runners2;
+    this.floorMs = floorMs;
+    this.now = now;
+  }
+  read(runner, cli) {
+    const key = `${runner}/${cli}`;
+    const kept = this.kept.get(key);
+    if (kept !== void 0 && this.now() - kept.at < this.floorMs) {
+      return kept.quota;
+    }
+    const quota = this.runners.quota(runner, cli);
+    this.kept.set(key, { at: this.now(), quota });
+    quota.catch(() => {
+      if (this.kept.get(key)?.quota === quota) {
+        this.kept.delete(key);
+      }
+    });
+    return quota;
+  }
+};
+
 // apps/server/dist/turn-hub.js
 var TurnHub = class {
   capacity;
@@ -12869,6 +13256,7 @@ var app = createApp({
   turns,
   scheduler: view,
   models: new ModelCatalog(runners),
+  quotas: new QuotaReads(runners),
   runners,
   webDir,
   signIn: { github: config.github, log },