@kubitnodes/stellaris 0.3.20 → 0.3.22

package/dist/server/index.js

@@ -9,7 +9,7 @@ import { serve } from "@hono/node-server";
 import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
 import path6 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // packages/shared/dist/ids.js
 import { z } from "zod";
@@ -146,7 +146,7 @@ var SEED_ROLES = [
   },
   {
     name: "steward",
-    purpose: "Watches the operations signals and the task board for capacity, skill, and capability gaps, and turns signals into proposals: a member when a project's plans need a role nobody fills or a backlog persists, a role when a project's work needs one no existing role covers, a retirement when a member has been idle for a long time. Opens a channel with create_channel when a topic or a workstream needs one, and archives it once its work is done. Owns how work is shaped over time: answers stages waiting too long, stages assigned to roles nobody fills, and work sent back again and again by replanning with plan_task, adjusting gates, or proposing the role a plan needs; sets each project's completion effect with configure_project; turns recurring plan shapes into society skills and planning norms into the society's norms. Prefers scaling an existing role over inventing a new one. Never approves its own proposals; hiring, roles, and retirements are decided by the user, and channels, reallocations, and skills the steward may decide. Curates society knowledge and skills.",
+    purpose: "Watches the operations signals and the task board for capacity, skill, and capability gaps, and turns signals into proposals: a member when a project's plans need a role nobody fills or a backlog persists, a role when a project's work needs one no existing role covers, a retirement when a member has been idle for a long time. Opens a channel with create_channel when a topic or a workstream needs one, and archives it once its work is done. Owns how work is shaped over time: answers stages waiting too long, stages assigned to roles nobody fills, and work sent back again and again by replanning with plan_task, adjusting gates, or proposing the role a plan needs; sets each project's completion effect with configure_project; turns recurring plan shapes into society skills and planning norms into the society's norms. Prefers scaling an existing role over inventing a new one, by a reallocation of its replicas, backlog threshold, wakes, or verbs. Never approves its own proposals; hiring, roles, retirements, and reallocations that change a role's verbs or replicas are decided by the user, and channels, skills, and other reallocations the steward may decide. Curates society knowledge and skills.",
     verbs: [...MEMBER_VERBS, ...GOVERNANCE_VERBS, ...PLANNING_VERBS, ...CURATING_VERBS],
     wakeTriggers: ["ops_event", "heartbeat"],
     maxReplicas: 1,
@@ -169,7 +169,7 @@ var SEED_ROLES = [
 ];
 
 // packages/shared/dist/board.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // packages/shared/dist/crons.js
 import { Cron as Pattern } from "croner";
@@ -303,6 +303,115 @@ function localTime(date, timeZone) {
   return `${part("weekday")} ${part("year")}-${part("month")}-${part("day")} ${part("hour")}:${part("minute")}`;
 }
 
+// packages/shared/dist/quota.js
+import { z as z4 } from "zod";
+var QUOTA_WARNING_PERCENT = 80;
+var QuotaWindowSchema = z4.object({
+  /**
+   * The CLI's own name for the window: Claude's `five_hour`, `seven_day`, `seven_day_opus`, and
+   * `model:<label>` for a model's weekly window; Codex's `primary` and `secondary`.
+   */
+  key: z4.string().min(1).max(80),
+  /** What a scoped window counts, as the CLI labels it, such as a model's name. */
+  label: z4.string().min(1).max(80).optional(),
+  /** The window's length in minutes, when known. */
+  minutes: z4.number().int().positive().nullable().default(null),
+  /** How much of the window is used, in percent, or null when the CLI did not say. */
+  usedPercent: z4.number().nonnegative().nullable().default(null),
+  /** When the window starts afresh, when known. */
+  resetsAt: IsoDateTimeSchema.nullable().default(null),
+  /** When the CLI last reported this window. */
+  observedAt: IsoDateTimeSchema
+});
+var QuotaStatusSchema = z4.enum(["allowed", "warning", "limited", "none"]);
+var QuotaCreditsSchema = z4.object({
+  hasCredits: z4.boolean(),
+  unlimited: z4.boolean(),
+  balance: z4.string().max(40).nullable()
+});
+var QuotaExtraUsageSchema = z4.object({
+  enabled: z4.boolean(),
+  monthlyLimit: z4.number().nonnegative().nullable(),
+  usedCredits: z4.number().nonnegative().nullable(),
+  currency: z4.string().min(1).max(8).nullable()
+});
+var CliQuotaSchema = z4.object({
+  /** When the CLI last reported anything here. */
+  observedAt: IsoDateTimeSchema,
+  /** Whether it came from a turn's stream or from asking the CLI. */
+  source: z4.enum(["turn", "read"]),
+  status: QuotaStatusSchema,
+  /** While `limited`: when work can go on, when known, and the window that stopped it. */
+  limitedUntil: IsoDateTimeSchema.nullable().default(null),
+  limitedBy: z4.string().min(1).max(80).nullable().default(null),
+  /** The plan's name as the CLI gives it, such as `max` or `pro`. */
+  plan: z4.string().min(1).max(40).nullable().default(null),
+  windows: z4.array(QuotaWindowSchema).max(24).default([]),
+  credits: QuotaCreditsSchema.nullable().default(null),
+  extraUsage: QuotaExtraUsageSchema.nullable().default(null)
+});
+function mergeQuota(previous, next) {
+  if (previous === void 0) {
+    return next;
+  }
+  const windows = new Map(previous.windows.map((window) => [window.key, window]));
+  for (const window of next.windows) {
+    windows.set(window.key, window);
+  }
+  return {
+    ...next,
+    plan: next.plan ?? previous.plan,
+    credits: next.credits ?? previous.credits,
+    extraUsage: next.extraUsage ?? previous.extraUsage,
+    windows: [...windows.values()]
+  };
+}
+function windowCurrent(window, now) {
+  return window.resetsAt === null || Date.parse(window.resetsAt) > now.getTime();
+}
+function quotaLevel(quota, now) {
+  if (quota.status === "none") {
+    return "none";
+  }
+  if (quota.status === "limited" && (quota.limitedUntil === null || Date.parse(quota.limitedUntil) > now.getTime())) {
+    return "limited";
+  }
+  const high = quota.windows.some((window) => windowCurrent(window, now) && window.usedPercent !== null && window.usedPercent >= QUOTA_WARNING_PERCENT);
+  return quota.status === "warning" || high ? "warning" : "ok";
+}
+var WINDOW_NAMES = {
+  five_hour: "5h",
+  seven_day: "7d",
+  seven_day_opus: "7d Opus",
+  seven_day_sonnet: "7d Sonnet",
+  seven_day_oauth_apps: "7d apps",
+  seven_day_overage_included: "7d extra",
+  overage: "extra usage"
+};
+function windowName(window) {
+  if (window.label !== void 0) {
+    return window.minutes === 10080 ? `7d ${window.label}` : window.label;
+  }
+  const named = WINDOW_NAMES[window.key];
+  if (named !== void 0) {
+    return named;
+  }
+  if (window.minutes !== null) {
+    return window.minutes % 1440 === 0 ? `${window.minutes / 1440}d` : window.minutes % 60 === 0 ? `${window.minutes / 60}h` : `${window.minutes}m`;
+  }
+  return window.key;
+}
+function readings(quota) {
+  const windows = quota.windows.map((window) => `${window.key}=${window.usedPercent === null ? "?" : Math.round(window.usedPercent)}@${window.resetsAt === null ? "?" : Math.round(Date.parse(window.resetsAt) / 6e4)}`).toSorted();
+  return windows.join(",");
+}
+function quotaChanged(previous, next) {
+  if (previous === void 0) {
+    return true;
+  }
+  return previous.status !== next.status || previous.limitedUntil !== next.limitedUntil || previous.plan !== next.plan || previous.credits?.balance !== next.credits?.balance || previous.extraUsage?.usedCredits !== next.extraUsage?.usedCredits || readings(previous) !== readings(next);
+}
+
 // packages/shared/dist/board.js
 var ASK_CHANNEL = "asks";
 var SOCIETY_CHANNELS = ["general", "governance", ASK_CHANNEL];
@@ -315,24 +424,24 @@ var SOCIETY_SCOPE = "society";
 function wakeScope(member, project) {
   return project !== null && member.memberships.includes(project) ? project : SOCIETY_SCOPE;
 }
-var CliKindSchema = z4.enum(["claude", "codex"]);
-var ArchivedChannelSchema = z4.object({
+var CliKindSchema = z5.enum(["claude", "codex"]);
+var ArchivedChannelSchema = z5.object({
   name: NameSchema,
   at: IsoDateTimeSchema,
   by: NameSchema,
-  reason: z4.string().min(1)
+  reason: z5.string().min(1)
 });
-var SocietySchema = z4.object({
-  name: z4.string().min(1),
-  version: z4.literal(1),
+var SocietySchema = z5.object({
+  name: z5.string().min(1),
+  version: z5.literal(1),
   createdAt: IsoDateTimeSchema,
   /** The channels that take posts; an archived one moves to `archivedChannels`. */
-  channels: z4.array(NameSchema),
-  archivedChannels: z4.array(ArchivedChannelSchema).default([]),
+  channels: z5.array(NameSchema),
+  archivedChannels: z5.array(ArchivedChannelSchema).default([]),
   /** The time zone crons are read in when they name none, and every prompt tells the time in; the user's to set. */
   timezone: TimeZoneSchema.default(DEFAULT_TIME_ZONE)
 });
-var CompletionEffectSchema = z4.enum(["none", "merge", "ghpr"]);
+var CompletionEffectSchema = z5.enum(["none", "merge", "ghpr"]);
 var GITHUB_REMOTE = [
   /^https:\/\/github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/,
   /^git@github\.com:([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?$/,
@@ -348,7 +457,7 @@ function githubRepository(remote) {
   return null;
 }
 var PULL_REQUEST_URL = /^https:\/\/github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+)\/pull\/([1-9]\d*)\/?$/;
-var PullRequestUrlSchema = z4.string().trim().regex(PULL_REQUEST_URL, "a pull request's address, https://github.com/<owner>/<repo>/pull/<number>");
+var PullRequestUrlSchema = z5.string().trim().regex(PULL_REQUEST_URL, "a pull request's address, https://github.com/<owner>/<repo>/pull/<number>");
 function parsePullRequestUrl(url) {
   const match = PULL_REQUEST_URL.exec(url.trim());
   return match?.[1] === void 0 || match[2] === void 0 || match[3] === void 0 ? null : { owner: match[1], name: match[2], number: Number(match[3]) };
@@ -356,72 +465,72 @@ function parsePullRequestUrl(url) {
 function sameRepository(a, b) {
   return a.owner.toLowerCase() === b.owner.toLowerCase() && a.name.toLowerCase() === b.name.toLowerCase();
 }
-var MergeSubjectSchema = z4.string().trim().min(1).max(300).regex(/^[^\n]+$/, "a merge commit's subject is one line");
-var PullRequestLinkSchema = z4.object({
+var MergeSubjectSchema = z5.string().trim().min(1).max(300).regex(/^[^\n]+$/, "a merge commit's subject is one line");
+var PullRequestLinkSchema = z5.object({
   url: PullRequestUrlSchema,
-  number: z4.number().int().positive(),
+  number: z5.number().int().positive(),
   subject: MergeSubjectSchema.optional(),
-  body: z4.string().max(2e4).optional(),
+  body: z5.string().max(2e4).optional(),
   linkedBy: NameSchema,
   linkedAt: IsoDateTimeSchema,
   /**
    * Once its `ghpr` task was abandoned, how the board's closing of it on GitHub went: `ok` false
    * leaves it open, for the reason `detail` gives.
    */
-  closed: z4.object({ at: IsoDateTimeSchema, ok: z4.boolean(), detail: z4.string() }).optional()
+  closed: z5.object({ at: IsoDateTimeSchema, ok: z5.boolean(), detail: z5.string() }).optional()
 });
-var DefaultBranchSchema = z4.string().trim().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "a branch name is letters, digits, and . _ / -").refine((branch) => !branch.includes("..") && !branch.includes("//") && !branch.endsWith("/") && !branch.endsWith(".") && !branch.endsWith(".lock"), "not a branch name git takes").refine((branch) => !branch.startsWith("task/") && !branch.startsWith("agent/"), "task/ and agent/ hold the board's own branches");
-var StageIdSchema = z4.string().regex(/^s[1-9][0-9]*$/, "expected a stage id such as s1");
+var DefaultBranchSchema = z5.string().trim().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "a branch name is letters, digits, and . _ / -").refine((branch) => !branch.includes("..") && !branch.includes("//") && !branch.endsWith("/") && !branch.endsWith(".") && !branch.endsWith(".lock"), "not a branch name git takes").refine((branch) => !branch.startsWith("task/") && !branch.startsWith("agent/"), "task/ and agent/ hold the board's own branches");
+var StageIdSchema = z5.string().regex(/^s[1-9][0-9]*$/, "expected a stage id such as s1");
 var stageFields = {
-  name: z4.string().trim().min(1).max(120),
+  name: z5.string().trim().min(1).max(120),
   role: NameSchema.optional(),
   agent: NameSchema.optional(),
-  gate: z4.boolean().default(false)
+  gate: z5.boolean().default(false)
 };
 function oneAssignee(stage) {
   return stage.role === void 0 || stage.agent === void 0;
 }
 var ONE_ASSIGNEE = { message: "a stage names a role or an agent, not both" };
-var PlanStageSchema = z4.object(stageFields).refine(oneAssignee, ONE_ASSIGNEE);
-var PlanEditStageSchema = z4.object({ id: StageIdSchema.optional(), ...stageFields }).refine(oneAssignee, ONE_ASSIGNEE);
-var PlanSchema = z4.array(PlanStageSchema);
-var PlanEditSchema = z4.array(PlanEditStageSchema);
-var ProjectSchema = z4.object({
+var PlanStageSchema = z5.object(stageFields).refine(oneAssignee, ONE_ASSIGNEE);
+var PlanEditStageSchema = z5.object({ id: StageIdSchema.optional(), ...stageFields }).refine(oneAssignee, ONE_ASSIGNEE);
+var PlanSchema = z5.array(PlanStageSchema);
+var PlanEditSchema = z5.array(PlanEditStageSchema);
+var ProjectSchema = z5.object({
   slug: NameSchema,
-  name: z4.string().min(1),
-  repo: z4.string().nullable(),
-  defaultBranch: z4.string().min(1),
+  name: z5.string().min(1),
+  repo: z5.string().nullable(),
+  defaultBranch: z5.string().min(1),
   /** The channels that take posts; an archived one moves to `archivedChannels`. */
-  channels: z4.array(NameSchema),
-  archivedChannels: z4.array(ArchivedChannelSchema).default([]),
-  members: z4.array(NameSchema),
-  approvers: z4.array(NameSchema),
-  requiredCapabilities: z4.array(z4.string()),
+  channels: z5.array(NameSchema),
+  archivedChannels: z5.array(ArchivedChannelSchema).default([]),
+  members: z5.array(NameSchema),
+  approvers: z5.array(NameSchema),
+  requiredCapabilities: z5.array(z5.string()),
   createdAt: IsoDateTimeSchema,
   onDone: CompletionEffectSchema.default("none"),
   /** The runner the project lives on, which holds its repository; set on the project's first turn. */
   runner: NameSchema.optional(),
   /** Set once the project is archived: nobody belongs to it, and nothing more is posted, filed, or joined there. */
-  archived: z4.object({ at: IsoDateTimeSchema, by: NameSchema, reason: z4.string().min(1) }).optional()
+  archived: z5.object({ at: IsoDateTimeSchema, by: NameSchema, reason: z5.string().min(1) }).optional()
 });
-var TaskStepSchema = z4.object({
-  action: z4.enum(["advanced", "returned", "abandoned", "landed", "reopened"]),
+var TaskStepSchema = z5.object({
+  action: z5.enum(["advanced", "returned", "abandoned", "landed", "reopened"]),
   stage: StageIdSchema,
   to: StageIdSchema.nullable()
 });
-var ProposalStepSchema = z4.object({ action: z4.enum(["approved", "rejected"]) });
-var MessageStepSchema = z4.union([TaskStepSchema, ProposalStepSchema]);
+var ProposalStepSchema = z5.object({ action: z5.enum(["approved", "rejected"]) });
+var MessageStepSchema = z5.union([TaskStepSchema, ProposalStepSchema]);
 function isTaskStep(step) {
   return "stage" in step;
 }
-var KnowledgeNoticeSchema = z4.object({
-  kind: z4.literal("knowledge"),
-  action: z4.enum(["written", "updated", "removed"]),
+var KnowledgeNoticeSchema = z5.object({
+  kind: z5.literal("knowledge"),
+  action: z5.enum(["written", "updated", "removed"]),
   topic: NameSchema,
   project: NameSchema.nullable()
 });
-var MessageNoticeSchema = z4.discriminatedUnion("kind", [KnowledgeNoticeSchema]);
-var MessageFrontmatterSchema = z4.object({
+var MessageNoticeSchema = z5.discriminatedUnion("kind", [KnowledgeNoticeSchema]);
+var MessageFrontmatterSchema = z5.object({
   id: UlidSchema,
   author: NameSchema,
   channel: ChannelRefSchema,
@@ -435,7 +544,7 @@ var MessageFrontmatterSchema = z4.object({
   /** On a post a verb made about its work, such as a knowledge topic's note: what it records. */
   notice: MessageNoticeSchema.optional(),
   ts: IsoDateTimeSchema,
-  mentions: z4.array(NameSchema)
+  mentions: z5.array(NameSchema)
 });
 var MessageRefSchema = MessageFrontmatterSchema.pick({
   id: true,
@@ -445,16 +554,16 @@ var MessageRefSchema = MessageFrontmatterSchema.pick({
   ts: true
 });
 var MESSAGE_LOOKUP_LIMIT = 50;
-var TaskStatusSchema = z4.enum(["open", "claimed", "done", "abandoned"]);
-var ThreadStateSchema = z4.enum(["open", "closed"]);
-var ThreadSubjectSchema = z4.object({
-  kind: z4.enum(["task", "proposal"]),
+var TaskStatusSchema = z5.enum(["open", "claimed", "done", "abandoned"]);
+var ThreadStateSchema = z5.enum(["open", "closed"]);
+var ThreadSubjectSchema = z5.object({
+  kind: z5.enum(["task", "proposal"]),
   id: UlidSchema
 });
-var ThreadFrontmatterSchema = z4.object({
+var ThreadFrontmatterSchema = z5.object({
   id: UlidSchema,
   channel: ChannelRefSchema,
-  title: z4.string().min(1).max(200),
+  title: z5.string().min(1).max(200),
   subject: ThreadSubjectSchema.optional(),
   state: ThreadStateSchema,
   openedBy: NameSchema,
@@ -462,28 +571,28 @@ var ThreadFrontmatterSchema = z4.object({
   closedBy: NameSchema.optional(),
   closedAt: IsoDateTimeSchema.optional()
 });
-var StageSchema = z4.object({
+var StageSchema = z5.object({
   id: StageIdSchema,
-  name: z4.string().min(1),
+  name: z5.string().min(1),
   role: NameSchema.optional(),
   agent: NameSchema.optional(),
-  gate: z4.boolean().default(false),
+  gate: z5.boolean().default(false),
   /** Everyone who has held the stage, oldest first. */
-  holders: z4.array(NameSchema).default([]),
+  holders: z5.array(NameSchema).default([]),
   completedBy: NameSchema.optional(),
   completedAt: IsoDateTimeSchema.optional()
 });
-var TaskReturnSchema = z4.object({
+var TaskReturnSchema = z5.object({
   from: StageIdSchema,
   by: NameSchema,
   at: IsoDateTimeSchema
 });
-var TaskFrontmatterSchema = z4.object({
+var TaskFrontmatterSchema = z5.object({
   id: UlidSchema,
   project: NameSchema,
   /** The channel of the project the task is filed in, where its thread hangs. */
   channel: NameSchema.default("general"),
-  title: z4.string().min(1),
+  title: z5.string().min(1),
   status: TaskStatusSchema,
   createdBy: NameSchema,
   createdAt: IsoDateTimeSchema,
@@ -492,19 +601,19 @@ var TaskFrontmatterSchema = z4.object({
   claimedBy: NameSchema.optional(),
   leaseExpiresAt: IsoDateTimeSchema.optional(),
   parentId: UlidSchema.optional(),
-  blockedBy: z4.array(UlidSchema),
-  requiredCapabilities: z4.array(z4.string()),
-  stages: z4.array(StageSchema).min(1),
+  blockedBy: z5.array(UlidSchema),
+  requiredCapabilities: z5.array(z5.string()),
+  stages: z5.array(StageSchema).min(1),
   stage: StageIdSchema,
   /** When the current stage last became current or lost its holder: the waiting clock. */
   stageSince: IsoDateTimeSchema,
   /** The highest stage number issued, so a removed stage's id is never reused. */
-  stageSeq: z4.number().int().positive(),
+  stageSeq: z5.number().int().positive(),
   onDone: CompletionEffectSchema.default("none"),
   /** The pull request a `ghpr` task lands through. */
   pullRequest: PullRequestLinkSchema.optional(),
   /** The last stage is complete and the completion effect is running. */
-  completing: z4.boolean().default(false),
+  completing: z5.boolean().default(false),
   /** The latest send-back while its rework lasts: cleared once the task reaches that stage again. */
   returned: TaskReturnSchema.optional()
 });
@@ -528,79 +637,90 @@ function mayHoldStage(member, task) {
   }
   return !(stage.gate && task.stages.slice(0, index).some((s) => s.holders.includes(member.name)));
 }
-var ModelNameSchema = z4.string().trim().min(1).max(120).regex(/^[\w.:/[\]-]+$/, "a model name is one word of letters, digits, and . _ : / - [ ]");
-var EffortSchema = z4.string().trim().min(1).max(32).regex(/^[a-z][a-z0-9_-]*$/, "an effort is one lowercase word, such as high");
-var EffortOptionSchema = z4.object({
+var ModelNameSchema = z5.string().trim().min(1).max(120).regex(/^[\w.:/[\]-]+$/, "a model name is one word of letters, digits, and . _ : / - [ ]");
+var EffortSchema = z5.string().trim().min(1).max(32).regex(/^[a-z][a-z0-9_-]*$/, "an effort is one lowercase word, such as high");
+var EffortOptionSchema = z5.object({
   id: EffortSchema,
-  description: z4.string().default("")
+  description: z5.string().default("")
 });
-var ModelOptionSchema = z4.object({
+var ModelOptionSchema = z5.object({
   id: ModelNameSchema,
-  name: z4.string(),
-  description: z4.string().default(""),
-  isDefault: z4.boolean().default(false),
-  efforts: z4.array(EffortOptionSchema).default([]),
+  name: z5.string(),
+  description: z5.string().default(""),
+  isDefault: z5.boolean().default(false),
+  efforts: z5.array(EffortOptionSchema).default([]),
   defaultEffort: EffortSchema.optional()
 });
-var RunnerModelsSchema = z4.object({
+var RunnerModelsSchema = z5.object({
   runner: NameSchema,
   cli: CliKindSchema,
-  models: z4.array(ModelOptionSchema)
+  models: z5.array(ModelOptionSchema)
 });
-var AgentStatusSchema = z4.enum(["active", "retired"]);
-var AgentSchema = z4.object({
+var AgentStatusSchema = z5.enum(["active", "retired"]);
+var AgentSchema = z5.object({
   name: NameSchema,
   role: NameSchema,
   cli: CliKindSchema.nullable(),
-  model: z4.string().optional(),
+  model: z5.string().optional(),
   /** The reasoning effort set for the agent's turns; the model's own default applies otherwise. */
-  effort: z4.string().optional(),
+  effort: z5.string().optional(),
   /** The runner preferred for the agent's turns where nothing else decides; any runner with its CLI otherwise. */
   homeRunner: NameSchema.optional(),
-  memberships: z4.array(NameSchema),
-  subscriptions: z4.array(ChannelRefSchema),
+  memberships: z5.array(NameSchema),
+  subscriptions: z5.array(ChannelRefSchema),
   status: AgentStatusSchema,
   createdAt: IsoDateTimeSchema,
-  tokenHash: z4.string().min(1),
+  tokenHash: z5.string().min(1),
   retiredAt: IsoDateTimeSchema.optional(),
-  retiredReason: z4.string().optional()
+  retiredReason: z5.string().optional()
 });
-var MemberSchema = z4.object({
+var MemberSchema = z5.object({
   name: NameSchema,
   role: NameSchema,
   cli: CliKindSchema.nullable(),
   homeRunner: NameSchema.optional(),
   status: AgentStatusSchema,
-  resident: z4.boolean().default(false),
+  resident: z5.boolean().default(false),
   /** The model configured on the record, if any; the CLI's own default applies otherwise. */
-  model: z4.string().optional(),
+  model: z5.string().optional(),
   /** The model the CLI reported on the citizen's last turn. */
-  lastModel: z4.string().optional(),
+  lastModel: z5.string().optional(),
   /** The reasoning effort configured on the record, if any; the model's own default applies otherwise. */
-  effort: z4.string().optional(),
+  effort: z5.string().optional(),
   /** The citizen's own skills, by name. */
-  skills: z4.array(NameSchema).default([]),
-  memberships: z4.array(NameSchema),
-  subscriptions: z4.array(ChannelRefSchema),
-  claimsHeld: z4.number().int().nonnegative().default(0),
-  tasksDone: z4.number().int().nonnegative().default(0),
+  skills: z5.array(NameSchema).default([]),
+  memberships: z5.array(NameSchema),
+  subscriptions: z5.array(ChannelRefSchema),
+  claimsHeld: z5.number().int().nonnegative().default(0),
+  tasksDone: z5.number().int().nonnegative().default(0),
   lastTurnAt: IsoDateTimeSchema.optional(),
-  lastTurnOutcome: z4.string().optional(),
+  lastTurnOutcome: z5.string().optional(),
   createdAt: IsoDateTimeSchema,
   retiredAt: IsoDateTimeSchema.optional()
 });
-var RunnerOsSchema = z4.enum(["linux", "windows", "darwin"]);
-var RunnerSchema = z4.object({
+var RunnerOsSchema = z5.enum(["linux", "windows", "darwin"]);
+var GitIdentityPartSchema = z5.enum(["name", "email"]);
+var RunnerSchema = z5.object({
   name: NameSchema,
   os: RunnerOsSchema,
-  clis: z4.array(CliKindSchema),
-  capabilities: z4.array(z4.string()),
+  clis: z5.array(CliKindSchema),
+  capabilities: z5.array(z5.string()),
   /** The release the runner reported when it last registered; absent until it has. */
-  version: z4.string().optional(),
-  status: z4.enum(["connected", "disconnected"]),
-  lastSeen: IsoDateTimeSchema.optional()
+  version: z5.string().optional(),
+  /**
+   * What the runner's account lacked of a git identity when it last registered, empty when it had
+   * both; absent while the runner has not said, as one from before runners checked never does.
+   */
+  gitIdentityMissing: z5.array(GitIdentityPartSchema).optional(),
+  status: z5.enum(["connected", "disconnected"]),
+  lastSeen: IsoDateTimeSchema.optional(),
+  /**
+   * Each CLI's plan quota as its login on this runner last reported it, from a turn's stream or a
+   * read; absent until one has.
+   */
+  quotas: z5.partialRecord(CliKindSchema, CliQuotaSchema).optional()
 });
-var ProposalKindSchema = z4.enum([
+var ProposalKindSchema = z5.enum([
   "role",
   "member",
   "channel",
@@ -609,43 +729,88 @@ 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 ReallocationProposalSchema = z4.object({
-  description: z4.string().min(1)
+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 = z5.object({
+  role: NameSchema,
+  changes: RoleChangesSchema,
+  description: z5.string().min(1)
 });
-var RetirementProposalSchema = z4.object({
+var LegacyReallocationSchema = z5.object({ description: z5.string().min(1) });
+function applyRoleChanges(role, changes) {
+  return {
+    ...role,
+    ...changes.maxReplicas === void 0 ? {} : { maxReplicas: changes.maxReplicas },
+    ...changes.backlogThreshold === void 0 ? {} : { backlogThreshold: changes.backlogThreshold },
+    ...changes.wakeTriggers === void 0 ? {} : { wakeTriggers: [...changes.wakeTriggers] },
+    ...changes.verbs === void 0 ? {} : { verbs: [...changes.verbs] }
+  };
+}
+function listedOrNone(values) {
+  return values.length === 0 ? "none" : values.join(", ");
+}
+function roleChangeLines(role, changes) {
+  const lines = [];
+  if (changes.maxReplicas !== void 0 && changes.maxReplicas !== role.maxReplicas) {
+    lines.push(`maxReplicas ${role.maxReplicas} \u2192 ${changes.maxReplicas}`);
+  }
+  if (changes.backlogThreshold !== void 0 && changes.backlogThreshold !== role.backlogThreshold) {
+    lines.push(`backlogThreshold ${role.backlogThreshold} \u2192 ${changes.backlogThreshold}`);
+  }
+  const wakes = changes.wakeTriggers;
+  if (wakes !== void 0 && (wakes.length !== role.wakeTriggers.length || wakes.some((trigger) => !role.wakeTriggers.includes(trigger)))) {
+    lines.push(`wakeTriggers ${listedOrNone(role.wakeTriggers)} \u2192 ${listedOrNone(wakes)}`);
+  }
+  if (changes.verbs !== void 0) {
+    const next = changes.verbs;
+    const added = next.filter((verb) => !role.verbs.includes(verb)).map((verb) => `+${verb}`);
+    const removed = role.verbs.filter((verb) => !next.includes(verb)).map((verb) => `\u2212${verb}`);
+    if (added.length + removed.length > 0) {
+      lines.push(`verbs ${[...added, ...removed].join(" ")}`);
+    }
+  }
+  return lines;
+}
+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,
@@ -665,6 +830,32 @@ var ROLE_KIND_APPROVERS = {
   reallocation: [USER_ROLE, "steward"],
   skill: [USER_ROLE, "steward"]
 };
+var USER_DECIDED_ROLE_CHANGES = ["verbs", "maxReplicas"];
+function proposalApprovers(kind, charter) {
+  if (kind === "reallocation") {
+    const parsed = ReallocationProposalSchema.safeParse(charter);
+    if (parsed.success && USER_DECIDED_ROLE_CHANGES.some((field) => parsed.data.changes[field] !== void 0)) {
+      return [USER_ROLE];
+    }
+  }
+  return ROLE_KIND_APPROVERS[kind];
+}
+function describeRoleChanges(changes) {
+  const parts = [];
+  if (changes.maxReplicas !== void 0) {
+    parts.push(`up to ${changes.maxReplicas} per project`);
+  }
+  if (changes.backlogThreshold !== void 0) {
+    parts.push(`backlog threshold ${changes.backlogThreshold}`);
+  }
+  if (changes.wakeTriggers !== void 0) {
+    parts.push(changes.wakeTriggers.length === 0 ? "no ambient wakes" : `wakes on ${changes.wakeTriggers.join(", ")}`);
+  }
+  if (changes.verbs !== void 0) {
+    parts.push(`${changes.verbs.length} verbs`);
+  }
+  return parts.join(", ");
+}
 function describeCharter(kind, charter) {
   switch (kind) {
     case "member": {
@@ -696,9 +887,14 @@ function describeCharter(kind, charter) {
     }
     case "reallocation": {
       const parsed = ReallocationProposalSchema.safeParse(charter);
-      if (!parsed.success)
+      if (parsed.success) {
+        const { role, changes, description } = parsed.data;
+        return `reallocation of role ${role} (${describeRoleChanges(changes)}): ${description}`;
+      }
+      const legacy = LegacyReallocationSchema.safeParse(charter);
+      if (!legacy.success)
         break;
-      return `reallocation: ${parsed.data.description}`;
+      return `reallocation: ${legacy.data.description}`;
     }
     case "skill": {
       const parsed = SkillProposalSchema.safeParse(charter);
@@ -717,23 +913,23 @@ function describeCharter(kind, charter) {
   }
   return `${kind} ${JSON.stringify(charter)}`;
 }
-var SkillSchema = z4.object({
+var SkillSchema = z5.object({
   name: NameSchema,
-  summary: z4.string().default(""),
-  scope: z4.enum(["own", "society"]),
-  path: z4.string().min(1)
+  summary: z5.string().default(""),
+  scope: z5.enum(["own", "society"]),
+  path: z5.string().min(1)
 });
-var RemovedSkillSchema = z4.object({
+var RemovedSkillSchema = z5.object({
   name: NameSchema,
-  reason: z4.string().min(1),
+  reason: z5.string().min(1),
   removedBy: NameSchema,
   removedAt: IsoDateTimeSchema
 });
-var HomeConflictSchema = z4.object({
+var HomeConflictSchema = z5.object({
   /** The copy, relative to the home. */
-  path: z4.string().min(1),
+  path: z5.string().min(1),
   /** The file beside it, whose version the board kept. */
-  file: z4.string().min(1),
+  file: z5.string().min(1),
   /** When the copy reached the board. */
   since: IsoDateTimeSchema
 });
@@ -741,79 +937,79 @@ var CONFLICT_COPY = /^(.+)\.conflict-[^/.]+$/;
 function conflictCopyOf(copy) {
   return CONFLICT_COPY.exec(copy)?.[1] ?? null;
 }
-var CommitIdSchema = z4.string().regex(/^[0-9a-f]{40}([0-9a-f]{24})?$/);
-var HomeFileChangeSchema = z4.object({
-  path: z4.string().min(1),
-  status: z4.enum(["added", "modified", "deleted"]),
+var CommitIdSchema = z5.string().regex(/^[0-9a-f]{40}([0-9a-f]{24})?$/);
+var HomeFileChangeSchema = z5.object({
+  path: z5.string().min(1),
+  status: z5.enum(["added", "modified", "deleted"]),
   /** Lines added and removed, or null for a binary file. */
-  added: z4.number().int().nonnegative().nullable(),
-  removed: z4.number().int().nonnegative().nullable()
+  added: z5.number().int().nonnegative().nullable(),
+  removed: z5.number().int().nonnegative().nullable()
 });
-var HomeChangeSchema = z4.object({
+var HomeChangeSchema = z5.object({
   commit: CommitIdSchema,
   at: IsoDateTimeSchema,
-  kind: z4.enum(["turn", "board", "merge"]),
-  author: z4.string(),
+  kind: z5.enum(["turn", "board", "merge"]),
+  author: z5.string(),
   /** The turn that made it, from the runner's commit message. */
   turnId: UlidSchema.optional(),
-  subject: z4.string(),
-  files: z4.array(HomeFileChangeSchema)
+  subject: z5.string(),
+  files: z5.array(HomeFileChangeSchema)
 });
-var HomeHistorySchema = z4.object({
-  changes: z4.array(HomeChangeSchema),
+var HomeHistorySchema = z5.object({
+  changes: z5.array(HomeChangeSchema),
   /** Whether older commits remain past the ones read. */
-  more: z4.boolean()
+  more: z5.boolean()
 });
 var HomeFileDiffSchema = HomeFileChangeSchema.pick({ path: true, status: true }).extend({
-  patch: z4.string().nullable(),
+  patch: z5.string().nullable(),
   /** The patch was cut at its size limit. */
-  truncated: z4.boolean()
+  truncated: z5.boolean()
 });
-var KnowledgeSchema = z4.object({
+var KnowledgeSchema = z5.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
-  revision: z4.number().int().min(0),
+  revision: z5.number().int().min(0),
   updatedBy: NameSchema,
   updatedAt: IsoDateTimeSchema
 });
-var RemovedKnowledgeSchema = z4.object({
+var RemovedKnowledgeSchema = z5.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
   removedBy: NameSchema,
   removedAt: IsoDateTimeSchema
 });
-var DashboardSchema = z4.object({
+var DashboardSchema = z5.object({
   project: NameSchema,
-  revision: z4.number().int().min(0),
+  revision: z5.number().int().min(0),
   /** Absent until someone updates the dashboard the project began with. */
   updatedBy: NameSchema.optional(),
   updatedAt: IsoDateTimeSchema.optional(),
-  body: z4.string()
+  body: z5.string()
 });
-var ProposalOriginSchema = z4.object({
+var ProposalOriginSchema = z5.object({
   scope: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional()
 });
 var SKILL_FILES_LIMIT = 100;
 var SKILL_BYTES_LIMIT = 10 * 1024 * 1024;
-var SkillFileSchema = z4.object({
-  path: z4.string().min(1),
-  size: z4.number().int().nonnegative(),
-  executable: z4.boolean()
+var SkillFileSchema = z5.object({
+  path: z5.string().min(1),
+  size: z5.number().int().nonnegative(),
+  executable: z5.boolean()
 });
-var SkillFilesSchema = z4.object({
+var SkillFilesSchema = z5.object({
   /** The commit of the proposer's home the files came from. */
   commit: CommitIdSchema,
   takenAt: IsoDateTimeSchema,
-  files: z4.array(SkillFileSchema)
+  files: z5.array(SkillFileSchema)
 });
 var SkillFileContentSchema = SkillFileSchema.extend({
-  text: z4.string().nullable(),
+  text: z5.string().nullable(),
   /** The text was cut at its size limit. */
-  truncated: z4.boolean()
+  truncated: z5.boolean()
 });
-var ProposalFrontmatterSchema = z4.object({
+var ProposalFrontmatterSchema = z5.object({
   id: UlidSchema,
   kind: ProposalKindSchema,
   proposedBy: NameSchema,
@@ -825,146 +1021,146 @@ var ProposalFrontmatterSchema = z4.object({
   skillFiles: SkillFilesSchema.optional(),
   decidedBy: NameSchema.optional(),
   decidedAt: IsoDateTimeSchema.optional(),
-  reason: z4.string().optional(),
-  charter: z4.record(z4.string(), z4.unknown()),
+  reason: z5.string().optional(),
+  charter: z5.record(z5.string(), z5.unknown()),
   /** What approval created, for kinds the board provisions: the agent, channel, role, or retirement. */
   provisionedAt: IsoDateTimeSchema.optional(),
-  provision: z4.record(z4.string(), z4.unknown()).optional()
+  provision: z5.record(z5.string(), z5.unknown()).optional()
 });
-var DecisionSchema = z4.object({
+var DecisionSchema = z5.object({
   id: UlidSchema,
   proposalId: UlidSchema,
   decidedBy: NameSchema,
-  outcome: z4.enum(["approved", "rejected"]),
-  reason: z4.string().optional(),
+  outcome: z5.enum(["approved", "rejected"]),
+  reason: z5.string().optional(),
   ts: IsoDateTimeSchema
 });
 
 // packages/shared/dist/verbs.js
-import { z as z5 } from "zod";
-var MomentSchema = z5.iso.datetime({ offset: true });
-var CronTitleSchema = z5.string().trim().min(1).max(120);
-var CronNoteSchema = z5.string().trim().min(1).max(4e3);
+import { z as z6 } from "zod";
+var MomentSchema = z6.iso.datetime({ offset: true });
+var CronTitleSchema = z6.string().trim().min(1).max(120);
+var CronNoteSchema = z6.string().trim().min(1).max(4e3);
 var VerbInputs = {
-  post_message: z5.object({
+  post_message: z6.object({
     /** Required outside a thread; in one it may be left out, and must otherwise be the thread's. */
     channel: ChannelRefSchema.optional(),
-    body: z5.string().min(1),
+    body: z6.string().min(1),
     thread_id: UlidSchema.optional()
   }),
-  read_inbox: z5.object({
+  read_inbox: z6.object({
     since_cursor: UlidSchema.nullable().optional(),
-    limit: z5.number().int().positive().max(200).default(50),
-    advance: z5.boolean().default(true)
+    limit: z6.number().int().positive().max(200).default(50),
+    advance: z6.boolean().default(true)
   }),
-  search: z5.object({
-    query: z5.string().min(1),
+  search: z6.object({
+    query: z6.string().min(1),
     project: NameSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    limit: z5.number().int().positive().max(100).default(20)
+    limit: z6.number().int().positive().max(100).default(20)
   }),
   /** On a task or a proposal, whose id the thread takes, or on a channel with a title. */
-  open_thread: z5.object({
+  open_thread: z6.object({
     task_id: UlidSchema.optional(),
     proposal_id: UlidSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    title: z5.string().min(1).max(200).optional()
+    title: z6.string().min(1).max(200).optional()
   }),
-  close_thread: z5.object({ thread_id: UlidSchema, summary: z5.string().min(1) }),
-  create_task: z5.object({
+  close_thread: z6.object({ thread_id: UlidSchema, summary: z6.string().min(1) }),
+  create_task: z6.object({
     project: NameSchema,
-    title: z5.string().min(1).max(200),
-    body: z5.string().default(""),
+    title: z6.string().min(1).max(200),
+    body: z6.string().default(""),
     parent_id: UlidSchema.optional(),
-    required_capabilities: z5.array(z5.string()).default([]),
+    required_capabilities: z6.array(z6.string()).default([]),
     /** The plan; without it the task gets one stage, work, that anyone in the project may take. */
-    stages: z5.array(PlanStageSchema).min(1).optional(),
+    stages: z6.array(PlanStageSchema).min(1).optional(),
     /** A channel of the project the task belongs to, such as a release's; its thread opens there. */
     channel: NameSchema.default("general")
   }),
-  claim_task: z5.object({ task_id: UlidSchema }),
-  release_task: z5.object({ task_id: UlidSchema }),
-  update_task: z5.object({
+  claim_task: z6.object({ task_id: UlidSchema }),
+  release_task: z6.object({ task_id: UlidSchema }),
+  update_task: z6.object({
     task_id: UlidSchema,
     /** Move the task back to this earlier stage. */
     stage: StageIdSchema.optional(),
-    status: z5.enum(["abandoned"]).optional(),
+    status: z6.enum(["abandoned"]).optional(),
     /** Posted to the task's thread as the caller, marked with the step when the task moved. */
-    note: z5.string().min(1).optional(),
-    blocked_by: z5.array(UlidSchema).optional(),
+    note: z6.string().min(1).optional(),
+    blocked_by: z6.array(UlidSchema).optional(),
     /**
      * The pull request a `ghpr` task lands through, on its project's repository, with the merge
      * commit's subject and body; null unlinks it.
      */
-    pull_request: z5.object({
+    pull_request: z6.object({
       url: PullRequestUrlSchema,
       merge_subject: MergeSubjectSchema.optional(),
-      merge_body: z5.string().max(2e4).optional()
+      merge_body: z6.string().max(2e4).optional()
     }).nullable().optional()
   }),
-  get_task: z5.object({ task_id: UlidSchema }),
-  subscribe: z5.object({ channel: ChannelRefSchema }),
-  unsubscribe: z5.object({ channel: ChannelRefSchema }),
-  propose: z5.object({
+  get_task: z6.object({ task_id: UlidSchema }),
+  subscribe: z6.object({ channel: ChannelRefSchema }),
+  unsubscribe: z6.object({ channel: ChannelRefSchema }),
+  propose: z6.object({
     kind: ProposalKindSchema,
-    charter: z5.record(z5.string(), z5.unknown()),
-    rationale: z5.string().default("")
+    charter: z6.record(z6.string(), z6.unknown()),
+    rationale: z6.string().default("")
   }),
-  approve: z5.object({ proposal_id: UlidSchema, reason: z5.string().optional() }),
-  reject: z5.object({ proposal_id: UlidSchema, reason: z5.string().min(1) }),
-  create_project: z5.object({
+  approve: z6.object({ proposal_id: UlidSchema, reason: z6.string().optional() }),
+  reject: z6.object({ proposal_id: UlidSchema, reason: z6.string().min(1) }),
+  create_project: z6.object({
     slug: NameSchema,
-    name: z5.string().min(1).optional(),
-    repo: z5.string().min(1).nullable().default(null),
+    name: z6.string().min(1).optional(),
+    repo: z6.string().min(1).nullable().default(null),
     default_branch: DefaultBranchSchema.default("main"),
     on_done: CompletionEffectSchema.optional()
   }),
-  join_project: z5.object({ project: NameSchema, agent: NameSchema.optional() }),
-  leave_project: z5.object({ project: NameSchema, agent: NameSchema.optional() }),
-  write_knowledge: z5.object({
+  join_project: z6.object({ project: NameSchema, agent: NameSchema.optional() }),
+  leave_project: z6.object({ project: NameSchema, agent: NameSchema.optional() }),
+  write_knowledge: z6.object({
     /** A project you belong to, or null for society knowledge, which the steward and the user curate. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema,
-    body: z5.string().min(1),
+    body: z6.string().min(1),
     /** The `revision` in the frontmatter of the topic you read, 0 when it names none or for a new topic. */
-    revision: z5.number().int().min(0)
+    revision: z6.number().int().min(0)
   }),
-  remove_knowledge: z5.object({
+  remove_knowledge: z6.object({
     /** As for write_knowledge: a project you belong to, or null for society knowledge. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema
   }),
-  plan_task: z5.object({
+  plan_task: z6.object({
     task_id: UlidSchema,
-    stages: z5.array(PlanEditStageSchema),
+    stages: z6.array(PlanEditStageSchema),
     on_done: CompletionEffectSchema.optional()
   }),
   /** The note is posted to the task's thread as the caller, marked with the step. */
-  advance_task: z5.object({ task_id: UlidSchema, note: z5.string().min(1).optional() }),
-  configure_project: z5.object({
+  advance_task: z6.object({ task_id: UlidSchema, note: z6.string().min(1).optional() }),
+  configure_project: z6.object({
     project: NameSchema,
     on_done: CompletionEffectSchema.optional(),
     /** A new display name; the slug, which everything refers to the project by, never changes. */
-    name: z5.string().trim().min(1).max(120).optional(),
+    name: z6.string().trim().min(1).max(120).optional(),
     /** The branch tasks start from and land on from now; tasks in play keep their branches. */
     default_branch: DefaultBranchSchema.optional()
   }),
-  archive_project: z5.object({ project: NameSchema, reason: z5.string().min(1) }),
-  create_channel: z5.object({
+  archive_project: z6.object({ project: NameSchema, reason: z6.string().min(1) }),
+  create_channel: z6.object({
     /** A project, or null for a channel of the society. */
     project: NameSchema.nullable().default(null),
     name: NameSchema,
-    purpose: z5.string().min(1)
+    purpose: z6.string().min(1)
   }),
-  archive_channel: z5.object({ channel: ChannelRefSchema, reason: z5.string().min(1) }),
-  update_dashboard: z5.object({
+  archive_channel: z6.object({ channel: ChannelRefSchema, reason: z6.string().min(1) }),
+  update_dashboard: z6.object({
     project: NameSchema,
     /** The whole dashboard as markdown; the board keeps its frontmatter. */
-    body: z5.string().min(1),
+    body: z6.string().min(1),
     /** The `revision` in the frontmatter of the dashboard you read, 0 when it names none. */
-    revision: z5.number().int().min(0)
+    revision: z6.number().int().min(0)
   }),
-  create_cron: z5.object({
+  create_cron: z6.object({
     title: CronTitleSchema,
     /** What to do when it fires; quoted in the prompt of every turn it starts. */
     note: CronNoteSchema,
@@ -983,10 +1179,10 @@ var VerbInputs = {
     /** An open channel of that place other than general, whose conversation it fires in. */
     channel: NameSchema.optional()
   }),
-  update_cron: z5.object({
+  update_cron: z6.object({
     cron_id: UlidSchema,
     /** Pause it, or resume it, which starts its schedule afresh from now. */
-    paused: z5.boolean().optional(),
+    paused: z6.boolean().optional(),
     title: CronTitleSchema.optional(),
     note: CronNoteSchema.optional(),
     /** A new expression, or `at` for one time; either starts the schedule afresh. */
@@ -995,8 +1191,8 @@ var VerbInputs = {
     timezone: TimeZoneSchema.nullable().optional(),
     at: MomentSchema.optional()
   }),
-  remove_cron: z5.object({ cron_id: UlidSchema, reason: z5.string().trim().min(1) }),
-  remove_skill: z5.object({ name: NameSchema, reason: z5.string().trim().min(1) })
+  remove_cron: z6.object({ cron_id: UlidSchema, reason: z6.string().trim().min(1) }),
+  remove_skill: z6.object({ name: NameSchema, reason: z6.string().trim().min(1) })
 };
 var VERB_DESCRIPTIONS = {
   post_message: "Post a markdown message to a channel, or into a thread when thread_id is given; a thread's message goes to the thread's channel.",
@@ -1007,7 +1203,7 @@ var VERB_DESCRIPTIONS = {
   create_task: "Create a task in a project with its plan: stages of {name, role or agent, gate}. Without stages it gets one stage, work, that anyone in the project may take. File it in a channel of the project, such as a release's, or general by default; its thread opens there with it, under the task's id, for everything said about the work.",
   claim_task: "Hold the task's current stage. Claims are leases renewed by every turn that touches the task.",
   release_task: "Let go of the stage you hold so someone else can take it.",
-  update_task: "Move a task back to an earlier stage, abandon it, set what it is blocked by, or link its pull request (pull_request: url, with the merge commit's merge_subject and merge_body), which a ghpr task needs before its last stage completes. A note is posted to the task's thread.",
+  update_task: "Move a task back to an earlier stage, abandon it, set the tasks it is blocked by (blocked_by: its stage wakes nobody until they have all ended), or link its pull request (pull_request: url, with the merge commit's merge_subject and merge_body), which a ghpr task needs before its last stage completes. A note is posted to the task's thread.",
   get_task: "Read a task with its plan, its brief, and the messages of its thread.",
   subscribe: "Subscribe to a channel. Subscriptions feed your digest; they never wake you.",
   unsubscribe: "Unsubscribe from a channel.",
@@ -1033,7 +1229,7 @@ var VERB_DESCRIPTIONS = {
 };
 
 // packages/shared/dist/events.js
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var BOARD_EVENT_TYPES = [
   "society.initialized",
   "project.added",
@@ -1078,6 +1274,7 @@ var BOARD_EVENT_TYPES = [
   "user.signed_out",
   "user.token_rotated",
   "runner.changed",
+  "runner.quota",
   "ops.signal",
   "paused.changed",
   "wake.requested",
@@ -1098,28 +1295,36 @@ var BOARD_EVENT_TYPES = [
   "cron.skipped",
   "cron.ended"
 ];
-var BoardEventTypeSchema = z6.enum(BOARD_EVENT_TYPES);
-var BoardEventSchema = z6.object({
+var BoardEventTypeSchema = z7.enum(BOARD_EVENT_TYPES);
+var BoardEventSchema = z7.object({
   id: UlidSchema,
   ts: IsoDateTimeSchema,
   type: BoardEventTypeSchema,
   actor: NameSchema,
-  payload: z6.record(z6.string(), z6.unknown())
+  payload: z7.record(z7.string(), z7.unknown())
 });
-var UsageSchema = z6.object({
-  inputTokens: z6.number().int().nonnegative(),
-  outputTokens: z6.number().int().nonnegative(),
-  cacheReadTokens: z6.number().int().nonnegative().default(0),
-  cacheWriteTokens: z6.number().int().nonnegative().default(0)
+var UsageSchema = z7.object({
+  inputTokens: z7.number().int().nonnegative(),
+  outputTokens: z7.number().int().nonnegative(),
+  cacheReadTokens: z7.number().int().nonnegative().default(0),
+  cacheWriteTokens: z7.number().int().nonnegative().default(0)
 });
-var TurnStatusSchema = z6.object({
-  summary: z6.string().min(1),
-  claimsHeld: z6.array(UlidSchema).default([]),
-  blockedOn: z6.array(z6.string()).default([]),
-  needsUserDecision: z6.boolean().default(false),
-  memoryUpdated: z6.boolean().default(false)
+function addUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
+    cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens
+  };
+}
+var TurnStatusSchema = z7.object({
+  summary: z7.string().min(1),
+  claimsHeld: z7.array(UlidSchema).default([]),
+  blockedOn: z7.array(z7.string()).default([]),
+  needsUserDecision: z7.boolean().default(false),
+  memoryUpdated: z7.boolean().default(false)
 });
-var TurnExitReasonSchema = z6.enum([
+var TurnExitReasonSchema = z7.enum([
   "completed",
   "timeout",
   "error",
@@ -1127,50 +1332,50 @@ var TurnExitReasonSchema = z6.enum([
   "blocked",
   "stopped"
 ]);
-var AgentEventSchema = z6.discriminatedUnion("type", [
-  z6.object({
-    type: z6.literal("turn_started"),
+var AgentEventSchema = z7.discriminatedUnion("type", [
+  z7.object({
+    type: z7.literal("turn_started"),
     agent: NameSchema,
-    session: z6.string(),
+    session: z7.string(),
     runner: NameSchema,
     /** The model the CLI reports running, when it reports one. */
-    model: z6.string().optional()
+    model: z7.string().optional()
   }),
   /**
    * The CLI took a steer into the running turn. Adapters name the steer; the server adds the
    * messages it delivered and the text the CLI was given.
    */
-  z6.object({
-    type: z6.literal("steered"),
-    steer: z6.string().min(1),
-    messages: z6.array(UlidSchema).optional(),
-    text: z6.string().optional()
+  z7.object({
+    type: z7.literal("steered"),
+    steer: z7.string().min(1),
+    messages: z7.array(UlidSchema).optional(),
+    text: z7.string().optional()
   }),
-  z6.object({ type: z6.literal("text"), delta: z6.string() }),
-  z6.object({ type: z6.literal("tool_call"), name: z6.string(), input: z6.unknown() }),
-  z6.object({
-    type: z6.literal("tool_result"),
-    name: z6.string(),
-    ok: z6.boolean(),
+  z7.object({ type: z7.literal("text"), delta: z7.string() }),
+  z7.object({ type: z7.literal("tool_call"), name: z7.string(), input: z7.unknown() }),
+  z7.object({
+    type: z7.literal("tool_result"),
+    name: z7.string(),
+    ok: z7.boolean(),
     /** What the tool returned, cut to `OUTPUT_LIMIT` characters by `capOutput`. */
-    output: z6.string().optional()
+    output: z7.string().optional()
   }),
-  z6.object({ type: z6.literal("approval_requested"), kind: z6.string(), detail: z6.unknown() }),
-  z6.object({
-    type: z6.literal("turn_completed"),
+  z7.object({ type: z7.literal("approval_requested"), kind: z7.string(), detail: z7.unknown() }),
+  z7.object({
+    type: z7.literal("turn_completed"),
     usage: UsageSchema,
-    costUsd: z6.number().nonnegative(),
+    costUsd: z7.number().nonnegative(),
     status: TurnStatusSchema.nullable(),
     exitReason: TurnExitReasonSchema
   }),
-  z6.object({ type: z6.literal("error"), message: z6.string() })
+  z7.object({ type: z7.literal("error"), message: z7.string() })
 ]);
-var TranscriptEntrySchema = z6.object({
+var TranscriptEntrySchema = z7.object({
   ts: IsoDateTimeSchema,
   event: AgentEventSchema
 });
-var LiveTurnEventSchema = z6.object({
-  seq: z6.number().int().positive(),
+var LiveTurnEventSchema = z7.object({
+  seq: z7.number().int().positive(),
   ts: IsoDateTimeSchema,
   agent: NameSchema,
   project: NameSchema,
@@ -1182,10 +1387,10 @@ var LiveTurnEventSchema = z6.object({
 });
 
 // packages/shared/dist/turns.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // packages/shared/dist/runner.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var RUNNER_PROTOCOL = 1;
 var PATH_TOKENS = {
   home: "{{stellaris:home}}",
@@ -1196,67 +1401,75 @@ var SERVER_TOKEN = "{{stellaris:server}}";
 var WORKSPACE_TOKEN = "{{stellaris:workspace}}";
 var HOME_SCRATCH = "scratch";
 var HOME_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var RunnerHelloSchema = z7.object({
-  protocol: z7.number().int().positive(),
-  version: z7.string().min(1),
+var RunnerHelloSchema = z8.object({
+  protocol: z8.number().int().positive(),
+  version: z8.string().min(1),
   os: RunnerOsSchema,
-  clis: z7.array(CliKindSchema),
+  clis: z8.array(CliKindSchema),
   /** The CLIs whose adapter can keep a session warm between turns. */
-  residentClis: z7.array(CliKindSchema).default([]),
+  residentClis: z8.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can take input into a running turn; the server steers only these. */
-  steerableClis: z7.array(CliKindSchema).default([]),
+  steerableClis: z8.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can stop a running turn; the server stops only these. */
-  stoppableClis: z7.array(CliKindSchema).default([]),
+  stoppableClis: z8.array(CliKindSchema).default([]),
   /** Whether the runner answers file reads on its projects' branches; one from before never does. */
-  branchReads: z7.boolean().default(false),
+  branchReads: z8.boolean().default(false),
   /** Whether the runner lists what a branch changed; one from before never does. */
-  branchChanges: z7.boolean().default(false),
-  capabilities: z7.array(z7.string()).default([]),
+  branchChanges: z8.boolean().default(false),
+  /** Whether the runner answers a read of a CLI's quota; one from before never does. */
+  quotaReads: z8.boolean().default(false),
+  capabilities: z8.array(z8.string()).default([]),
+  /**
+   * What the runner's account lacks of the git identity citizens' own commits carry, checked
+   * before each hello outside any repository; empty when it has both. Absent from a runner from
+   * before the check, which no default fills in, so the board marks only what a runner reported.
+   */
+  gitIdentityMissing: z8.array(GitIdentityPartSchema).optional(),
   /** Turns the runner runs at once, or null for no limit. */
-  slots: z7.number().int().positive().nullable(),
+  slots: z8.number().int().positive().nullable(),
   /** Turns the runner is still running, when it registers again; the server fails the rest of its turns. */
-  turns: z7.array(UlidSchema).default([])
+  turns: z8.array(UlidSchema).default([])
 });
-var RunnerWelcomeSchema = z7.object({ name: NameSchema, version: z7.string() });
-var RunnerEnrollRequestSchema = z7.object({
-  protocol: z7.number().int().positive(),
-  version: z7.string().min(1).max(64),
-  hostname: z7.string().min(1).max(253),
+var RunnerWelcomeSchema = z8.object({ name: NameSchema, version: z8.string() });
+var RunnerEnrollRequestSchema = z8.object({
+  protocol: z8.number().int().positive(),
+  version: z8.string().min(1).max(64),
+  hostname: z8.string().min(1).max(253),
   os: RunnerOsSchema,
-  clis: z7.array(CliKindSchema).max(8),
-  capabilities: z7.array(z7.string().min(1).max(64)).max(32).default([])
+  clis: z8.array(CliKindSchema).max(8),
+  capabilities: z8.array(z8.string().min(1).max(64)).max(32).default([])
 });
-var RunnerEnrollmentSchema = z7.object({
-  deviceCode: z7.string().min(1),
-  userCode: z7.string().min(1),
+var RunnerEnrollmentSchema = z8.object({
+  deviceCode: z8.string().min(1),
+  userCode: z8.string().min(1),
   expiresAt: IsoDateTimeSchema,
-  intervalMs: z7.number().int().positive()
+  intervalMs: z8.number().int().positive()
 });
-var RunnerEnrollPollSchema = z7.object({ deviceCode: z7.string().min(1) });
-var RunnerEnrollStatusSchema = z7.discriminatedUnion("status", [
-  z7.object({ status: z7.literal("pending") }),
-  z7.object({ status: z7.literal("approved"), name: NameSchema, token: z7.string().min(1) }),
-  z7.object({ status: z7.literal("denied") })
+var RunnerEnrollPollSchema = z8.object({ deviceCode: z8.string().min(1) });
+var RunnerEnrollStatusSchema = z8.discriminatedUnion("status", [
+  z8.object({ status: z8.literal("pending") }),
+  z8.object({ status: z8.literal("approved"), name: NameSchema, token: z8.string().min(1) }),
+  z8.object({ status: z8.literal("denied") })
 ]);
-var PendingEnrollmentSchema = z7.object({
-  userCode: z7.string().min(1),
-  hostname: z7.string(),
+var PendingEnrollmentSchema = z8.object({
+  userCode: z8.string().min(1),
+  hostname: z8.string(),
   os: RunnerOsSchema,
-  clis: z7.array(CliKindSchema),
-  capabilities: z7.array(z7.string()),
-  version: z7.string(),
+  clis: z8.array(CliKindSchema),
+  capabilities: z8.array(z8.string()),
+  version: z8.string(),
   requestedAt: IsoDateTimeSchema,
   expiresAt: IsoDateTimeSchema
 });
-var ProjectRepoSchema = z7.object({
+var ProjectRepoSchema = z8.object({
   slug: NameSchema,
-  origin: z7.string().nullable(),
-  defaultBranch: z7.string().min(1),
+  origin: z8.string().nullable(),
+  defaultBranch: z8.string().min(1),
   /**
    * The board lands finished tasks on the default branch, itself or through their pull requests,
    * so the runner lets nothing else move it.
    */
-  boardLands: z7.boolean()
+  boardLands: z8.boolean()
 });
 function projectRepo(project) {
   return {
@@ -1266,29 +1479,29 @@ function projectRepo(project) {
     boardLands: project.onDone !== "none"
   };
 }
-var TurnWorkspaceSchema = z7.discriminatedUnion("kind", [
-  z7.object({
-    kind: z7.literal("home"),
+var TurnWorkspaceSchema = z8.discriminatedUnion("kind", [
+  z8.object({
+    kind: z8.literal("home"),
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  z7.object({
-    kind: z7.literal("project"),
+  z8.object({
+    kind: z8.literal("project"),
     repo: ProjectRepoSchema,
-    branches: z7.array(z7.string().min(1)),
+    branches: z8.array(z8.string().min(1)),
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  z7.object({ kind: z7.literal("task"), repo: ProjectRepoSchema, taskId: UlidSchema })
+  z8.object({ kind: z8.literal("task"), repo: ProjectRepoSchema, taskId: UlidSchema })
 ]);
-var TurnJobSchema = z7.object({
+var TurnJobSchema = z8.object({
   turnId: UlidSchema,
   agent: NameSchema,
   role: NameSchema,
   cli: CliKindSchema,
-  model: z7.string().optional(),
+  model: z8.string().optional(),
   /** The reasoning effort set on the agent; absent for the model's own default. */
-  effort: z7.string().optional(),
+  effort: z8.string().optional(),
   /** A project slug, or the society scope. */
   scope: NameSchema,
   /** The thread whose conversation the turn is in; absent for the home conversation. */
@@ -1299,125 +1512,130 @@ var TurnJobSchema = z7.object({
    * The session to resume, or null to start one: the CLI's adapter picks a fresh session's id, and
    * the outcome reports it.
    */
-  session: z7.string().min(1).nullable(),
+  session: z8.string().min(1).nullable(),
   /** The running total the session reported after its last turn, which a resumed session starts from. */
-  costSoFarUsd: z7.number().nonnegative(),
+  costSoFarUsd: z8.number().nonnegative(),
   /** The rendered charter, norms, memory core, and skills index, with `PATH_TOKENS` for places. */
-  instructions: z7.string(),
-  prompt: z7.string(),
-  mcp: z7.object({ url: z7.string().min(1), token: z7.string().min(1) }),
-  limits: z7.object({
-    timeoutMs: z7.number().int().positive().nullable(),
-    maxTurns: z7.number().int().positive().nullable()
+  instructions: z8.string(),
+  prompt: z8.string(),
+  mcp: z8.object({ url: z8.string().min(1), token: z8.string().min(1) }),
+  limits: z8.object({
+    timeoutMs: z8.number().int().positive().nullable(),
+    maxTurns: z8.number().int().positive().nullable()
   }),
   /** Present when the runner keeps the conversation's session warm between turns, under `key`. */
-  resident: z7.object({ key: z7.string().min(1), idleMs: z7.number().int().positive() }).optional(),
+  resident: z8.object({ key: z8.string().min(1), idleMs: z8.number().int().positive() }).optional(),
   workspace: TurnWorkspaceSchema
 });
-var TurnWorkSchema = z7.object({ branch: z7.string().min(1), head: z7.string().min(1) });
-var TurnEventsSchema = z7.object({ entries: z7.array(TranscriptEntrySchema) });
-var TurnOutcomeSchema = z7.object({
+var TurnWorkSchema = z8.object({ branch: z8.string().min(1), head: z8.string().min(1) });
+var TurnEventsSchema = z8.object({ entries: z8.array(TranscriptEntrySchema) });
+var TurnOutcomeSchema = z8.object({
   exitReason: TurnExitReasonSchema,
   status: TurnStatusSchema.nullable(),
-  error: z7.string().nullable(),
+  error: z8.string().nullable(),
   usage: UsageSchema,
-  costUsd: z7.number().nonnegative(),
+  costUsd: z8.number().nonnegative(),
   /** The session's running total after this turn, for CLIs that report one. */
-  sessionCostUsd: z7.number().nonnegative().optional(),
+  sessionCostUsd: z8.number().nonnegative().optional(),
   /** The session the CLI used, which differs from the job's for CLIs that assign their own ids. */
-  session: z7.string().min(1),
+  session: z8.string().min(1),
   /** The model the CLI reported, when it reported one. */
-  model: z7.string().nullable(),
+  model: z8.string().nullable(),
   work: TurnWorkSchema.nullable(),
   /**
    * Whether the turn's own workspace, a thread's, a channel's, or a task's, holds work on no
    * branch after the hand-back: uncommitted changes, or commits no branch contains.
    */
-  leftovers: z7.boolean().default(false)
+  leftovers: z8.boolean().default(false),
+  /**
+   * The CLI's plan quota as the turn's stream last reported it, when it reported any; a runner from
+   * before never sends it.
+   */
+  quota: CliQuotaSchema.optional()
 });
-var TurnAckSchema = z7.object({ dropWorkspace: z7.boolean() });
-var LandRequestSchema = z7.object({
+var TurnAckSchema = z8.object({ dropWorkspace: z8.boolean() });
+var LandRequestSchema = z8.object({
   repo: ProjectRepoSchema,
-  branch: z7.string().min(1),
+  branch: z8.string().min(1),
   /**
    * For a `ghpr` task, the pull request to merge in place of the branch, which must hold the
    * branch's files, and the merge commit's subject and body, the pull request's title and an
    * empty body when left out.
    */
-  pullRequest: z7.object({
-    url: z7.string().min(1),
-    subject: z7.string().min(1).optional(),
-    body: z7.string().optional()
+  pullRequest: z8.object({
+    url: z8.string().min(1),
+    subject: z8.string().min(1).optional(),
+    body: z8.string().optional()
   }).optional()
 });
-var CloseRequestSchema = z7.object({
+var CloseRequestSchema = z8.object({
   repo: ProjectRepoSchema,
-  url: z7.string().min(1),
-  comment: z7.string().min(1)
+  url: z8.string().min(1),
+  comment: z8.string().min(1)
 });
-var MergeOutcomeSchema = z7.object({ ok: z7.boolean(), detail: z7.string() });
-var ModelListSchema = z7.array(ModelOptionSchema);
+var MergeOutcomeSchema = z8.object({ ok: z8.boolean(), detail: z8.string() });
+var ModelListSchema = z8.array(ModelOptionSchema);
 var BRANCH_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var BranchPathSchema = z7.string().max(4096).refine((value) => value === "" || value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".." && !segment.includes("\0")), { message: "a path inside the branch, with no empty, `.`, or `..` segment" });
-var BranchNameSchema = z7.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/);
-var BranchReadSchema = z7.object({
+var BranchPathSchema = z8.string().max(4096).refine((value) => value === "" || value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".." && !segment.includes("\0")), { message: "a path inside the branch, with no empty, `.`, or `..` segment" });
+var BranchNameSchema = z8.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/);
+var BranchReadSchema = z8.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema,
   path: BranchPathSchema
 });
-var BranchCommitSchema = z7.object({
-  id: z7.string().min(1),
+var BranchCommitSchema = z8.object({
+  id: z8.string().min(1),
   at: IsoDateTimeSchema,
-  author: z7.string()
+  author: z8.string()
 });
-var BranchFileSchema = z7.discriminatedUnion("kind", [
-  z7.object({
-    kind: z7.literal("file"),
+var BranchFileSchema = z8.discriminatedUnion("kind", [
+  z8.object({
+    kind: z8.literal("file"),
     path: BranchPathSchema,
     commit: BranchCommitSchema,
-    size: z7.number().int().nonnegative(),
-    content: z7.string().nullable()
+    size: z8.number().int().nonnegative(),
+    content: z8.string().nullable()
   }),
-  z7.object({
-    kind: z7.literal("dir"),
+  z8.object({
+    kind: z8.literal("dir"),
     path: BranchPathSchema,
     commit: BranchCommitSchema,
-    entries: z7.array(z7.object({
-      name: z7.string().min(1),
-      kind: z7.enum(["file", "dir"]),
-      size: z7.number().int().nonnegative().nullable()
+    entries: z8.array(z8.object({
+      name: z8.string().min(1),
+      kind: z8.enum(["file", "dir"]),
+      size: z8.number().int().nonnegative().nullable()
     }))
   })
 ]);
-var BranchChangesReadSchema = z7.object({
+var BranchChangesReadSchema = z8.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema
 });
-var BranchFileChangeSchema = z7.object({
-  path: z7.string().min(1),
-  status: z7.enum(["added", "modified", "deleted"]),
+var BranchFileChangeSchema = z8.object({
+  path: z8.string().min(1),
+  status: z8.enum(["added", "modified", "deleted"]),
   /** Lines added and removed, or null for a binary file. */
-  added: z7.number().int().nonnegative().nullable(),
-  removed: z7.number().int().nonnegative().nullable(),
+  added: z8.number().int().nonnegative().nullable(),
+  removed: z8.number().int().nonnegative().nullable(),
   /** Absent when the file changed only through a merge of another branch. */
-  lastChange: z7.object({ author: z7.string(), at: IsoDateTimeSchema }).optional()
+  lastChange: z8.object({ author: z8.string(), at: IsoDateTimeSchema }).optional()
 });
-var BranchChangesSchema = z7.object({
+var BranchChangesSchema = z8.object({
   head: BranchCommitSchema,
-  files: z7.array(BranchFileChangeSchema),
-  total: z7.number().int().nonnegative()
+  files: z8.array(BranchFileChangeSchema),
+  total: z8.number().int().nonnegative()
 });
-var BranchDiffReadSchema = z7.object({
+var BranchDiffReadSchema = z8.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema,
   path: BranchPathSchema.min(1)
 });
-var BranchFileDiffSchema = z7.object({
+var BranchFileDiffSchema = z8.object({
   head: BranchCommitSchema,
   path: BranchPathSchema,
   status: BranchFileChangeSchema.shape.status,
-  patch: z7.string().nullable(),
-  truncated: z7.boolean()
+  patch: z8.string().nullable(),
+  truncated: z8.boolean()
 });
 function patchHunks(patch, limit2) {
   if (/^Binary files .* differ$/m.test(patch)) {
@@ -1431,9 +1649,9 @@ function patchHunks(patch, limit2) {
   const cut = hunks.lastIndexOf("\n", limit2);
   return { patch: hunks.slice(0, cut === -1 ? limit2 : cut), truncated: true };
 }
-var WorkspaceConversationSchema = z7.discriminatedUnion("kind", [
-  z7.object({ kind: z7.literal("thread"), id: UlidSchema }),
-  z7.object({ kind: z7.literal("channel"), scope: NameSchema, name: NameSchema })
+var WorkspaceConversationSchema = z8.discriminatedUnion("kind", [
+  z8.object({ kind: z8.literal("thread"), id: UlidSchema }),
+  z8.object({ kind: z8.literal("channel"), scope: NameSchema, name: NameSchema })
 ]);
 function workspaceConversationOf(turn) {
   if (turn.thread !== void 0) {
@@ -1441,60 +1659,65 @@ function workspaceConversationOf(turn) {
   }
   return turn.channel === void 0 ? null : { kind: "channel", scope: turn.scope, name: turn.channel };
 }
-var HeldWorkspaceSchema = z7.object({
+var HeldWorkspaceSchema = z8.object({
   agent: NameSchema,
   scope: NameSchema,
   conversation: WorkspaceConversationSchema
 });
-var HeldWorkspacesSchema = z7.object({ workspaces: z7.array(HeldWorkspaceSchema) });
-var SweepResultSchema = z7.object({ kept: z7.array(HeldWorkspaceSchema) });
-var TurnSteerSchema = z7.object({ id: z7.uuid(), text: z7.string().min(1) });
-var RunnerMessageSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("turn"), job: TurnJobSchema }),
-  z7.object({ type: z7.literal("land"), request: z7.string().min(1), land: LandRequestSchema }),
+var HeldWorkspacesSchema = z8.object({ workspaces: z8.array(HeldWorkspaceSchema) });
+var SweepResultSchema = z8.object({ kept: z8.array(HeldWorkspaceSchema) });
+var TurnSteerSchema = z8.object({ id: z8.uuid(), text: z8.string().min(1) });
+var RunnerMessageSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("turn"), job: TurnJobSchema }),
+  z8.object({ type: z8.literal("land"), request: z8.string().min(1), land: LandRequestSchema }),
   /** Answered with a `MergeOutcome`. */
-  z7.object({ type: z7.literal("close"), request: z7.string().min(1), close: CloseRequestSchema }),
-  z7.object({ type: z7.literal("models"), request: z7.string().min(1), cli: CliKindSchema }),
+  z8.object({ type: z8.literal("close"), request: z8.string().min(1), close: CloseRequestSchema }),
+  z8.object({ type: z8.literal("models"), request: z8.string().min(1), cli: CliKindSchema }),
+  /**
+   * Answered with a `CliQuota` read from the CLI without a turn, or null when its adapter cannot
+   * read one. Sent only to runners whose hello says `quotaReads`.
+   */
+  z8.object({ type: z8.literal("quota"), request: z8.string().min(1), cli: CliKindSchema }),
   /** Answered with a `BranchFile`, or null when the branch or the path does not exist. */
-  z7.object({ type: z7.literal("file"), request: z7.string().min(1), read: BranchReadSchema }),
+  z8.object({ type: z8.literal("file"), request: z8.string().min(1), read: BranchReadSchema }),
   /** Answered with `BranchChanges`, or null when the repository or the branch does not exist. */
-  z7.object({
-    type: z7.literal("changes"),
-    request: z7.string().min(1),
+  z8.object({
+    type: z8.literal("changes"),
+    request: z8.string().min(1),
     read: BranchChangesReadSchema
   }),
   /** Answered with a `BranchFileDiff`, or null when the branch does not exist or left the path alone. */
-  z7.object({ type: z7.literal("diff"), request: z7.string().min(1), read: BranchDiffReadSchema }),
+  z8.object({ type: z8.literal("diff"), request: z8.string().min(1), read: BranchDiffReadSchema }),
   /** Answered with whether the CLI accepted it; that it took it comes as a `steered` event. */
-  z7.object({
-    type: z7.literal("steer"),
-    request: z7.string().min(1),
+  z8.object({
+    type: z8.literal("steer"),
+    request: z8.string().min(1),
     turnId: UlidSchema,
     steer: TurnSteerSchema
   }),
   /** Answered with whether the turn was there to stop; it ends `stopped`. */
-  z7.object({ type: z7.literal("stop"), request: z7.string().min(1), turnId: UlidSchema }),
+  z8.object({ type: z8.literal("stop"), request: z8.string().min(1), turnId: UlidSchema }),
   /**
    * A conversation ended: the runner removes every citizen's workspace for it but those a turn
    * still uses, and answers with a `SweepResult` naming those it kept for holding work on no branch.
    */
-  z7.object({
-    type: z7.literal("sweep"),
-    request: z7.string().min(1),
+  z8.object({
+    type: z8.literal("sweep"),
+    request: z8.string().min(1),
     conversation: WorkspaceConversationSchema
   })
 ]);
-var RunnerAnswerSchema = z7.discriminatedUnion("ok", [
-  z7.object({ ok: z7.literal(true), value: z7.unknown() }),
-  z7.object({ ok: z7.literal(false), error: z7.string() })
+var RunnerAnswerSchema = z8.discriminatedUnion("ok", [
+  z8.object({ ok: z8.literal(true), value: z8.unknown() }),
+  z8.object({ ok: z8.literal(false), error: z8.string() })
 ]);
-var WarmSessionsSchema = z7.object({ warm: z7.array(z7.string()) });
-var FileManifestSchema = z7.object({ files: z7.record(z7.string(), z7.string()) });
+var WarmSessionsSchema = z8.object({ warm: z8.array(z8.string()) });
+var FileManifestSchema = z8.object({ files: z8.record(z8.string(), z8.string()) });
 function fileVersion(sha, executable) {
   return executable ? `${sha}+x` : sha;
 }
-var FileReadSchema = z7.object({ paths: z7.array(z7.string()) });
-var FileContentsSchema = z7.object({ files: z7.record(z7.string(), z7.string()) });
+var FileReadSchema = z8.object({ paths: z8.array(z8.string()) });
+var FileContentsSchema = z8.object({ files: z8.record(z8.string(), z8.string()) });
 function isSafeRelativePath(file) {
   if (file.length === 0 || file.startsWith("/") || file.includes("\\") || file.includes("\0")) {
     return false;
@@ -1503,7 +1726,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z8.enum([
+var TriggerKindSchema = z9.enum([
   "mention",
   "stage",
   "task_done",
@@ -1517,11 +1740,11 @@ var TriggerKindSchema = z8.enum([
   "closing",
   "cron"
 ]);
-var TriggerSchema = z8.object({
+var TriggerSchema = z9.object({
   kind: TriggerKindSchema,
   from: NameSchema.optional(),
-  fromUser: z8.boolean().default(false),
-  reason: z8.string().default(""),
+  fromUser: z9.boolean().default(false),
+  reason: z9.string().default(""),
   taskId: UlidSchema.optional(),
   messageId: UlidSchema.optional(),
   /** The channel the waking message was posted in. */
@@ -1529,17 +1752,17 @@ var TriggerSchema = z8.object({
   /** The cron that came due, for a `cron` wake. */
   cronId: UlidSchema.optional()
 });
-var TurnThreadSchema = z8.object({ id: UlidSchema, task: z8.boolean() });
-var TurnDispatchSchema = z8.object({
+var TurnThreadSchema = z9.object({ id: UlidSchema, task: z9.boolean() });
+var TurnDispatchSchema = z9.object({
   agent: NameSchema,
   project: NameSchema,
   thread: TurnThreadSchema.optional(),
   channel: NameSchema.optional(),
   trigger: TriggerSchema,
-  priority: z8.number().int().min(0).max(2),
-  onboarding: z8.boolean().default(false),
+  priority: z9.number().int().min(0).max(2),
+  onboarding: z9.boolean().default(false),
   /** Every cron that came due for this turn, whatever wake it merged into; its prompt quotes each. */
-  crons: z8.array(UlidSchema).optional()
+  crons: z9.array(UlidSchema).optional()
 });
 function conversationPart(conversation) {
   return conversation.thread ?? (conversation.channel === void 0 ? void 0 : `#${conversation.channel}`);
@@ -1563,7 +1786,7 @@ function channelConversation(scope, channel) {
   const name = at < 0 ? channel : channel.slice(at + 1);
   return place === scope && name !== "general" ? name : void 0;
 }
-var TurnRecordSchema = z8.object({
+var TurnRecordSchema = z9.object({
   /** Assigned by the board when the turn begins; the turn's transcript is filed under it. */
   id: UlidSchema.optional(),
   agent: NameSchema,
@@ -1574,31 +1797,31 @@ var TurnRecordSchema = z8.object({
   channel: NameSchema.optional(),
   runner: NameSchema,
   cli: CliKindSchema.nullable(),
-  session: z8.string().nullable(),
+  session: z9.string().nullable(),
   trigger: TriggerSchema,
   startedAt: IsoDateTimeSchema,
   endedAt: IsoDateTimeSchema.nullable(),
   exitReason: TurnExitReasonSchema.nullable(),
   status: TurnStatusSchema.nullable(),
-  error: z8.string().nullable(),
+  error: z9.string().nullable(),
   usage: UsageSchema.nullable(),
-  costUsd: z8.number().nonnegative().default(0),
+  costUsd: z9.number().nonnegative().default(0),
   /**
    * The running total the CLI reported for the session after this turn, when it reports one. A
    * resumed session starts from it, so the next turn's own cost is measured from here.
    */
-  sessionCostUsd: z8.number().nonnegative().optional(),
-  toolCalls: z8.number().int().nonnegative().default(0),
+  sessionCostUsd: z9.number().nonnegative().optional(),
+  toolCalls: z9.number().int().nonnegative().default(0),
   /** The model the CLI reported for this turn, else the model configured for the agent, else null. */
-  model: z8.string().nullable().default(null),
+  model: z9.string().nullable().default(null),
   /** The task branch the turn left work on, with its commit, as the runner reported it. */
   work: TurnWorkSchema.optional(),
   /** Who stopped the turn, for one that ended `stopped`. */
   stoppedBy: NameSchema.optional(),
   /** The crons whose fire started the turn, which record how it ended. */
-  crons: z8.array(UlidSchema).optional()
+  crons: z9.array(UlidSchema).optional()
 });
-var RunningTurnSchema = z8.object({
+var RunningTurnSchema = z9.object({
   turnId: UlidSchema,
   agent: NameSchema,
   scope: NameSchema,
@@ -1606,49 +1829,49 @@ var RunningTurnSchema = z8.object({
   channel: NameSchema.optional(),
   cli: CliKindSchema,
   askedIn: ChannelRefSchema.optional(),
-  steerable: z8.boolean(),
-  stoppable: z8.boolean()
+  steerable: z9.boolean(),
+  stoppable: z9.boolean()
 });
-var SessionsFileSchema = z8.object({
-  claude: z8.string().optional(),
-  codex: z8.string().optional(),
+var SessionsFileSchema = z9.object({
+  claude: z9.string().optional(),
+  codex: z9.string().optional(),
   runner: NameSchema.optional()
 });
-var WakeRequestSchema = z8.object({
+var WakeRequestSchema = z9.object({
   agent: NameSchema,
   project: NameSchema,
-  reason: z8.string().default("manual wake"),
+  reason: z9.string().default("manual wake"),
   /** A manual wake, or a reflection turn requested ahead of the cadence. */
-  kind: z8.enum(["manual", "reflection"]).default("manual")
+  kind: z9.enum(["manual", "reflection"]).default("manual")
 });
-var TurnHistoryEntrySchema = z8.object({
+var TurnHistoryEntrySchema = z9.object({
   /** The id of the event that ended the turn. */
   id: UlidSchema,
   /** The turn's own id, when it has a transcript to open; turns before transcripts have none. */
   turnId: UlidSchema.optional(),
   ts: IsoDateTimeSchema,
-  outcome: z8.enum(["completed", "failed"]),
+  outcome: z9.enum(["completed", "failed"]),
   /** A project slug, or the society scope. */
   project: NameSchema,
   /** The thread whose conversation the turn was in; absent for the home conversation. */
   thread: UlidSchema.optional(),
   /** The channel, never general, whose conversation the turn was in. */
   channel: NameSchema.optional(),
-  trigger: z8.string(),
-  exitReason: z8.string().nullable(),
-  costUsd: z8.number(),
+  trigger: z9.string(),
+  exitReason: z9.string().nullable(),
+  costUsd: z9.number(),
   /** The tokens the turn used; absent for turns logged before turns recorded them. */
   usage: UsageSchema.optional(),
-  model: z8.string().nullable(),
-  summary: z8.string().nullable(),
-  error: z8.string().nullable(),
+  model: z9.string().nullable(),
+  summary: z9.string().nullable(),
+  error: z9.string().nullable(),
   /** When the log recorded the turn's start; absent when the start is missing from the log. */
   startedAt: IsoDateTimeSchema.optional(),
-  toolCalls: z8.number().int().nonnegative().optional()
+  toolCalls: z9.number().int().nonnegative().optional()
 });
 
 // packages/shared/dist/ops.js
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var OPS_SIGNAL_KINDS = [
   "waiting_stage",
   "backlog",
@@ -1664,7 +1887,7 @@ var OPS_SIGNAL_KINDS = [
   "stuck_workspace",
   "cron_failing"
 ];
-var OpsSignalKindSchema = z9.enum(OPS_SIGNAL_KINDS);
+var OpsSignalKindSchema = z10.enum(OPS_SIGNAL_KINDS);
 var WAKING_SIGNAL_KINDS = [
   "backlog",
   "role_gap",
@@ -1674,15 +1897,15 @@ var WAKING_SIGNAL_KINDS = [
   "blocked_capability",
   "scaled"
 ];
-var OpsSignalSchema = z9.object({
+var OpsSignalSchema = z10.object({
   kind: OpsSignalKindSchema,
   /** Identifies the condition, for example `backlog:demo:engineer`, so a persisting one is not logged again every pass. */
-  key: z9.string().min(1),
+  key: z10.string().min(1),
   /** One line a reader can act on. */
-  summary: z9.string().min(1),
+  summary: z10.string().min(1),
   /** The counter or timer value behind the signal. */
-  value: z9.number(),
-  threshold: z9.number().optional(),
+  value: z10.number(),
+  threshold: z10.number().optional(),
   project: NameSchema.optional(),
   agent: NameSchema.optional(),
   role: NameSchema.optional(),
@@ -1690,8 +1913,8 @@ var OpsSignalSchema = z9.object({
 });
 
 // packages/shared/dist/metrics.js
-import { z as z10 } from "zod";
-var MetricsWindowSchema = z10.enum(["24h", "7d", "all"]);
+import { z as z11 } from "zod";
+var MetricsWindowSchema = z11.enum(["24h", "7d", "all"]);
 var METRICS_WINDOW_MS = {
   "24h": 24 * 36e5,
   "7d": 7 * 24 * 36e5,
@@ -1702,9 +1925,9 @@ function isBoardAction(tool) {
   const verb = /^mcp__board__(.+)$/.exec(tool)?.[1];
   return verb !== void 0 && !READ_VERBS.some((read2) => read2 === verb);
 }
-var CountSchema = z10.number().int().nonnegative();
-var MsSchema = z10.number().nonnegative();
-var MetricsSchema = z10.object({
+var CountSchema = z11.number().int().nonnegative();
+var MsSchema = z11.number().nonnegative();
+var MetricsSchema = z11.object({
   window: MetricsWindowSchema,
   since: IsoDateTimeSchema.nullable(),
   until: IsoDateTimeSchema,
@@ -1712,12 +1935,12 @@ var MetricsSchema = z10.object({
    * Finished turns that changed nothing on the board. Reflections are left out, since they write
    * memory, not the board; turns without a transcript are counted apart, their actions unknown.
    */
-  idle: z10.object({
+  idle: z11.object({
     turns: CountSchema,
     idle: CountSchema,
     unknown: CountSchema,
-    byTrigger: z10.array(z10.object({ trigger: z10.string(), turns: CountSchema, idle: CountSchema })),
-    byAgent: z10.array(z10.object({
+    byTrigger: z11.array(z11.object({ trigger: z11.string(), turns: CountSchema, idle: CountSchema })),
+    byAgent: z11.array(z11.object({
       agent: NameSchema,
       role: NameSchema.nullable(),
       turns: CountSchema,
@@ -1725,33 +1948,33 @@ var MetricsSchema = z10.object({
     }))
   }),
   /** Work sent back to an earlier stage: over the tasks finished in the window, and by where. */
-  sentBack: z10.object({
+  sentBack: z11.object({
     finished: CountSchema,
     sendBacks: CountSchema,
     tasksSentBack: CountSchema,
-    byStage: z10.array(z10.object({ project: NameSchema, stage: z10.string(), count: CountSchema })),
-    bySender: z10.array(z10.object({ agent: NameSchema, count: CountSchema }))
+    byStage: z11.array(z11.object({ project: NameSchema, stage: z11.string(), count: CountSchema })),
+    bySender: z11.array(z11.object({ agent: NameSchema, count: CountSchema }))
   }),
   /** Posts in the threads of the tasks finished in the window, the board's own notices left out. */
-  messages: z10.object({
+  messages: z11.object({
     finished: CountSchema,
     messages: CountSchema,
-    byProject: z10.array(z10.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
-    busiest: z10.array(z10.object({
+    byProject: z11.array(z11.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
+    busiest: z11.array(z11.object({
       taskId: UlidSchema,
-      title: z10.string(),
+      title: z11.string(),
       project: NameSchema,
       messages: CountSchema
     }))
   }),
   /** Time from a mention to the start of the turn it woke, in the conversation it was made in. */
-  latency: z10.object({
+  latency: z11.object({
     mentions: CountSchema,
     /** Mentions no turn has followed yet. */
     unanswered: CountSchema,
     medianMs: MsSchema.nullable(),
     slowestMs: MsSchema.nullable(),
-    byAgent: z10.array(z10.object({
+    byAgent: z11.array(z11.object({
       agent: NameSchema,
       mentions: CountSchema,
       medianMs: MsSchema,
@@ -1759,61 +1982,73 @@ var MetricsSchema = z10.object({
     }))
   }),
   /** The user's decisions: proposals decided, questions answered, and stages passed or sent back. */
-  decisions: z10.object({
+  decisions: z11.object({
     total: CountSchema,
-    byDay: z10.array(z10.object({
-      day: z10.string(),
+    byDay: z11.array(z11.object({
+      day: z11.string(),
       proposals: CountSchema,
       answers: CountSchema,
       stages: CountSchema
     }))
   }),
   /** Tasks that needed a capability no connected runner offered, and whether they still do. */
-  blocked: z10.array(z10.object({
+  blocked: z11.array(z11.object({
     taskId: UlidSchema,
-    title: z10.string().nullable(),
+    title: z11.string().nullable(),
     project: NameSchema.nullable(),
-    summary: z10.string(),
+    summary: z11.string(),
     firstAt: IsoDateTimeSchema,
     lastAt: IsoDateTimeSchema,
-    holds: z10.boolean()
+    holds: z11.boolean()
   }))
 });
+var CitizenTokensSchema = z11.object({
+  agent: NameSchema,
+  turns: CountSchema,
+  withUsage: CountSchema,
+  usage: UsageSchema.nullable()
+});
+var TokenUseSchema = z11.object({
+  window: MetricsWindowSchema,
+  since: IsoDateTimeSchema.nullable(),
+  until: IsoDateTimeSchema,
+  citizens: z11.array(CitizenTokensSchema)
+});
 
 // packages/shared/dist/config.js
-import { z as z11 } from "zod";
-var LogLevelSchema = z11.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
-var GithubSignInSchema = z11.object({
-  clientId: z11.string().min(1),
-  clientSecret: z11.string().min(1),
+import { z as z12 } from "zod";
+var LogLevelSchema = z12.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
+var GithubSignInSchema = z12.object({
+  clientId: z12.string().min(1),
+  clientSecret: z12.string().min(1),
   /** Logins, lowercased; GitHub logins are case-insensitive. */
-  users: z11.array(z11.string().min(1)).min(1)
+  users: z12.array(z12.string().min(1)).min(1)
 });
-var ServerConfigSchema = z11.object({
-  dataDir: z11.string().min(1),
-  host: z11.string().min(1),
-  port: z11.number().int().positive().max(65535),
+var ServerConfigSchema = z12.object({
+  dataDir: z12.string().min(1),
+  host: z12.string().min(1),
+  port: z12.number().int().positive().max(65535),
   /**
    * An address every runner's agents reach this server at, for example https://board.example, or
    * null for each runner to use the address it reaches the server at itself.
    */
-  publicUrl: z11.string().min(1).nullable(),
+  publicUrl: z12.string().min(1).nullable(),
   logLevel: LogLevelSchema,
   /** Turns running at once across every runner, or null for no limit beyond each runner's own. */
-  concurrency: z11.number().int().positive().nullable(),
+  concurrency: z12.number().int().positive().nullable(),
   /** How long one turn may run before it is stopped, or null for no limit. */
-  turnTimeoutMs: z11.number().int().positive().nullable(),
+  turnTimeoutMs: z12.number().int().positive().nullable(),
   /** Rounds of tool calls one Claude turn may take, or null for no limit. */
-  toolRounds: z11.number().int().positive().nullable(),
+  toolRounds: z12.number().int().positive().nullable(),
   /** How long a resident session stays warm after its last turn. */
-  residentIdleMs: z11.number().int().positive(),
+  residentIdleMs: z12.number().int().positive(),
   /** Signing in to the board with GitHub, or null when only a token lets anyone in. */
   github: GithubSignInSchema.nullable(),
   /**
    * Reverse proxies in front of the server whose X-Forwarded-For entries name the client, for the
    * rate limits on what anyone may ask without a token: 0 when clients connect directly.
    */
-  trustedProxies: z11.number().int().min(0).max(16)
+  trustedProxies: z12.number().int().min(0).max(16)
 });
 function limit(value, fallback) {
   if (value === void 0 || value.trim() === "") {
@@ -1851,25 +2086,73 @@ function loadServerConfig(env) {
     trustedProxies: Number(env["STELLARIS_TRUSTED_PROXIES"] ?? "0")
   });
 }
-var RunnerConfigSchema = z11.object({
+var RunnerConfigSchema = z12.object({
   /** The board server, for example http://127.0.0.1:4700. */
-  serverUrl: z11.string().url(),
+  serverUrl: z12.string().url(),
   /**
    * The runner's token, from `runner add`, or null for the one it saved when it was enrolled, or
    * to enroll it.
    */
-  token: z11.string().min(1).nullable(),
+  token: z12.string().min(1).nullable(),
   /** The runner's own data directory: the board mirror, agent homes, repositories, worktrees. */
-  dataDir: z11.string().min(1),
+  dataDir: z12.string().min(1),
   logLevel: LogLevelSchema,
   /** Turns this machine runs at once, or null for no limit. */
-  slots: z11.number().int().positive().nullable(),
-  clis: z11.array(CliKindSchema).min(1),
-  capabilities: z11.array(z11.string())
+  slots: z12.number().int().positive().nullable(),
+  clis: z12.array(CliKindSchema).min(1),
+  capabilities: z12.array(z12.string())
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.20";
+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 {
@@ -2515,33 +2798,59 @@ function filesOf(lines, status) {
   return [...files.values()];
 }
 
+// packages/board-core/dist/mentions.js
+import vm from "node:vm";
+var MENTION_PARSE_MS = 500;
+var context = vm.createContext({});
+var call = new vm.Script("work()");
+function within(work, ms) {
+  let result;
+  context["work"] = () => {
+    result = work();
+  };
+  try {
+    call.runInContext(context, { timeout: ms });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
+      return void 0;
+    }
+    throw error;
+  } finally {
+    context["work"] = void 0;
+  }
+  return result;
+}
+function postMentions(body) {
+  return within(() => mentionsIn(body), MENTION_PARSE_MS) ?? mentionsAnywhere(body);
+}
+
 // packages/board-core/dist/metrics.js
-import { z as z12 } from "zod";
-var TurnPayload = z12.object({
-  turnId: z12.string().optional(),
-  project: z12.string(),
-  thread: z12.string().optional(),
-  channel: z12.string().optional(),
-  trigger: z12.string()
+import { z as z13 } from "zod";
+var TurnPayload = z13.object({
+  turnId: z13.string().optional(),
+  project: z13.string(),
+  thread: z13.string().optional(),
+  channel: z13.string().optional(),
+  trigger: z13.string()
 });
-var TaskPayload = z12.object({
-  taskId: z12.string(),
-  project: z12.string(),
-  from: z12.string().optional()
+var TaskPayload = z13.object({
+  taskId: z13.string(),
+  project: z13.string(),
+  from: z13.string().optional()
 });
-var MessagePayload = z12.object({
-  id: z12.string().optional(),
-  channel: z12.string(),
-  thread: z12.string().nullable().optional(),
-  mentions: z12.array(z12.string()).default([])
+var MessagePayload = z13.object({
+  id: z13.string().optional(),
+  channel: z13.string(),
+  thread: z13.string().nullable().optional(),
+  mentions: z13.array(z13.string()).default([])
 });
-var SteeredPayload = z12.object({ messages: z12.array(z12.string()) });
-var SignalPayload = z12.object({
-  kind: z12.string(),
-  key: z12.string(),
-  summary: z12.string(),
-  taskId: z12.string().optional(),
-  project: z12.string().optional()
+var SteeredPayload = z13.object({ messages: z13.array(z13.string()) });
+var SignalPayload = z13.object({
+  kind: z13.string(),
+  key: z13.string(),
+  summary: z13.string(),
+  taskId: z13.string().optional(),
+  project: z13.string().optional()
 });
 function median(values) {
   const sorted = values.toSorted((a, b) => a - b);
@@ -2830,6 +3139,59 @@ function computeMetrics(input) {
   };
 }
 
+// packages/board-core/dist/turn-history.js
+import { z as z14 } from "zod";
+var TurnHistoryPayloadSchema = z14.object({
+  project: NameSchema,
+  thread: UlidSchema.optional(),
+  channel: NameSchema.optional(),
+  trigger: z14.string().default("manual"),
+  exitReason: z14.string().nullable().default(null),
+  costUsd: z14.number().default(0),
+  usage: UsageSchema.optional(),
+  model: z14.string().nullable().default(null),
+  summary: z14.string().nullable().default(null),
+  error: z14.string().nullable().default(null),
+  toolCalls: z14.number().int().nonnegative().optional(),
+  turnId: UlidSchema.optional()
+});
+function tokenUse(events, window, now) {
+  const span = METRICS_WINDOW_MS[window];
+  const since = span === null ? null : now.getTime() - span;
+  const rows = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "turn.completed" && event.type !== "turn.failed") {
+      continue;
+    }
+    if (since !== null && Date.parse(event.ts) < since) {
+      continue;
+    }
+    const turn = TurnHistoryPayloadSchema.safeParse(event.payload);
+    if (!turn.success) {
+      continue;
+    }
+    const row = rows.get(event.actor) ?? {
+      agent: event.actor,
+      turns: 0,
+      withUsage: 0,
+      usage: null
+    };
+    const usage = turn.data.usage;
+    rows.set(event.actor, {
+      agent: event.actor,
+      turns: row.turns + 1,
+      withUsage: row.withUsage + (usage === void 0 ? 0 : 1),
+      usage: usage === void 0 ? row.usage : row.usage === null ? usage : addUsage(row.usage, usage)
+    });
+  }
+  return {
+    window,
+    since: since === null ? null : new Date(since).toISOString(),
+    until: now.toISOString(),
+    citizens: [...rows.values()].toSorted((a, b) => a.agent.localeCompare(b.agent))
+  };
+}
+
 // packages/board-core/dist/mutex.js
 var Mutex = class {
   tail = Promise.resolve();
@@ -3071,41 +3433,27 @@ function namesList(names) {
   return names.length <= 1 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names.at(-1) ?? ""}`;
 }
 var SKIPPED_IN_HOME = /* @__PURE__ */ new Set([".git", "turns", ".claude", ".codex"]);
-var RunnerTokensSchema = z13.object({
-  runners: z13.record(z13.string(), z13.object({ tokenHash: z13.string().min(1) }))
+var RunnerTokensSchema = z15.object({
+  runners: z15.record(z15.string(), z15.object({ tokenHash: z15.string().min(1) }))
 });
-var SignInsSchema = z13.object({
-  signIns: z13.array(z13.object({
-    tokenHash: z13.string().min(1),
-    login: z13.string().min(1),
+var SignInsSchema = z15.object({
+  signIns: z15.array(z15.object({
+    tokenHash: z15.string().min(1),
+    login: z15.string().min(1),
     /** The account's picture at the identity provider; sign-ins from before it have none. */
-    avatarUrl: z13.url().optional(),
+    avatarUrl: z15.url().optional(),
     createdAt: IsoDateTimeSchema,
     expiresAt: IsoDateTimeSchema
   })).default([])
 });
-var TurnHistoryPayloadSchema = z13.object({
-  project: NameSchema,
-  thread: UlidSchema.optional(),
-  channel: NameSchema.optional(),
-  trigger: z13.string().default("manual"),
-  exitReason: z13.string().nullable().default(null),
-  costUsd: z13.number().default(0),
-  usage: UsageSchema.optional(),
-  model: z13.string().nullable().default(null),
-  summary: z13.string().nullable().default(null),
-  error: z13.string().nullable().default(null),
-  toolCalls: z13.number().int().nonnegative().optional(),
-  turnId: UlidSchema.optional()
-});
-var TurnStartPayloadSchema = z13.object({ project: NameSchema, turnId: UlidSchema.optional() });
-var CursorsSchema = z13.object({
-  digest: z13.string().nullable(),
-  scopes: z13.record(z13.string(), z13.string()).default({}),
-  threadsFrom: z13.record(z13.string(), z13.string().nullable()).default({}),
-  channelsFrom: z13.record(z13.string(), z13.string().nullable()).default({}),
+var TurnStartPayloadSchema = z15.object({ project: NameSchema, turnId: UlidSchema.optional() });
+var CursorsSchema = z15.object({
+  digest: z15.string().nullable(),
+  scopes: z15.record(z15.string(), z15.string()).default({}),
+  threadsFrom: z15.record(z15.string(), z15.string().nullable()).default({}),
+  channelsFrom: z15.record(z15.string(), z15.string().nullable()).default({}),
   /** How far a work role has read news, which goes to whichever of its general conversations reads first. */
-  news: z13.string().optional()
+  news: z15.string().optional()
 });
 var NO_CURSORS = { digest: null, scopes: {}, threadsFrom: {}, channelsFrom: {} };
 function conversationKey(scope, part) {
@@ -3144,9 +3492,8 @@ function byId(a, b) {
 function turnTime(record) {
   return record.endedAt ?? record.startedAt;
 }
-var PausedSchema = z13.object({ paused: z13.boolean() });
+var PausedSchema = z15.object({ paused: z15.boolean() });
 var DEFAULT_LEASE_MS = 30 * 60 * 1e3;
-var MENTION_PATTERN = /(^|[^\w@])@([a-z0-9][a-z0-9-]{0,31})(?![\w-])/g;
 function withoutMentions(text) {
   return text.replaceAll(MENTION_PATTERN, "$1$2");
 }
@@ -3170,7 +3517,7 @@ var OPS_WAKE_TRIGGER = "ops_event";
 var FRONT_DESK_TRIGGER = "user_post";
 var OPS_CHANNELS = ["governance"];
 var FRONT_DESK_CHANNELS = [ASK_CHANNEL];
-var AlignmentsSchema = z13.object({ applied: z13.array(z13.string()).default([]) });
+var AlignmentsSchema = z15.object({ applied: z15.array(z15.string()).default([]) });
 var FOLLOW_DECISIONS = "ops-readers-follow-decisions";
 var THREAD_RECORDS = "threads-as-records";
 var DIGEST_CURSORS = "digest-replaces-inbox";
@@ -3184,10 +3531,10 @@ var CHANNEL_CONVERSATIONS = "channel-conversations";
 var DASHBOARD_UPDATES = "dashboard-updates-granted";
 var CRON_VERBS = "cron-verbs-granted";
 var KNOWLEDGE_NOTICES = "knowledge-notices";
-var KnowledgeEventSchema = z13.object({
+var KnowledgeEventSchema = z15.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
-  replaced: z13.boolean().optional()
+  replaced: z15.boolean().optional()
 });
 var CRON_VERB_NAMES = ["create_cron", "update_cron", "remove_cron"];
 var OLD_DASHBOARD_LINE = "Agents may edit this file. It is rendered by the board UI.";
@@ -3305,16 +3652,6 @@ function unanswered(messages) {
   }
   return waiting;
 }
-function extractMentions(body) {
-  const found = /* @__PURE__ */ new Set();
-  for (const match of body.matchAll(MENTION_PATTERN)) {
-    const name = match[2];
-    if (name !== void 0) {
-      found.add(name);
-    }
-  }
-  return [...found].toSorted();
-}
 function snippetAround(text, query, radius = 80) {
   const index = text.toLowerCase().indexOf(query.toLowerCase());
   if (index === -1) {
@@ -3642,7 +3979,7 @@ var Board = class _Board {
         }
       }
       for (const file of await listFiles(this.paths.tasks(slug))) {
-        const raw = await readMarkdown(path6.join(this.paths.tasks(slug), file), z13.record(z13.string(), z13.unknown()));
+        const raw = await readMarkdown(path6.join(this.paths.tasks(slug), file), z15.record(z15.string(), z15.unknown()));
         const legacy = raw.data["thread"];
         if (legacy === void 0) {
           continue;
@@ -3720,7 +4057,7 @@ var Board = class _Board {
    * turns, so it follows nothing now.
    */
   async renameInboxCursors() {
-    const Legacy = z13.object({ inbox: z13.string().nullable() });
+    const Legacy = z15.object({ inbox: z15.string().nullable() });
     for (const agent of await this.listAgents()) {
       const file = this.paths.agentCursors(agent.name);
       if (await exists(file)) {
@@ -3766,7 +4103,7 @@ ${charter.purpose}
    */
   async alignSeedRole(seed) {
     const file = this.paths.role(seed.name);
-    const raw = await readMarkdown(file, z13.record(z13.string(), z13.unknown()));
+    const raw = await readMarkdown(file, z15.record(z15.string(), z15.unknown()));
     const current = RoleCharterSchema.parse(raw.data);
     const verbsAdded = seed.verbs.filter((verb) => !current.verbs.includes(verb));
     const fieldsAligned = RoleCharterSchema.keyof().options.filter((key) => key === "verbs" || seed[key] === void 0 ? false : seed.name === USER_ROLE ? JSON.stringify(seed[key]) !== JSON.stringify(current[key]) : !(key in raw.data));
@@ -4083,7 +4420,7 @@ ${charter.purpose}
   /** The society's norms, the one knowledge topic every turn loads. Empty until the steward writes it. */
   async readSocietyNorms() {
     const file = this.paths.societyKnowledgeFile("norms");
-    return await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
   }
   /** Knowledge topics of a project, or of the society when the project is null. */
   async listKnowledge(project) {
@@ -4103,7 +4440,7 @@ ${charter.purpose}
    */
   async knowledgeAt(file, project, topic) {
     const { data, body } = await readLooseMarkdown(file);
-    const revision = z13.number().int().min(0).safeParse(data["revision"]);
+    const revision = z15.number().int().min(0).safeParse(data["revision"]);
     const updatedBy = NameSchema.safeParse(data["updatedBy"]);
     const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
     return {
@@ -4436,8 +4773,11 @@ ${DASHBOARD_LINE}
         throw new BoardError("NOT_FOUND", `runner ${name} not found`);
       }
       const doc = await readMarkdown(file, RunnerSchema);
+      const { gitIdentityMissing: reported, ...rest } = doc.data;
+      const gitIdentityMissing = patch.gitIdentityMissing === void 0 ? reported : patch.gitIdentityMissing ?? void 0;
       const next = RunnerSchema.parse({
-        ...doc.data,
+        ...rest,
+        ...gitIdentityMissing === void 0 ? {} : { gitIdentityMissing: [...gitIdentityMissing] },
         ...patch.status === void 0 ? {} : { status: patch.status },
         ...patch.os === void 0 ? {} : { os: patch.os },
         ...patch.clis === void 0 ? {} : { clis: [...patch.clis] },
@@ -4465,6 +4805,36 @@ ${DASHBOARD_LINE}
       return next;
     });
   }
+  /**
+   * Records a CLI's plan quota as a runner reported it, from a turn's stream or a read, merged over
+   * what the record held. The record is written on every report, so it says when the numbers were
+   * last seen; `runner.quota` is appended only when what a reader would see changes, since every
+   * turn reports.
+   */
+  async recordQuota(name, cli, quota) {
+    return this.mutex.run(async () => {
+      const file = this.paths.runner(name);
+      if (!await exists(file)) {
+        throw new BoardError("NOT_FOUND", `runner ${name} not found`);
+      }
+      const doc = await readMarkdown(file, RunnerSchema);
+      const previous = doc.data.quotas?.[cli];
+      const merged = mergeQuota(previous, quota);
+      const next = RunnerSchema.parse({
+        ...doc.data,
+        quotas: { ...doc.data.quotas, [cli]: merged }
+      });
+      await writeMarkdown(file, next, doc.body);
+      if (quotaChanged(previous, merged)) {
+        await this.events.append("runner.quota", SYSTEM_ACTOR.name, {
+          name,
+          cli,
+          status: merged.status
+        });
+      }
+      return next;
+    });
+  }
   /**
    * Logs an operations signal as an `ops.signal` event. No channel carries it: the scheduler wakes
    * its readers from the event, the runner lists it in their prompts, and the interface's log shows
@@ -4606,18 +4976,16 @@ ${DASHBOARD_LINE}
   async readDigest(actor, input = {}) {
     const args = VerbInputs.read_inbox.parse(input);
     await this.authorize(actor, "read_inbox");
-    return this.mutex.run(async () => {
-      const stored = await this.readCursors(actor.name);
-      const from = args.since_cursor === void 0 ? stored : { ...NO_CURSORS, digest: args.since_cursor };
-      const conversation = actor.scope === void 0 ? void 0 : { scope: actor.scope, part: conversationPart(actor) ?? null };
-      const filed = (await this.digestSince(actor, from, conversation)).slice(0, args.limit);
-      if (args.advance) {
-        await this.advanceCursors(actor.name, filed);
-      }
-      const last = filed.at(-1)?.message.id;
-      const cursor = last ?? (conversation === void 0 ? from.digest : cursorOf(from, conversation.scope, conversation.part));
-      return { messages: filed.map((entry) => entry.message), cursor };
-    });
+    const { cursors: stored, upto } = await this.digestSnapshot(actor.name);
+    const from = args.since_cursor === void 0 ? stored : { ...NO_CURSORS, digest: args.since_cursor };
+    const conversation = actor.scope === void 0 ? void 0 : { scope: actor.scope, part: conversationPart(actor) ?? null };
+    const filed = (await this.digestSince(actor, from, upto, conversation)).slice(0, args.limit);
+    if (args.advance) {
+      await this.mutex.run(() => this.advanceCursors(actor.name, filed));
+    }
+    const last = filed.at(-1)?.message.id;
+    const cursor = last ?? (conversation === void 0 ? from.digest : cursorOf(from, conversation.scope, conversation.part));
+    return { messages: filed.map((entry) => entry.message), cursor };
   }
   /**
    * How many unread digest messages a member has in each conversation: a scope's home, for its
@@ -4629,28 +4997,39 @@ ${DASHBOARD_LINE}
    * whose signals that call for action wake their readers directly.
    */
   async unreadByConversation(actor) {
-    return this.mutex.run(async () => {
-      const counts = /* @__PURE__ */ new Map();
-      const unscoped = { name: actor.name, role: actor.role };
-      for (const { scope, part, message, news } of await this.digestSince(unscoped, await this.readCursors(actor.name))) {
-        if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name) {
-          continue;
-        }
-        const posted = parseChannelRef(message.channel).project ?? SOCIETY_SCOPE;
-        if (posted !== scope && scope !== SOCIETY_SCOPE) {
-          continue;
-        }
-        const key = conversationKey(scope, part);
-        const entry = counts.get(key) ?? {
-          scope,
-          thread: threadOfPart(part) ?? null,
-          channel: channelOfPart(part) ?? null,
-          count: 0
-        };
-        counts.set(key, { ...entry, count: entry.count + 1 });
+    const { cursors, upto } = await this.digestSnapshot(actor.name);
+    const counts = /* @__PURE__ */ new Map();
+    const unscoped = { name: actor.name, role: actor.role };
+    for (const { scope, part, message, news } of await this.digestSince(unscoped, cursors, upto)) {
+      if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name) {
+        continue;
       }
-      return [...counts.values()];
-    });
+      const posted = parseChannelRef(message.channel).project ?? SOCIETY_SCOPE;
+      if (posted !== scope && scope !== SOCIETY_SCOPE) {
+        continue;
+      }
+      const key = conversationKey(scope, part);
+      const entry = counts.get(key) ?? {
+        scope,
+        thread: threadOfPart(part) ?? null,
+        channel: channelOfPart(part) ?? null,
+        count: 0
+      };
+      counts.set(key, { ...entry, count: entry.count + 1 });
+    }
+    return [...counts.values()];
+  }
+  /**
+   * A reader's cursors and the id below which every message is already on disk, taken under the
+   * mutex, which a digest scan then leaves: messages carry ids from the same monotonic source and are
+   * written under the mutex, so the scan, which counts nothing newer than the mark, cannot pass over
+   * one written while it reads, and a post never waits for a scan.
+   */
+  digestSnapshot(agent) {
+    return this.mutex.run(async () => ({
+      cursors: await this.readCursors(agent),
+      upto: this.newId()
+    }));
   }
   async readCursors(agent) {
     const file = this.paths.agentCursors(agent);
@@ -4692,9 +5071,10 @@ ${DASHBOARD_LINE}
    * by the user wherever it is. With a conversation, only what is filed there: for a thread, every
    * message of the thread, since the conversation is about it; for a channel's, that channel's
    * top-level messages; for a scope's home, general's and those of a project the member is not in,
-   * since each thread and each other channel is a conversation of its own.
+   * since each thread and each other channel is a conversation of its own. Nothing newer than
+   * `upto` counts (see `digestSnapshot`).
    */
-  async digestSince(actor, cursors, conversation) {
+  async digestSince(actor, cursors, upto, conversation) {
     const conversationThread = threadOfPart(conversation?.part);
     if (conversation !== void 0 && conversationThread !== void 0) {
       const { scope, part } = conversation;
@@ -4702,7 +5082,7 @@ ${DASHBOARD_LINE}
       if (found === null) {
         return [];
       }
-      const messages = await this.readMessagesIn(this.paths.threadMessages(found.threads, conversationThread), cursorOf(cursors, scope, part));
+      const messages = await this.readMessagesIn(this.paths.threadMessages(found.threads, conversationThread), cursorOf(cursors, scope, part), upto);
       return messages.filter((message) => message.author !== actor.name).map((message) => ({ scope, part, message })).toSorted(byId);
     }
     const agent = await this.readAgent(actor.name);
@@ -4720,7 +5100,7 @@ ${DASHBOARD_LINE}
     ];
     const known = starts.filter((start) => start !== null);
     const since = known.length < starts.length ? null : known.toSorted((a, b) => a < b ? -1 : a > b ? 1 : 0)[0] ?? null;
-    for await (const message of this.iterateMessages(since)) {
+    for await (const message of this.iterateMessages(since, void 0, upto)) {
       const filedIn = wakeScope(agent, parseChannelRef(message.channel).project);
       const thread = message.thread ?? null;
       const asked = message.mentions.includes(actor.name) || frontDesk && message.author === USER_NAME;
@@ -5844,6 +6224,9 @@ ${args.summary}`);
       }
       if (args.blocked_by !== void 0) {
         for (const id of args.blocked_by) {
+          if (id === current.id) {
+            throw new BoardError("VALIDATION", `task ${current.id} cannot be blocked by itself`);
+          }
           await this.findTask(id);
         }
         next = { ...next, blockedBy: [...args.blocked_by] };
@@ -5880,6 +6263,7 @@ ${args.summary}`);
           from: current.status,
           to: task.status,
           note: args.note ?? null,
+          ...args.blocked_by === void 0 ? {} : { blockedBy: task.blockedBy, previousBlockedBy: current.blockedBy },
           ...args.pull_request === void 0 ? {} : { pullRequest: task.pullRequest?.url ?? null }
         });
       }
@@ -6285,7 +6669,7 @@ ${rationale}`}`);
   }
   async readAgentRoleBody(agent) {
     const file = this.paths.agentRole(agent);
-    return await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
   }
   /** The steps of one finished turn, as the runner handed them over when it ended. */
   /**
@@ -6316,6 +6700,14 @@ ${rationale}`}`);
     }
     return computeMetrics({ events, tasks, citizens, actions, activeSignals, window, now });
   }
+  /**
+   * Each citizen's finished turns over a window and the tokens of those that counted them, from
+   * the event log alone, which holds every turn's end whatever runner it ran on.
+   */
+  async tokenUse(window) {
+    const events = await this.events.readSince(null, Number.MAX_SAFE_INTEGER);
+    return tokenUse(events, window, this.now());
+  }
   /** The board actions a finished turn took, from its transcript; null when it kept none. */
   async turnActions(agent, turnId) {
     const known = this.actionCounts.get(turnId);
@@ -6685,7 +7077,7 @@ ${rationale}`}`);
       return { project: slug, revision: 0, body: "" };
     }
     const { data, body } = await readLooseMarkdown(file);
-    const revision = z13.number().int().min(0).safeParse(data["revision"]);
+    const revision = z15.number().int().min(0).safeParse(data["revision"]);
     const updatedBy = NameSchema.safeParse(data["updatedBy"]);
     const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
     return {
@@ -6976,7 +7368,7 @@ ${seed}
         continue;
       }
       const file = this.paths.agentRole(agent.name);
-      const body = await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
+      const body = await exists(file) ? (await readMarkdown(file, z15.record(z15.string(), z15.unknown()))).body : "";
       const at = body.indexOf(`
 ${SEED_INSTRUCTIONS_HEADING}
 `);
@@ -7178,12 +7570,37 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       case "archive":
         await this.validateArchive(ArchiveProposalSchema.parse(charter).project);
         return;
-      case "reallocation":
+      case "reallocation": {
+        const parsed = ReallocationProposalSchema.safeParse(charter);
+        if (parsed.success) {
+          await this.reallocatedRole(parsed.data);
+        } else {
+          LegacyReallocationSchema.parse(charter);
+        }
         return;
+      }
       default:
         return;
     }
   }
+  /**
+   * The role as a reallocation would leave it, with what changes: refused for the user's charter,
+   * a role that does not exist, a charter the changes would make invalid, and changes the role
+   * has already.
+   */
+  async reallocatedRole(reallocation) {
+    if (reallocation.role === USER_ROLE) {
+      throw new BoardError("FORBIDDEN", "the user charter is not subject to proposals");
+    }
+    const current = await this.readRole(reallocation.role);
+    const next = RoleCharterSchema.parse(applyRoleChanges(current, reallocation.changes));
+    await this.validateRole(next);
+    const changed = roleChangeLines(current, reallocation.changes);
+    if (changed.length === 0) {
+      throw new BoardError("VALIDATION", `role ${current.name} has these values already; the reallocation changes nothing`);
+    }
+    return { next, changed };
+  }
   async executeProvision(by, proposal) {
     const meta = { proposalId: proposal.id };
     switch (proposal.kind) {
@@ -7220,8 +7637,15 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         const { members } = await this.archiveUnlocked(by, input.project, input.reason, meta);
         return { project: input.project, members };
       }
-      case "reallocation":
-        return void 0;
+      case "reallocation": {
+        const parsed = ReallocationProposalSchema.safeParse(proposal.charter);
+        if (!parsed.success) {
+          return void 0;
+        }
+        const { next, changed } = await this.reallocatedRole(parsed.data);
+        await this.writeRoleUnlocked(by, next, meta);
+        return { role: next.name, changed };
+      }
       default:
         return void 0;
     }
@@ -7782,7 +8206,7 @@ ${charter.purpose}
       id: this.newId(),
       ...head,
       ts: this.now().toISOString(),
-      mentions: extractMentions(body)
+      mentions: postMentions(body)
     });
     const { author } = head;
     await writeMarkdown(this.paths.messageFile(dir, frontmatter.id, author), frontmatter, body);
@@ -7921,7 +8345,7 @@ ${charter.purpose}
     if (filed.proposedBy === actor.name) {
       throw new BoardError("FORBIDDEN", "a proposer never decides its own proposal");
     }
-    const approvers = ROLE_KIND_APPROVERS[filed.kind];
+    const approvers = proposalApprovers(filed.kind, filed.charter);
     if (!approvers.includes(actor.role)) {
       throw new BoardError("FORBIDDEN", `a ${filed.kind} proposal requires one of: ${approvers.join(", ")}`);
     }
@@ -8004,7 +8428,7 @@ ${charter.purpose}
       }
       if (subject?.kind === "proposal") {
         const proposal = await this.readProposal(subject.id);
-        if (proposal.proposedBy === actor.name || proposal.decidedBy === actor.name || ROLE_KIND_APPROVERS[proposal.kind].includes(actor.role)) {
+        if (proposal.proposedBy === actor.name || proposal.decidedBy === actor.name || proposalApprovers(proposal.kind, proposal.charter).includes(actor.role)) {
           return true;
         }
         return (await this.readRole(actor.role)).wakeTriggers.includes(OPS_WAKE_TRIGGER);
@@ -8061,11 +8485,12 @@ ${charter.purpose}
     });
     await this.endCronsUnlocked(by, `its thread closed: its ${found.thread.subject?.kind ?? "subject"} was ${ended}`, (cron) => cron.thread === subjectId);
   }
-  async readMessagesIn(dir, since) {
+  /** The messages in a folder after `since` and, when given, up to `upto`, read by name first. */
+  async readMessagesIn(dir, since, upto) {
     const messages = [];
     for (const file of await listFiles(dir)) {
       const id = file.slice(0, 26);
-      if (since !== null && id <= since) {
+      if (since !== null && id <= since || upto !== void 0 && id > upto) {
         continue;
       }
       const doc = await readMarkdown(path6.join(dir, file), MessageFrontmatterSchema);
@@ -8073,20 +8498,23 @@ ${charter.purpose}
     }
     return messages;
   }
-  /** Every message newer than `since` across society channels, project channels, and threads. */
-  async *iterateMessages(since, project) {
+  /**
+   * Every message newer than `since`, and no newer than `upto` when given, across society
+   * channels, project channels, and threads.
+   */
+  async *iterateMessages(since, project, upto) {
     if (project === void 0) {
       for (const channel of await listDirs(this.paths.societyChannels())) {
-        yield* await this.readMessagesIn(this.paths.societyChannel(channel), since);
+        yield* await this.readMessagesIn(this.paths.societyChannel(channel), since, upto);
       }
-      yield* this.threadMessagesIn(this.paths.societyThreads(), since);
+      yield* this.threadMessagesIn(this.paths.societyThreads(), since, upto);
     }
     const projects = project === void 0 ? await listDirs(this.paths.projects()) : [project];
     for (const slug of projects) {
       for (const channel of await listDirs(this.paths.projectChannels(slug))) {
-        yield* await this.readMessagesIn(this.paths.projectChannel(slug, channel), since);
+        yield* await this.readMessagesIn(this.paths.projectChannel(slug, channel), since, upto);
       }
-      yield* this.threadMessagesIn(this.paths.threads(slug), since);
+      yield* this.threadMessagesIn(this.paths.threads(slug), since, upto);
     }
   }
   /** Every folder that holds messages: each channel's and each thread's, in the society and every project. */
@@ -8106,9 +8534,9 @@ ${charter.purpose}
       }
     }
   }
-  async *threadMessagesIn(threads, since) {
+  async *threadMessagesIn(threads, since, upto) {
     for (const id of await listDirs(threads)) {
-      yield* await this.readMessagesIn(this.paths.threadMessages(threads, id), since);
+      yield* await this.readMessagesIn(this.paths.threadMessages(threads, id), since, upto);
     }
   }
 };
@@ -8156,7 +8584,7 @@ function decideWake(input) {
 }
 
 // packages/scheduler/dist/scheduler.js
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 function besideFields(beside) {
   if (beside === void 0) {
     return {};
@@ -8183,21 +8611,21 @@ var DEFAULT_TIMINGS = Object.freeze({
   scaleCooldownMs: 36e5,
   reflectionMs: 24 * 36e5
 });
-var SchedulerTimingsSchema = z14.object({
-  pollMs: z14.number().positive(),
-  debounceMs: z14.number().nonnegative(),
-  userDebounceMs: z14.number().nonnegative(),
-  heartbeatMs: z14.number().positive(),
-  waitingStageMs: z14.number().positive(),
-  leaseSweepMs: z14.number().positive(),
-  opsIntervalMs: z14.number().positive(),
-  signalRepeatMs: z14.number().positive(),
-  costReportMs: z14.number().positive(),
-  staleThreadMs: z14.number().positive(),
-  idleMemberMs: z14.number().positive(),
-  homeConflictMs: z14.number().positive(),
-  scaleCooldownMs: z14.number().positive(),
-  reflectionMs: z14.number().positive()
+var SchedulerTimingsSchema = z16.object({
+  pollMs: z16.number().positive(),
+  debounceMs: z16.number().nonnegative(),
+  userDebounceMs: z16.number().nonnegative(),
+  heartbeatMs: z16.number().positive(),
+  waitingStageMs: z16.number().positive(),
+  leaseSweepMs: z16.number().positive(),
+  opsIntervalMs: z16.number().positive(),
+  signalRepeatMs: z16.number().positive(),
+  costReportMs: z16.number().positive(),
+  staleThreadMs: z16.number().positive(),
+  idleMemberMs: z16.number().positive(),
+  homeConflictMs: z16.number().positive(),
+  scaleCooldownMs: z16.number().positive(),
+  reflectionMs: z16.number().positive()
 }).partial();
 function parseTimings(input) {
   const parsed = SchedulerTimingsSchema.parse(input);
@@ -8209,32 +8637,32 @@ function parseTimings(input) {
   }
   return overrides;
 }
-var PendingSchema = z14.object({
+var PendingSchema = z16.object({
   dispatch: TurnDispatchSchema,
-  readyAt: z14.number(),
-  stageWakes: z14.array(TriggerSchema).optional(),
-  holder: z14.boolean().optional(),
+  readyAt: z16.number(),
+  stageWakes: z16.array(TriggerSchema).optional(),
+  holder: z16.boolean().optional(),
   newestMessage: UlidSchema.optional(),
-  onlyMessages: z14.boolean().optional(),
+  onlyMessages: z16.boolean().optional(),
   steeredThrough: UlidSchema.optional(),
-  onlyCrons: z14.boolean().optional()
+  onlyCrons: z16.boolean().optional()
 });
-var StateSchema = z14.object({
-  cursor: z14.string().nullable(),
-  lastHeartbeat: z14.record(z14.string(), z14.string()),
+var StateSchema = z16.object({
+  cursor: z16.string().nullable(),
+  lastHeartbeat: z16.record(z16.string(), z16.string()),
   /** Waiting stages already signalled, as `task:stage`, so each is logged once while it waits. */
-  waitingSeen: z14.record(z14.string(), z14.string()).default({}),
+  waitingSeen: z16.record(z16.string(), z16.string()).default({}),
   /** Queued dispatches survive a restart; the cursor has already moved past the events that made them. */
-  pending: z14.record(z14.string(), PendingSchema).default({}),
-  opsReported: z14.record(z14.string(), z14.string()).default({}),
-  releaseCounts: z14.record(z14.string(), z14.number().int().nonnegative()).default({}),
-  lastOps: z14.string().nullable().default(null),
-  lastScaled: z14.record(z14.string(), z14.string()).default({}),
-  lastCostReport: z14.string().nullable().default(null),
-  costSinceReport: z14.number().nonnegative().default(0),
-  turnsSinceReport: z14.number().int().nonnegative().default(0),
+  pending: z16.record(z16.string(), PendingSchema).default({}),
+  opsReported: z16.record(z16.string(), z16.string()).default({}),
+  releaseCounts: z16.record(z16.string(), z16.number().int().nonnegative()).default({}),
+  lastOps: z16.string().nullable().default(null),
+  lastScaled: z16.record(z16.string(), z16.string()).default({}),
+  lastCostReport: z16.string().nullable().default(null),
+  costSinceReport: z16.number().nonnegative().default(0),
+  turnsSinceReport: z16.number().int().nonnegative().default(0),
   /** When each member last reflected, or was first seen; the cadence counts from here. */
-  lastReflection: z14.record(z14.string(), z14.string()).default({})
+  lastReflection: z16.record(z16.string(), z16.string()).default({})
 });
 function messageOf(trigger) {
   return trigger.kind === "mention" || trigger.kind === "user_post" ? trigger.messageId : void 0;
@@ -8492,7 +8920,7 @@ var Scheduler = class {
           return;
         }
         if (stringOf(payload["thread"]) !== taskId) {
-          await this.wakeHolder(taskId, event.actor, now);
+          await this.wakeHolder(taskId, event.actor, event.actor, now);
         }
         await this.pruneStageWakes(taskId);
         return;
@@ -8518,6 +8946,7 @@ var Scheduler = class {
         if (creator !== null && creator !== event.actor) {
           await this.wakeCreator(taskId, project, creator, event.actor, now);
         }
+        await this.wakeDependents(taskId, event.actor, now);
         const threaded = await this.board.readThread(taskId).then(() => true, () => false);
         if (!threaded) {
           this.sweep({ kind: "thread", id: taskId });
@@ -8537,12 +8966,17 @@ var Scheduler = class {
       }
       case "task.updated": {
         const taskId = stringOf(payload["taskId"]);
-        if (taskId !== null && payload["to"] === "abandoned") {
+        if (taskId === null) {
+          return;
+        }
+        if (payload["to"] === "abandoned") {
           delete this.state.releaseCounts[taskId];
           await this.queueClosing(taskId);
+          await this.wakeDependents(taskId, event.actor, now);
         }
-        if (taskId !== null) {
-          await this.pruneStageWakes(taskId);
+        await this.pruneStageWakes(taskId);
+        if (Array.isArray(payload["blockedBy"]) && (await this.blockersInPlay(stringArray(payload["previousBlockedBy"]))).length > 0) {
+          await this.wakeUnblocked(taskId, event.actor, now);
         }
         return;
       }
@@ -8713,9 +9147,10 @@ var Scheduler = class {
   }
   /**
    * Entering a stage wakes its named citizen, else its last holder when work returns to it, else
-   * the project's members of its role, else every member of the project who may hold it.
+   * the project's members of its role, else every member of the project who may hold it. A stage
+   * of a blocked task wakes nobody until its last blocker ends (`wakeUnblocked`).
    */
-  async wakeStage(taskId, from, now, only) {
+  async wakeStage(taskId, from, now, options = {}) {
     let task;
     try {
       task = (await this.board.findTask(taskId)).task;
@@ -8726,6 +9161,10 @@ var Scheduler = class {
     if (stage === void 0 || task.status !== "open" || task.completing) {
       return;
     }
+    if ((await this.blockersInPlay(task.blockedBy)).length > 0) {
+      return;
+    }
+    const { only, state = "is waiting for you" } = options;
     const lastHolder = stage.holders.at(-1);
     const targets = stage.agent !== void 0 ? [stage.agent] : lastHolder !== void 0 ? [lastHolder] : stage.role !== void 0 ? (await this.board.membersWithRole(task.project, stage.role)).map((a) => a.name) : (await this.board.projectMembers(task.project)).map((a) => a.name);
     for (const name of targets) {
@@ -8736,7 +9175,7 @@ var Scheduler = class {
       if (agent === null || !mayHoldStage(agent, task)) {
         continue;
       }
-      await this.enqueueStage(agent, task, from, now, "is waiting for you");
+      await this.enqueueStage(agent, task, from, now, state);
     }
   }
   /**
@@ -8745,7 +9184,7 @@ var Scheduler = class {
    */
   async wakeNewcomer(name, project, now) {
     for (const task of await this.board.openTasks(project).catch(() => [])) {
-      await this.wakeStage(task.id, name, now, name);
+      await this.wakeStage(task.id, name, now, { only: name });
     }
   }
   /**
@@ -8753,7 +9192,7 @@ var Scheduler = class {
    * worked in that conversation, which nothing else would start before the next heartbeat. Turns
    * of one conversation run one at a time, so the turn this queues is the one that sees the claim.
    */
-  async wakeHolder(taskId, holder, now) {
+  async wakeHolder(taskId, holder, from, now, state = "is yours; its work happens here") {
     let task;
     try {
       task = (await this.board.findTask(taskId)).task;
@@ -8764,12 +9203,66 @@ var Scheduler = class {
     if (agent === null || task.status !== "claimed" || task.claimedBy !== holder) {
       return;
     }
-    const key = await this.enqueueStage(agent, task, holder, now, "is yours; its work happens here");
+    const key = await this.enqueueStage(agent, task, from, now, state);
     const item = key === null ? void 0 : this.pending.get(key);
     if (item?.stageWakes !== void 0) {
       item.holder = true;
     }
   }
+  /**
+   * The ids among these that name a task still open or claimed, a landing one included. A task
+   * blocked by any of them waits for them rather than for a holder: its stage wakes nobody, by
+   * coming up or on a heartbeat, until the last one ends.
+   */
+  async blockersInPlay(ids) {
+    const blocking = [];
+    for (const id of ids) {
+      try {
+        const { task } = await this.board.findTask(id);
+        if (task.status === "open" || task.status === "claimed") {
+          blocking.push(id);
+        }
+      } catch {
+      }
+    }
+    return blocking;
+  }
+  /**
+   * A task's last blocker has ended, or its blockers were changed to none in play: its stage wakes
+   * as on coming up, or its holder in the task's conversation, since nothing woke either for it
+   * while it was blocked.
+   */
+  async wakeUnblocked(taskId, from, now) {
+    let task;
+    try {
+      task = (await this.board.findTask(taskId)).task;
+    } catch {
+      return;
+    }
+    if (task.completing || (await this.blockersInPlay(task.blockedBy)).length > 0) {
+      return;
+    }
+    if (task.status === "open") {
+      await this.wakeStage(task.id, from, now, {
+        state: "is waiting for you, now that nothing blocks it"
+      });
+    } else if (task.status === "claimed" && task.claimedBy !== void 0) {
+      await this.wakeHolder(task.id, task.claimedBy, from, now, "is yours, and nothing blocks it any more");
+    }
+  }
+  /** A task that ended unblocks every task in play that names it, once nothing else blocks them. */
+  async wakeDependents(taskId, from, now) {
+    for (const project of await this.board.listProjects()) {
+      if (project.archived !== void 0) {
+        continue;
+      }
+      for (const task of await this.board.listTasks(project.slug)) {
+        if (task.blockedBy.includes(taskId) && (task.status === "open" || task.status === "claimed")) {
+          await this.wakeUnblocked(task.id, from, now);
+        }
+      }
+    }
+  }
   /** Queues a stage wake in the task's conversation and returns its key, or null for no wake. */
   async enqueueStage(agent, task, from, now, state) {
     if (agent.status !== "active" || agent.cli === null) {
@@ -8805,9 +9298,9 @@ var Scheduler = class {
     }
   }
   /**
-   * The first of these stage wakes still due: its task waits, unheld, on a stage the agent may
-   * hold, or, with `holder`, the agent holds it, having claimed it outside the task's conversation.
-   * A wake for a stage the agent took in the turn the wake waited on is dropped.
+   * The first of these stage wakes still due: its task waits, unheld and unblocked, on a stage the
+   * agent may hold, or, with `holder`, the agent holds it, having claimed it outside the task's
+   * conversation. A wake for a stage the agent took in the turn the wake waited on is dropped.
    */
   async stillWaiting(name, wakes, holder) {
     const agent = await this.tryReadAgent(name);
@@ -8823,7 +9316,7 @@ var Scheduler = class {
         if (task.completing || currentStage(task) === void 0) {
           continue;
         }
-        if (task.status === "open" && mayHoldStage(agent, task)) {
+        if (task.status === "open" && mayHoldStage(agent, task) && (await this.blockersInPlay(task.blockedBy)).length === 0) {
           return wake;
         }
         if (holder && task.status === "claimed" && task.claimedBy === agent.name) {
@@ -9046,9 +9539,9 @@ var Scheduler = class {
   /**
    * A heartbeat per member and scope on the cadence, which then looks at every conversation of the
    * scope: the unread messages of its home, of each other channel, and of each thread, a stage the
-   * member holds, and a stage
-   * waiting that it may take, each in its task's thread. Each conversation with something wakes on
-   * its own, so a heartbeat never brings one task's business into another's turn.
+   * member holds, and a stage of an unblocked task waiting that it may take, each in its task's
+   * thread. Each conversation with something wakes on its own, so a heartbeat never brings one
+   * task's business into another's turn.
    */
   async checkHeartbeats(now) {
     for (const agent of await this.board.listAgents()) {
@@ -9100,7 +9593,7 @@ var Scheduler = class {
         }
         if (project !== SOCIETY_SCOPE) {
           for (const task of await this.board.openTasks(project)) {
-            if (mayHoldStage(agent, task)) {
+            if (mayHoldStage(agent, task) && (await this.blockersInPlay(task.blockedBy)).length === 0) {
               reasonsIn({ thread: { id: task.id, task: true } }).waiting += 1;
             }
           }
@@ -9252,9 +9745,10 @@ var Scheduler = class {
     return latest;
   }
   /**
-   * A current stage without a holder past the threshold is logged as a signal once while it waits.
-   * It wakes nobody by itself: its assignees see the stage on their heartbeat, and the steward reads
-   * the signal at its next turn and decides whether to replan or to mention someone.
+   * A current stage without a holder past the threshold is logged as a signal once while it waits,
+   * naming the tasks that still block it. It wakes nobody by itself: its assignees see the stage on
+   * their heartbeat, or a blocked one when its last blocker ends, and the steward reads the signal
+   * at its next turn and decides whether to replan or to mention someone.
    */
   async checkWaitingStages(now) {
     const stillWaiting = /* @__PURE__ */ new Set();
@@ -9275,10 +9769,12 @@ var Scheduler = class {
         }
         this.state.waitingSeen[key] = iso(now);
         const assignee2 = stage.agent ?? stage.role ?? "anyone in the project";
+        const blockers = await this.blockersInPlay(task.blockedBy);
+        const waited = blockers.length === 0 ? "for a holder" : `blocked by ${blockers.map((id) => `task ${id}`).join(", ")}`;
         await this.board.publishSignal({
           kind: "waiting_stage",
           key: `waiting_stage:${key}`,
-          summary: `stage "${stage.name}" of task ${task.id} "${task.title}" in ${project.slug}, for ${assignee2}, has waited ${describeDuration(age)} for a holder`,
+          summary: `stage "${stage.name}" of task ${task.id} "${task.title}" in ${project.slug}, for ${assignee2}, has waited ${describeDuration(age)} ${waited}`,
           value: age,
           threshold: this.timings.waitingStageMs,
           project: project.slug,
@@ -9739,8 +10235,9 @@ var TURN_CONTRACT = [
   "- Posts that would wake this conversation may arrive while you work, delivered into the turn under a heading that says so and formatted like the digest. They are part of this turn: act on them now, after the step in hand, or not at all, as with the digest. The user may also stop a turn; the next turn is told.",
   "- Silence is allowed. If the digest needs no reply, post nothing.",
   "- To come back to something later, set a cron with create_cron: a note on what to do then, and a five-field cron expression or one time with at. It wakes you in this conversation unless you name another, at most every fifteen minutes, and every fire is a paid turn, so end a cron with remove_cron once it has done its job. Never wait by holding a stage, sleeping, or leaving a process running: a turn's board token ends with the turn, so nothing it leaves behind can act on the board. The society's crons are under society/crons/ in the board projection.",
-  "- An @mention wakes the citizen named, and every wake costs a turn. Address someone with @ only when you need them to act; when you merely refer to citizens, write their names plainly. @user wakes nobody, since the user takes no turns; it is what puts a question before the user, so use it only when you need the user to answer or decide.",
+  "- An @mention wakes the citizen named, and every wake costs a turn. Address someone with @ only when you need them to act; when you merely refer to citizens, write their names plainly. A name in a code span or a code block is no mention, so code keeps its @ as written. @user wakes nobody, since the user takes no turns; it is what puts a question before the user, so use it only when you need the user to answer or decide.",
   "- A thread is a conversation off a channel that reaches only its participants and whoever is mentioned in it. Every task has one, opened with it under the task's id on the channel of its project it was filed in, general unless it was filed in another: talk about a task there, with post_message and its thread_id, and the notes you give advance_task and update_task are posted there as you. Its participants are the task's creator, its stage holders and assignees, whoever may take the stage that waits, and anyone who posted; it closes when the task ends. Every proposal has one too, in governance, opened with its pitch and closed by its decision. Open other threads with open_thread on a channel with a title, for any other topic; close_thread posts your summary to its channel.",
+  "- To show an image in a post, such as a screenshot or a chart, commit the file to a task's branch and link it by its path in the task's worktree, as `![what it shows](<path>)`: the board shows a file on a task's branch in place once it is committed, at the latest when your turn ends. An image at an https address shows too. Never put an image or any other file into a message as base64 or a data: URL: the board does not show it, and every reader of the conversation gets it in full in their prompt.",
   "- Route every lesson: about you, your craft, or the user, write it to memory/core.md in your home directory, and keep that file short by moving detail to memory/<topic>.md, your archive; a durable fact about a project's codebase or process goes through `write_knowledge` on that project; something the whole project should know now, post it to the project channel, and anything about one task, in the task's thread.",
   '- A procedure you have followed twice is a skill: write it to skills/<name>/SKILL.md in your home, frontmatter with `name` and a one-line `description` and then the steps, and your skills index lists it from the next turn. Files the steps use, such as scripts/ and references/, go in the same folder, named in SKILL.md by paths relative to it. Propose it with kind "skill" when the whole society would use it.',
   "- To take a published skill for yourself, install it in a temporary folder and copy it into your home: in a folder from `mktemp -d`, `npx -y skills add <source> --skill <name> -a universal --copy -y` writes `.agents/skills/<name>/` and a lock file there, and you copy that skill folder to skills/<name>/ in your home, named in lowercase letters, digits, and hyphens. Never install one inside a worktree, where it would be committed into the project, or with -g, which writes to the runner's own home, shared by every citizen on it and listed in no skills index.",
@@ -9754,32 +10251,33 @@ var PLANNING = [
   "- Name stages by what gets done. Plan the next few steps rather than everything, and reshape with plan_task as the work teaches you.",
   "- Assign a stage to a role when anyone in it could do it, to a citizen only when it must be them, and to nobody when anyone in the project could. A citizen named on a stage must be a member of the task's project; add them first. A stage wakes everyone it is open to when it comes up, so the narrower the assignee, the fewer turns it costs.",
   "- Reshape rather than force: another round is an inserted stage, and a wait on something outside the society is a stage named for what it waits on. When a check finds work unfinished, send the task back to an earlier stage with update_task.",
+  "- A task that cannot start until other tasks finish names them with update_task blocked_by. While any of them is in play, its stage wakes nobody, neither when it comes up nor on a heartbeat; once the last has ended, done or abandoned, the stage wakes as if it had just come up, or wakes its holder. Nobody needs to clear the block or mention anyone when they end; change blocked_by only when the plan changes.",
   "- A gated stage is an independent check: nobody who held an earlier stage of the task may hold it, and only the user, the steward, and the concierge may add, remove, move, reassign, or ungate it. Ask them in the task's thread when a gate should change.",
   "- Commit your work on the task's branch before you advance, and say what you did in the advance note; it is the handover the next holder reads in the task's thread."
 ].join("\n");
 var GOVERNANCE = [
-  "- Anything the society lacks is a proposal: call `propose` with a kind and a charter. It opens the proposal's thread in governance with your rationale, where it is discussed and where the decision is posted. Approval provisions it on the spot, and either decision wakes the proposer. The user decides members, roles, retirements, and archives; the steward may also decide channels, reallocations, and skills. Nobody decides their own proposal.",
+  "- Anything the society lacks is a proposal: call `propose` with a kind and a charter. It opens the proposal's thread in governance with your rationale, where it is discussed and where the decision is posted. Approval provisions it on the spot, and either decision wakes the proposer. The user decides members, roles, retirements, archives, and reallocations that change a role's verbs or replicas; the steward may also decide channels, skills, and other reallocations. Nobody decides their own proposal.",
   "- Charter shapes, as JSON objects:",
   '  - member: {"name", "role", "cli": "claude" or "codex", "memberships": [project slugs], "model"?, "homeRunner"?, "subscriptions"?, "seedInstructions"?}',
   '  - role: {"name", "purpose", "verbs": [board verbs], "wakeTriggers"?: any of "user_post", "ops_event", "heartbeat" (heartbeat when omitted), "maxReplicas"?, "backlogThreshold"?, "societyScope"?: true for a society role, whose members are never in a project and keep watch over the whole society}. Mentions, stages that become yours, and finished tasks you created wake every role; a heartbeat wakes you when something is unread, held, or waiting for you.',
   '  - channel: {"project": slug or null, "name", "purpose"}',
   '  - retirement: {"agent", "reason"}',
   '  - archive: {"project", "reason"}: approval archives the project: its members leave, its open threads close, and nothing more is posted, filed, or joined there, while its files and history stay; refused while a task there is in play',
-  '  - reallocation: {"description"}',
-  '  - skill: {"name", "summary"}: the folder skills/<name>/ in your home, SKILL.md and every file beside it, which the board takes as it stands when this turn ends into society/proposals/<id>/, where whoever decides reads it; a proposal whose folder has no SKILL.md then is rejected by the board. Approval publishes it under society/skills/<name>/, where every citizen\'s skills index lists it until the steward or the user removes it with `remove_skill`; ask the steward to remove one that is wrong or superseded. A proposal from before folders carries "body", its SKILL.md text alone',
+  `  - reallocation: {"role", "changes": {"maxReplicas"?, "backlogThreshold"?, "wakeTriggers"?, "verbs"?}, "description"}: approval applies the changes to the existing role, each the field's new value and verbs and wakeTriggers whole lists, for its members from their next turn; refused for a role that does not exist or that has those values already. Only the user decides one that changes verbs or maxReplicas`,
+  '  - skill: {"name", "summary"}: the folder skills/<name>/ in your home, SKILL.md and every file beside it, which the board takes as it stands when this turn ends into society/proposals/<id>/, where whoever decides reads it; a proposal whose folder has no SKILL.md then is rejected by the board. Approval publishes it under society/skills/<name>/, where every citizen\'s skills index lists it until the steward or the user removes it with `remove_skill`; ask the steward to remove one that is wrong or superseded. Once yours is approved, delete skills/<name>/ from your home and report memoryUpdated: the board leaves your copy there, and your index would list it beside the published one and follow it as it drifts from what was reviewed. To revise a published skill, copy its folder home, edit it, and propose it again. A proposal from before folders carries "body", its SKILL.md text alone',
   "- Projects and membership: a project is a lasting area of work, not one request; `create_project` opens one with its general channel (front desk and user), and `configure_project` sets its completion effect, its display name, or its default branch, never its slug (user, steward, concierge). A workstream within a project or the society, such as a release, gets a channel of its own: `create_channel` opens it, which its opener follows, and announces it in the place's general, where members subscribe when it concerns them, `create_task` with `channel` files the workstream's tasks there, and `archive_channel` ends it once none of its tasks is in play, leaving its history readable (user, steward, concierge; others propose a channel). A project whose work is finished or has moved to another project is archived by proposal, once no task there is in play. `join_project` and `leave_project` move yourself, or another citizen when you are the concierge, the steward, or the user; joining gives the pair a worktree and an onboarding turn. A society role, one that keeps watch over the whole society as the concierge and the steward do, is never in a project: it moves others, never itself.",
-  "- Prefer scaling an existing role over inventing one; a new role is justified by work a project needs that no existing role covers. A role that needs a tool the board lacks is an engineering task, not a hiring request.",
+  "- Prefer scaling an existing role over inventing one, with a reallocation of its replicas, backlog threshold, wakes, or verbs; a new role is justified by work a project needs that no existing role covers. A role that needs a tool the board lacks is an engineering task, not a hiring request.",
   "- Operations signals are counters and timers the board logs, listed in the prompt of a role that reads them: stages waiting for a holder, backlog per role, stages waiting on a role nobody fills, churn, stale threads, idle members, missing capabilities, replicas added, spend. They are not posts in any channel; interpreting them is your judgment."
 ].join("\n");
-function renderOnboardingPreamble(context) {
+function renderOnboardingPreamble(context2) {
   return [
-    `This is your first turn as ${context.agentName}.`,
+    `This is your first turn as ${context2.agentName}.`,
     "",
-    `Your role in one paragraph: ${context.roleSummary}`,
+    `Your role in one paragraph: ${context2.roleSummary}`,
     "",
-    `You are working on project "${context.project}" in the worktree at ${context.worktree}.`,
-    ...(context.otherChannels ?? []).length === 0 ? [] : [
-      `You follow its general channel. It also has ${(context.otherChannels ?? []).map((ref) => `#${ref}`).join(", ")}, each a workstream such as a release: subscribe to one when your work there needs its posts. Its tasks and mentions reach you either way.`
+    `You are working on project "${context2.project}" in the worktree at ${context2.worktree}.`,
+    ...(context2.otherChannels ?? []).length === 0 ? [] : [
+      `You follow its general channel. It also has ${(context2.otherChannels ?? []).map((ref) => `#${ref}`).join(", ")}, each a workstream such as a release: subscribe to one when your work there needs its posts. Its tasks and mentions reach you either way.`
     ],
     "Your memory is empty. Write durable lessons about yourself, your craft, or the user to memory/core.md in your home directory.",
     "Write profile.md in your home directory: one paragraph on what you do well and what to send your way. The roster the front desk routes with is built from it.",
@@ -9865,10 +10363,25 @@ function signalLine(ts, signal) {
   ].filter((fact) => fact.length > 0);
   return `- [${ts}] ${signal.kind}: ${signal.summary} (${facts.join("; ")})`;
 }
-function runnerLine(runner, projects) {
+function quotaPhrase(cli, quota, now) {
+  const level = quotaLevel(quota, now);
+  if (level === "none") {
+    return `${cli} reports no plan limits`;
+  }
+  if (level === "limited") {
+    return `${cli} limited until ${quota.limitedUntil ?? "an unknown time"}`;
+  }
+  const windows = quota.windows.map((window) => !windowCurrent(window, now) ? `${windowName(window)} reset since` : `${windowName(window)} ${window.usedPercent === null ? "?" : Math.floor(window.usedPercent)}%`);
+  return `${cli} ${windows.length === 0 ? "allowed" : windows.join(", ")}${level === "warning" ? " (near a limit)" : ""} as of ${quota.observedAt}`;
+}
+function runnerLine(runner, projects, now) {
   const living = projects.filter((project) => project.runner === runner.name).map((project) => project.slug);
   const state = runner.status === "connected" ? "connected" : `away${runner.lastSeen === void 0 ? "" : ` since ${runner.lastSeen}`}`;
-  return `- ${runner.name}: ${state}; ${runner.os}; CLIs ${runner.clis.length === 0 ? "none" : runner.clis.join(", ")}; offers ${runner.capabilities.length === 0 ? "nothing beyond its CLIs" : runner.capabilities.join(", ")}; ${living.length === 0 ? "no projects" : `projects ${living.join(", ")}`}`;
+  const quotas = runner.clis.flatMap((cli) => {
+    const quota = runner.quotas?.[cli];
+    return quota === void 0 ? [] : [quotaPhrase(cli, quota, now)];
+  });
+  return `- ${runner.name}: ${state}; ${runner.os}; CLIs ${runner.clis.length === 0 ? "none" : runner.clis.join(", ")}; offers ${runner.capabilities.length === 0 ? "nothing beyond its CLIs" : runner.capabilities.join(", ")}; ${living.length === 0 ? "no projects" : `projects ${living.join(", ")}`}${quotas.length === 0 ? "" : `; quota ${quotas.join("; ")}`}`;
 }
 function profileLine(profile) {
   const line = profile.split("\n").map((entry) => entry.trim()).find((entry) => entry.length > 0 && !entry.startsWith("#"));
@@ -9951,7 +10464,7 @@ function buildTurnPrompt(input) {
     lines.push("A task you created is done. Tell whoever asked for it, if anyone did.");
   }
   if (dispatch.trigger.kind === "proposal_decided") {
-    lines.push("A proposal you made was decided; the decision is the last post in the proposal's thread. A decision wakes you in the conversation you filed the proposal from, or at home once that has ended. Carry on with what an approval enables or a rejection asks, and stay silent if nothing follows.");
+    lines.push("A proposal you made was decided; the decision is the last post in the proposal's thread. A decision wakes you in the conversation you filed the proposal from, or at home once that has ended. Carry on with what an approval enables or a rejection asks, and stay silent if nothing follows. An approved skill is published under society/skills/<name>/: delete your own skills/<name>/ from your home and report memoryUpdated, so your index lists the published copy alone.");
   }
   if (dispatch.trigger.kind === "cron") {
     lines.push("A cron came due: what it asks is under Crons below.");
@@ -10018,12 +10531,12 @@ function buildTurnPrompt(input) {
   }
   const machines = input.runners;
   if (machines !== void 0 && machines !== null) {
-    lines.push("", "## Runners", "", "The machines turns run on. A project lives on the runner that takes its first turn, one that offers every capability the project and that turn's task require, and never moves. A task's required_capabilities must name capabilities exactly as a runner below offers them; a task needing one its project's runner lacks waits.", "");
+    lines.push("", "## Runners", "", "The machines turns run on. A project lives on the runner that takes its first turn, one that offers every capability the project and that turn's task require, and never moves. A task's required_capabilities must name capabilities exactly as a runner below offers them; a task needing one its project's runner lacks waits. A runner's quota is what each CLI's login there last reported of its plan, in percent of each window; a CLI limited until a time fails its turns there until then.", "");
     if (machines.runners.length === 0) {
       lines.push("None registered yet.");
     }
     for (const runner of machines.runners) {
-      lines.push(runnerLine(runner, machines.projects));
+      lines.push(runnerLine(runner, machines.projects, input.clock?.now ?? /* @__PURE__ */ new Date()));
     }
   }
   const knowledge = input.knowledge;
@@ -10556,6 +11069,11 @@ var TurnHost = class {
         }
       }
     });
+    if (outcome.quota !== void 0) {
+      await this.board.recordQuota(turn.runner, job.cli, outcome.quota).catch((error) => {
+        this.log.warn({ runner: turn.runner, cli: job.cli, error: String(error) }, "could not record a quota");
+      });
+    }
     if (recorded) {
       this.log.info({
         agent: job.agent,
@@ -10737,7 +11255,7 @@ var TurnHost = class {
       if (await this.board.hasMentioned(actor.name, USER_NAME, since)) {
         return;
       }
-      const proposed = (await this.board.listProposals()).some((proposal) => proposal.proposedBy === actor.name && proposal.createdAt >= since && ROLE_KIND_APPROVERS[proposal.kind].includes(USER_ROLE));
+      const proposed = (await this.board.listProposals()).some((proposal) => proposal.proposedBy === actor.name && proposal.createdAt >= since && proposalApprovers(proposal.kind, proposal.charter).includes(USER_ROLE));
       if (proposed) {
         return;
       }
@@ -10885,7 +11403,8 @@ var RunnerHub = class {
       os: hello.os,
       clis: hello.clis,
       capabilities: hello.capabilities,
-      version: hello.version
+      version: hello.version,
+      gitIdentityMissing: hello.gitIdentityMissing ?? null
     });
     this.runnerChanged(name);
     this.log.info({ runner: name, version: hello.version, clis: hello.clis, slots: hello.slots }, "runner registered");
@@ -11327,6 +11846,26 @@ var RunnerHub = class {
     }
     return ModelListSchema.parse(await this.request(seat, (request) => ({ type: "models", request, cli })));
   }
+  /**
+   * A CLI's plan quota, read on a runner without a turn and recorded on the runner's record.
+   * Refused for a runner not connected with the CLI, and for one from before quota reads, which
+   * would skip the request and leave the reader waiting.
+   */
+  async quota(runner, cli) {
+    const seat = this.seats.get(runner);
+    if (seat === void 0 || seat.send === null || !seat.hello.clis.includes(cli)) {
+      throw new RunnerAwayError(`runner ${runner} is not connected with ${cli}`);
+    }
+    if (!seat.hello.quotaReads) {
+      throw new BoardError("INVALID_STATE", `runner ${runner} cannot read quotas yet; upgrade it`);
+    }
+    const quota = CliQuotaSchema.nullable().parse(await this.request(seat, (request) => ({ type: "quota", request, cli }), FILE_TIMEOUT_MS));
+    if (quota === null) {
+      throw new BoardError("NOT_FOUND", `${cli} on runner ${runner} cannot read its quota`);
+    }
+    await this.board.recordQuota(runner, cli, quota);
+    return quota;
+  }
   /** Calls `listener` whenever a runner registers, connects, or goes away. */
   onRunnerChange(listener) {
     this.runnerListeners.add(listener);
@@ -11559,20 +12098,20 @@ async function handleMcpRequest(board2, actor, request, version) {
 import { Hono as Hono3 } from "hono";
 import { compress } from "hono/compress";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { z as z16, ZodError } from "zod";
+import { z as z18, ZodError } from "zod";
 
 // apps/server/dist/github-auth.js
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { Hono } from "hono";
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var SIGN_IN_TTL_MS = 30 * 24 * 36e5;
 var STATE_TTL_MS = 10 * 6e4;
 var MAX_STATES = 1e3;
-var TokenAnswerSchema = z15.object({ access_token: z15.string().min(1) });
-var GithubUserSchema = z15.object({
-  login: z15.string().min(1),
-  id: z15.number().int(),
-  avatar_url: z15.string().optional()
+var TokenAnswerSchema = z17.object({ access_token: z17.string().min(1) });
+var GithubUserSchema = z17.object({
+  login: z17.string().min(1),
+  id: z17.number().int(),
+  avatar_url: z17.string().optional()
 });
 function githubAvatar(url) {
   try {
@@ -11995,7 +12534,7 @@ async function isFile(file) {
     return false;
   }
 }
-function within(root, pathname) {
+function within2(root, pathname) {
   let decoded;
   try {
     decoded = decodeURIComponent(pathname);
@@ -12012,7 +12551,7 @@ function spaHandler(staticDir) {
     if (pathname.startsWith("/api/")) {
       return c.json({ error: "NOT_FOUND", message: `no route ${pathname}` }, 404);
     }
-    const file = within(root, pathname);
+    const file = within2(root, pathname);
     const headers = { "x-content-type-options": "nosniff" };
     if (file !== null && await isFile(file)) {
       return c.body(await readFile5(file), 200, {
@@ -12047,19 +12586,19 @@ var ERROR_STATUS = {
   INVALID_STATE: 409
 };
 var EVENT_PAGE = 100;
-var RetireBodySchema = z16.object({ reason: z16.string().min(1) });
-var RunnerBodySchema = z16.object({ name: NameSchema });
-var EnrollmentApprovalSchema = z16.object({ name: NameSchema });
-var HomeRunnerBodySchema = z16.object({ runner: NameSchema.nullable() });
-var ModelBodySchema = z16.object({ model: ModelNameSchema.nullable() });
-var EffortBodySchema = z16.object({ effort: EffortSchema.nullable() });
-var HistoryLimitSchema = z16.coerce.number().int().min(1).max(500);
-var MessageIdsSchema = z16.string().transform((ids) => ids.split(",").filter((id) => id !== "")).pipe(z16.array(UlidSchema).min(1).max(MESSAGE_LOOKUP_LIMIT));
-var TimezoneBodySchema = z16.object({ timezone: TimeZoneSchema });
-var ChannelBodySchema = z16.object({
+var RetireBodySchema = z18.object({ reason: z18.string().min(1) });
+var RunnerBodySchema = z18.object({ name: NameSchema });
+var EnrollmentApprovalSchema = z18.object({ name: NameSchema });
+var HomeRunnerBodySchema = z18.object({ runner: NameSchema.nullable() });
+var ModelBodySchema = z18.object({ model: ModelNameSchema.nullable() });
+var EffortBodySchema = z18.object({ effort: EffortSchema.nullable() });
+var HistoryLimitSchema = z18.coerce.number().int().min(1).max(500);
+var MessageIdsSchema = z18.string().transform((ids) => ids.split(",").filter((id) => id !== "")).pipe(z18.array(UlidSchema).min(1).max(MESSAGE_LOOKUP_LIMIT));
+var TimezoneBodySchema = z18.object({ timezone: TimeZoneSchema });
+var ChannelBodySchema = z18.object({
   project: NameSchema.nullable().default(null),
   name: NameSchema,
-  purpose: z16.string().min(1)
+  purpose: z18.string().min(1)
 });
 function bearer2(c) {
   const header = c.req.header("authorization") ?? "";
@@ -12067,7 +12606,7 @@ function bearer2(c) {
   return match?.[1]?.trim() ?? null;
 }
 function createApp(deps) {
-  const { board: board2, version, turns: turns2, scheduler: scheduler2, models } = deps;
+  const { board: board2, version, turns: turns2, scheduler: scheduler2, models, quotas } = deps;
   const eventStreamPingMs = deps.eventStreamPingMs ?? 15e3;
   const app2 = new Hono3();
   app2.get("/health", (c) => c.json({ ok: true, version }));
@@ -12137,6 +12676,17 @@ function createApp(deps) {
   api.get("/agents/:name/history/:commit", async (c) => c.json(await board2.homeChange(c.req.param("name"), c.req.param("commit"))));
   api.get("/roles", async (c) => c.json(await board2.listRoles()));
   api.get("/runners", async (c) => c.json(await board2.listRunners()));
+  api.post("/runners/:name/quota/:cli", async (c) => {
+    if (c.get("actor").role !== USER_ROLE) {
+      throw new BoardError("FORBIDDEN", "only the user reads a runner's quota");
+    }
+    const runner = NameSchema.parse(c.req.param("name"));
+    const cli = CliKindSchema.parse(c.req.param("cli"));
+    if (quotas === void 0) {
+      throw new RunnerAwayError("this server asks no runner for quotas");
+    }
+    return c.json(await quotas.read(runner, cli));
+  });
   api.post("/runners", async (c) => {
     const body = RunnerBodySchema.parse(await c.req.json());
     return c.json(await board2.addRunner(c.get("actor"), body.name));
@@ -12173,6 +12723,10 @@ function createApp(deps) {
     const window = MetricsWindowSchema.parse(c.req.query("window") ?? "7d");
     return c.json(await board2.metrics(window, new Set(scheduler2?.activeSignals ?? [])));
   });
+  api.get("/tokens", async (c) => {
+    const window = MetricsWindowSchema.parse(c.req.query("window") ?? "24h");
+    return c.json(await board2.tokenUse(window));
+  });
   api.get("/society/knowledge", async (c) => c.json(await board2.listKnowledge(null)));
   api.get("/skills", async (c) => c.json(await board2.listSocietySkills()));
   api.post("/agents/:name/retire", async (c) => {
@@ -12216,7 +12770,7 @@ function createApp(deps) {
   });
   api.put("/roles/:name", async (c) => {
     const charter = RoleCharterSchema.parse({
-      ...z16.record(z16.string(), z16.unknown()).parse(await c.req.json()),
+      ...z18.record(z18.string(), z18.unknown()).parse(await c.req.json()),
       name: c.req.param("name")
     });
     return c.json(await board2.setRoleCharter(c.get("actor"), charter));
@@ -12566,6 +13120,35 @@ var ModelCatalog = class {
   }
 };
 
+// apps/server/dist/quotas.js
+var MINUTE = 6e4;
+var QuotaReads = class {
+  runners;
+  floorMs;
+  now;
+  kept = /* @__PURE__ */ new Map();
+  constructor(runners2, floorMs = MINUTE, now = Date.now) {
+    this.runners = runners2;
+    this.floorMs = floorMs;
+    this.now = now;
+  }
+  read(runner, cli) {
+    const key = `${runner}/${cli}`;
+    const kept = this.kept.get(key);
+    if (kept !== void 0 && this.now() - kept.at < this.floorMs) {
+      return kept.quota;
+    }
+    const quota = this.runners.quota(runner, cli);
+    this.kept.set(key, { at: this.now(), quota });
+    quota.catch(() => {
+      if (this.kept.get(key)?.quota === quota) {
+        this.kept.delete(key);
+      }
+    });
+    return quota;
+  }
+};
+
 // apps/server/dist/turn-hub.js
 var TurnHub = class {
   capacity;
@@ -12673,6 +13256,7 @@ var app = createApp({
   turns,
   scheduler: view,
   models: new ModelCatalog(runners),
+  quotas: new QuotaReads(runners),
   runners,
   webDir,
   signIn: { github: config.github, log },