@kubitnodes/stellaris 0.3.21 → 0.3.22

package/dist/cli/index.js

@@ -9,7 +9,7 @@ import { Command } from "commander";
 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";
@@ -288,6 +288,79 @@ function describeSchedule(schedule, societyZone) {
   return schedule.timezone === void 0 ? `\`${schedule.cron}\` in the society's time zone, ${societyZone}` : `\`${schedule.cron}\` in ${schedule.timezone}`;
 }
 
+// packages/shared/dist/quota.js
+import { z as z4 } from "zod";
+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 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];
@@ -300,24 +373,24 @@ var SOCIETY_SCOPE = "society";
 function wakeScope(member, project2) {
   return project2 !== null && member.memberships.includes(project2) ? project2 : 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)?$/,
@@ -333,7 +406,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]) };
@@ -341,72 +414,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,
@@ -420,7 +493,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,
@@ -429,16 +502,16 @@ var MessageRefSchema = MessageFrontmatterSchema.pick({
   thread: true,
   ts: true
 });
-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,
@@ -446,28 +519,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,
@@ -476,19 +549,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()
 });
@@ -512,79 +585,90 @@ function mayHoldStage(member, task2) {
   }
   return !(stage.gate && task2.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",
@@ -593,42 +677,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(role2, changes) {
   return {
     ...role2,
@@ -663,18 +747,18 @@ function roleChangeLines(role2, 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,
@@ -777,23 +861,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
 });
@@ -801,79 +885,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,
@@ -885,146 +969,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,
@@ -1043,10 +1127,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. */
@@ -1055,12 +1139,12 @@ 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) })
 };
 
 // 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",
@@ -1105,6 +1189,7 @@ var BOARD_EVENT_TYPES = [
   "user.signed_out",
   "user.token_rotated",
   "runner.changed",
+  "runner.quota",
   "ops.signal",
   "paused.changed",
   "wake.requested",
@@ -1125,28 +1210,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())
-});
-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 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)
-});
-var TurnExitReasonSchema = z6.enum([
+  payload: z7.record(z7.string(), z7.unknown())
+});
+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)
+});
+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 = z7.enum([
   "completed",
   "timeout",
   "error",
@@ -1154,50 +1247,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,
@@ -1209,97 +1302,105 @@ 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 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()
 });
-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. */
@@ -1310,125 +1411,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, limit) {
   if (/^Binary files .* differ$/m.test(patch)) {
@@ -1442,64 +1548,69 @@ function patchHunks(patch, limit) {
   const cut = hunks.lastIndexOf("\n", limit);
   return { patch: hunks.slice(0, cut === -1 ? limit : 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 })
 ]);
-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;
@@ -1508,7 +1619,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z8.enum([
+var TriggerKindSchema = z9.enum([
   "mention",
   "stage",
   "task_done",
@@ -1522,11 +1633,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. */
@@ -1534,17 +1645,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}`);
@@ -1555,7 +1666,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,
@@ -1566,31 +1677,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,
@@ -1598,49 +1709,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",
@@ -1656,16 +1767,16 @@ var OPS_SIGNAL_KINDS = [
   "stuck_workspace",
   "cron_failing"
 ];
-var OpsSignalKindSchema = z9.enum(OPS_SIGNAL_KINDS);
-var OpsSignalSchema = z9.object({
+var OpsSignalKindSchema = z10.enum(OPS_SIGNAL_KINDS);
+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(),
@@ -1673,8 +1784,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,
@@ -1685,9 +1796,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,
@@ -1695,12 +1806,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,
@@ -1708,33 +1819,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,
@@ -1742,81 +1853,141 @@ 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)
 });
-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 {
@@ -2459,33 +2630,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()
-});
-var TaskPayload = z12.object({
-  taskId: z12.string(),
-  project: z12.string(),
-  from: z12.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 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()
+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 = z13.object({
+  taskId: z13.string(),
+  project: z13.string(),
+  from: z13.string().optional()
+});
+var MessagePayload = z13.object({
+  id: z13.string().optional(),
+  channel: z13.string(),
+  thread: z13.string().nullable().optional(),
+  mentions: z13.array(z13.string()).default([])
+});
+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);
@@ -2774,6 +2971,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 turn2 = TurnHistoryPayloadSchema.safeParse(event.payload);
+    if (!turn2.success) {
+      continue;
+    }
+    const row = rows.get(event.actor) ?? {
+      agent: event.actor,
+      turns: 0,
+      withUsage: 0,
+      usage: null
+    };
+    const usage = turn2.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();
@@ -3015,41 +3265,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) {
@@ -3088,9 +3324,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");
 }
@@ -3114,7 +3349,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";
@@ -3128,10 +3363,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.";
@@ -3249,16 +3484,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) {
@@ -3586,7 +3811,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;
@@ -3664,7 +3889,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 agent2 of await this.listAgents()) {
       const file = this.paths.agentCursors(agent2.name);
       if (await exists(file)) {
@@ -3710,7 +3935,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));
@@ -4027,7 +4252,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(project2) {
@@ -4047,7 +4272,7 @@ ${charter.purpose}
    */
   async knowledgeAt(file, project2, 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 {
@@ -4380,8 +4605,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] },
@@ -4409,6 +4637,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
@@ -6243,7 +6501,7 @@ ${rationale}`}`);
   }
   async readAgentRoleBody(agent2) {
     const file = this.paths.agentRole(agent2);
-    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. */
   /**
@@ -6274,6 +6532,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(agent2, turnId) {
     const known = this.actionCounts.get(turnId);
@@ -6643,7 +6909,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 {
@@ -6934,7 +7200,7 @@ ${seed}
         continue;
       }
       const file = this.paths.agentRole(agent2.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}
 `);
@@ -7772,7 +8038,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);