@kubitnodes/stellaris 0.3.12 → 0.3.14

package/dist/cli/index.js

@@ -9,7 +9,7 @@ import { Command } from "commander";
 import { mkdir as mkdir4, readdir as readdir3, readFile as readFile5, rename as rename3, stat as stat2 } from "node:fs/promises";
 import path6 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // packages/shared/dist/ids.js
 import { z } from "zod";
@@ -60,7 +60,10 @@ var VERB_NAMES = [
   "remove_knowledge",
   "create_channel",
   "archive_channel",
-  "update_dashboard"
+  "update_dashboard",
+  "create_cron",
+  "update_cron",
+  "remove_cron"
 ];
 var VerbNameSchema = z2.enum(VERB_NAMES);
 var CharterTriggerSchema = z2.enum(["user_post", "ops_event", "heartbeat"]);
@@ -107,7 +110,10 @@ var MEMBER_VERBS = [
   "remove_knowledge",
   "plan_task",
   "advance_task",
-  "update_dashboard"
+  "update_dashboard",
+  "create_cron",
+  "update_cron",
+  "remove_cron"
 ];
 var GOVERNANCE_VERBS = ["approve", "reject"];
 var FRONT_DESK_VERBS = ["create_project"];
@@ -160,7 +166,126 @@ var SEED_ROLES = [
 ];
 
 // packages/shared/dist/board.js
+import { z as z4 } from "zod";
+
+// packages/shared/dist/crons.js
+import { Cron as Pattern } from "croner";
 import { z as z3 } from "zod";
+var CRON_FLOOR_MS = 15 * 6e4;
+var FIRE_SLACK_MS = 6e4;
+var FLOOR_LOOKAHEAD = 200;
+var DEFAULT_TIME_ZONE = "UTC";
+function canonicalTimeZone(zone) {
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: zone }).resolvedOptions().timeZone;
+  } catch {
+    return null;
+  }
+}
+var TimeZoneSchema = z3.string().trim().min(1).max(64).transform((zone, ctx) => {
+  const canonical = canonicalTimeZone(zone);
+  if (canonical === null) {
+    ctx.addIssue({
+      code: "custom",
+      message: `${zone} is not a time zone; name one as IANA does, such as Europe/Berlin, America/New_York, or UTC`
+    });
+    return z3.NEVER;
+  }
+  return canonical;
+});
+function pattern(expression, timeZone) {
+  return new Pattern(expression, { mode: "5-part", timezone: timeZone, paused: true });
+}
+function cronExpressionError(expression) {
+  try {
+    pattern(expression, DEFAULT_TIME_ZONE);
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+var CronExpressionSchema = z3.string().trim().min(1).max(120).superRefine((expression, ctx) => {
+  const error = cronExpressionError(expression);
+  if (error !== null) {
+    ctx.addIssue({
+      code: "custom",
+      message: `not a five-field cron expression (minute, hour, day of month, month, day of week): ${error}`
+    });
+  }
+});
+var CronScheduleSchema = z3.union([
+  z3.object({ cron: CronExpressionSchema, timezone: TimeZoneSchema.optional() }),
+  z3.object({ at: IsoDateTimeSchema })
+]);
+var CronRunSchema = z3.object({
+  turnId: UlidSchema,
+  at: IsoDateTimeSchema,
+  outcome: z3.enum(["completed", "failed", "stopped"])
+});
+var CronFrontmatterSchema = z3.object({
+  id: UlidSchema,
+  title: z3.string().trim().min(1).max(120),
+  agent: NameSchema,
+  scope: NameSchema,
+  thread: UlidSchema.optional(),
+  channel: NameSchema.optional(),
+  schedule: CronScheduleSchema,
+  createdBy: NameSchema,
+  createdAt: IsoDateTimeSchema,
+  /** When the current schedule took effect: set, changed, or resumed. It fires only after this. */
+  since: IsoDateTimeSchema,
+  paused: z3.object({ at: IsoDateTimeSchema, by: NameSchema }).optional(),
+  lastFiredAt: IsoDateTimeSchema.optional(),
+  /** When a time came while its previous fire's turn was still queued or running, so it passed. */
+  lastSkippedAt: IsoDateTimeSchema.optional(),
+  /** How the turn of its latest fire ended. */
+  lastRun: CronRunSchema.optional(),
+  /** Its turns that failed in a row, up to the latest. */
+  failures: z3.number().int().nonnegative().default(0),
+  ended: z3.object({ at: IsoDateTimeSchema, by: NameSchema, reason: z3.string().min(1) }).optional()
+});
+function isOneTime(schedule) {
+  return "at" in schedule;
+}
+function scheduleZone(schedule, societyZone) {
+  return isOneTime(schedule) ? societyZone : schedule.timezone ?? societyZone;
+}
+function fireTimes(schedule, societyZone, after, count) {
+  if (isOneTime(schedule)) {
+    const at = new Date(schedule.at);
+    return at > after && count > 0 ? [at] : [];
+  }
+  return pattern(schedule.cron, scheduleZone(schedule, societyZone)).nextRuns(count, after);
+}
+function shortestGapMs(schedule, societyZone, after) {
+  const times = fireTimes(schedule, societyZone, after, FLOOR_LOOKAHEAD);
+  let shortest = null;
+  for (let index = 1; index < times.length; index += 1) {
+    const gap = (times[index]?.getTime() ?? 0) - (times[index - 1]?.getTime() ?? 0);
+    shortest = shortest === null ? gap : Math.min(shortest, gap);
+  }
+  return shortest;
+}
+function nextFire(cron2, societyZone, floorMs = CRON_FLOOR_MS) {
+  if (cron2.ended !== void 0 || cron2.paused !== void 0) {
+    return null;
+  }
+  const fired = cron2.lastFiredAt === void 0 ? null : Date.parse(cron2.lastFiredAt);
+  const since = Date.parse(cron2.since);
+  if (isOneTime(cron2.schedule)) {
+    return fired !== null && fired >= since ? null : new Date(cron2.schedule.at);
+  }
+  const from = Math.max(since, fired === null ? since : fired + floorMs - FIRE_SLACK_MS, cron2.lastSkippedAt === void 0 ? since : Date.parse(cron2.lastSkippedAt));
+  return fireTimes(cron2.schedule, societyZone, new Date(from), 1)[0] ?? null;
+}
+function describeSchedule(schedule, societyZone) {
+  if (isOneTime(schedule)) {
+    return `once at ${schedule.at}`;
+  }
+  return schedule.timezone === void 0 ? `\`${schedule.cron}\` in the society's time zone, ${societyZone}` : `\`${schedule.cron}\` in ${schedule.timezone}`;
+}
+
+// packages/shared/dist/board.js
 var ASK_CHANNEL = "asks";
 var SOCIETY_CHANNELS = ["general", "governance", ASK_CHANNEL];
 var PROJECT_DEFAULT_CHANNELS = ["general"];
@@ -172,30 +297,32 @@ var SOCIETY_SCOPE = "society";
 function wakeScope(member, project2) {
   return project2 !== null && member.memberships.includes(project2) ? project2 : SOCIETY_SCOPE;
 }
-var CliKindSchema = z3.enum(["claude", "codex"]);
-var ArchivedChannelSchema = z3.object({
+var CliKindSchema = z4.enum(["claude", "codex"]);
+var ArchivedChannelSchema = z4.object({
   name: NameSchema,
   at: IsoDateTimeSchema,
   by: NameSchema,
-  reason: z3.string().min(1)
+  reason: z4.string().min(1)
 });
-var SocietySchema = z3.object({
-  name: z3.string().min(1),
-  version: z3.literal(1),
+var SocietySchema = z4.object({
+  name: z4.string().min(1),
+  version: z4.literal(1),
   createdAt: IsoDateTimeSchema,
   /** The channels that take posts; an archived one moves to `archivedChannels`. */
-  channels: z3.array(NameSchema),
-  archivedChannels: z3.array(ArchivedChannelSchema).default([])
+  channels: z4.array(NameSchema),
+  archivedChannels: z4.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 = z3.enum(["none", "merge", "ghpr"]);
+var CompletionEffectSchema = z4.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)?$/,
   /^ssh:\/\/git@github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/
 ];
 function githubRepository(remote) {
-  for (const pattern of GITHUB_REMOTE) {
-    const match = remote === null ? null : pattern.exec(remote);
+  for (const pattern2 of GITHUB_REMOTE) {
+    const match = remote === null ? null : pattern2.exec(remote);
     if (match?.[1] !== void 0 && match[2] !== void 0) {
       return { owner: match[1], name: match[2] };
     }
@@ -203,7 +330,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 = z3.string().trim().regex(PULL_REQUEST_URL, "a pull request's address, https://github.com/<owner>/<repo>/pull/<number>");
+var PullRequestUrlSchema = z4.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]) };
@@ -211,60 +338,65 @@ function parsePullRequestUrl(url) {
 function sameRepository(a, b) {
   return a.owner.toLowerCase() === b.owner.toLowerCase() && a.name.toLowerCase() === b.name.toLowerCase();
 }
-var MergeSubjectSchema = z3.string().trim().min(1).max(300).regex(/^[^\n]+$/, "a merge commit's subject is one line");
-var PullRequestLinkSchema = z3.object({
+var MergeSubjectSchema = z4.string().trim().min(1).max(300).regex(/^[^\n]+$/, "a merge commit's subject is one line");
+var PullRequestLinkSchema = z4.object({
   url: PullRequestUrlSchema,
-  number: z3.number().int().positive(),
+  number: z4.number().int().positive(),
   subject: MergeSubjectSchema.optional(),
-  body: z3.string().max(2e4).optional(),
+  body: z4.string().max(2e4).optional(),
   linkedBy: NameSchema,
-  linkedAt: IsoDateTimeSchema
+  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()
 });
-var DefaultBranchSchema = z3.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 = z3.string().regex(/^s[1-9][0-9]*$/, "expected a stage id such as s1");
+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 stageFields = {
-  name: z3.string().trim().min(1).max(120),
+  name: z4.string().trim().min(1).max(120),
   role: NameSchema.optional(),
   agent: NameSchema.optional(),
-  gate: z3.boolean().default(false)
+  gate: z4.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 = z3.object(stageFields).refine(oneAssignee, ONE_ASSIGNEE);
-var PlanEditStageSchema = z3.object({ id: StageIdSchema.optional(), ...stageFields }).refine(oneAssignee, ONE_ASSIGNEE);
-var PlanSchema = z3.array(PlanStageSchema);
-var PlanEditSchema = z3.array(PlanEditStageSchema);
-var ProjectSchema = z3.object({
+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({
   slug: NameSchema,
-  name: z3.string().min(1),
-  repo: z3.string().nullable(),
-  defaultBranch: z3.string().min(1),
+  name: z4.string().min(1),
+  repo: z4.string().nullable(),
+  defaultBranch: z4.string().min(1),
   /** The channels that take posts; an archived one moves to `archivedChannels`. */
-  channels: z3.array(NameSchema),
-  archivedChannels: z3.array(ArchivedChannelSchema).default([]),
-  members: z3.array(NameSchema),
-  approvers: z3.array(NameSchema),
-  requiredCapabilities: z3.array(z3.string()),
+  channels: z4.array(NameSchema),
+  archivedChannels: z4.array(ArchivedChannelSchema).default([]),
+  members: z4.array(NameSchema),
+  approvers: z4.array(NameSchema),
+  requiredCapabilities: z4.array(z4.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: z3.object({ at: IsoDateTimeSchema, by: NameSchema, reason: z3.string().min(1) }).optional()
+  archived: z4.object({ at: IsoDateTimeSchema, by: NameSchema, reason: z4.string().min(1) }).optional()
 });
-var TaskStepSchema = z3.object({
-  action: z3.enum(["advanced", "returned", "abandoned", "landed", "reopened"]),
+var TaskStepSchema = z4.object({
+  action: z4.enum(["advanced", "returned", "abandoned", "landed", "reopened"]),
   stage: StageIdSchema,
   to: StageIdSchema.nullable()
 });
-var ProposalStepSchema = z3.object({ action: z3.enum(["approved", "rejected"]) });
-var MessageStepSchema = z3.union([TaskStepSchema, ProposalStepSchema]);
+var ProposalStepSchema = z4.object({ action: z4.enum(["approved", "rejected"]) });
+var MessageStepSchema = z4.union([TaskStepSchema, ProposalStepSchema]);
 function isTaskStep(step) {
   return "stage" in step;
 }
-var MessageFrontmatterSchema = z3.object({
+var MessageFrontmatterSchema = z4.object({
   id: UlidSchema,
   author: NameSchema,
   channel: ChannelRefSchema,
@@ -276,18 +408,18 @@ var MessageFrontmatterSchema = z3.object({
   /** On a post a task verb made in the task's thread, or a decision in a proposal's: the step it recorded. */
   step: MessageStepSchema.optional(),
   ts: IsoDateTimeSchema,
-  mentions: z3.array(NameSchema)
+  mentions: z4.array(NameSchema)
 });
-var TaskStatusSchema = z3.enum(["open", "claimed", "done", "abandoned"]);
-var ThreadStateSchema = z3.enum(["open", "closed"]);
-var ThreadSubjectSchema = z3.object({
-  kind: z3.enum(["task", "proposal"]),
+var TaskStatusSchema = z4.enum(["open", "claimed", "done", "abandoned"]);
+var ThreadStateSchema = z4.enum(["open", "closed"]);
+var ThreadSubjectSchema = z4.object({
+  kind: z4.enum(["task", "proposal"]),
   id: UlidSchema
 });
-var ThreadFrontmatterSchema = z3.object({
+var ThreadFrontmatterSchema = z4.object({
   id: UlidSchema,
   channel: ChannelRefSchema,
-  title: z3.string().min(1).max(200),
+  title: z4.string().min(1).max(200),
   subject: ThreadSubjectSchema.optional(),
   state: ThreadStateSchema,
   openedBy: NameSchema,
@@ -295,28 +427,28 @@ var ThreadFrontmatterSchema = z3.object({
   closedBy: NameSchema.optional(),
   closedAt: IsoDateTimeSchema.optional()
 });
-var StageSchema = z3.object({
+var StageSchema = z4.object({
   id: StageIdSchema,
-  name: z3.string().min(1),
+  name: z4.string().min(1),
   role: NameSchema.optional(),
   agent: NameSchema.optional(),
-  gate: z3.boolean().default(false),
+  gate: z4.boolean().default(false),
   /** Everyone who has held the stage, oldest first. */
-  holders: z3.array(NameSchema).default([]),
+  holders: z4.array(NameSchema).default([]),
   completedBy: NameSchema.optional(),
   completedAt: IsoDateTimeSchema.optional()
 });
-var TaskReturnSchema = z3.object({
+var TaskReturnSchema = z4.object({
   from: StageIdSchema,
   by: NameSchema,
   at: IsoDateTimeSchema
 });
-var TaskFrontmatterSchema = z3.object({
+var TaskFrontmatterSchema = z4.object({
   id: UlidSchema,
   project: NameSchema,
   /** The channel of the project the task is filed in, where its thread hangs. */
   channel: NameSchema.default("general"),
-  title: z3.string().min(1),
+  title: z4.string().min(1),
   status: TaskStatusSchema,
   createdBy: NameSchema,
   createdAt: IsoDateTimeSchema,
@@ -325,19 +457,19 @@ var TaskFrontmatterSchema = z3.object({
   claimedBy: NameSchema.optional(),
   leaseExpiresAt: IsoDateTimeSchema.optional(),
   parentId: UlidSchema.optional(),
-  blockedBy: z3.array(UlidSchema),
-  requiredCapabilities: z3.array(z3.string()),
-  stages: z3.array(StageSchema).min(1),
+  blockedBy: z4.array(UlidSchema),
+  requiredCapabilities: z4.array(z4.string()),
+  stages: z4.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: z3.number().int().positive(),
+  stageSeq: z4.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: z3.boolean().default(false),
+  completing: z4.boolean().default(false),
   /** The latest send-back while its rework lasts: cleared once the task reaches that stage again. */
   returned: TaskReturnSchema.optional()
 });
@@ -361,79 +493,79 @@ function mayHoldStage(member, task2) {
   }
   return !(stage.gate && task2.stages.slice(0, index).some((s) => s.holders.includes(member.name)));
 }
-var ModelNameSchema = z3.string().trim().min(1).max(120).regex(/^[\w.:/[\]-]+$/, "a model name is one word of letters, digits, and . _ : / - [ ]");
-var EffortSchema = z3.string().trim().min(1).max(32).regex(/^[a-z][a-z0-9_-]*$/, "an effort is one lowercase word, such as high");
-var EffortOptionSchema = z3.object({
+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({
   id: EffortSchema,
-  description: z3.string().default("")
+  description: z4.string().default("")
 });
-var ModelOptionSchema = z3.object({
+var ModelOptionSchema = z4.object({
   id: ModelNameSchema,
-  name: z3.string(),
-  description: z3.string().default(""),
-  isDefault: z3.boolean().default(false),
-  efforts: z3.array(EffortOptionSchema).default([]),
+  name: z4.string(),
+  description: z4.string().default(""),
+  isDefault: z4.boolean().default(false),
+  efforts: z4.array(EffortOptionSchema).default([]),
   defaultEffort: EffortSchema.optional()
 });
-var RunnerModelsSchema = z3.object({
+var RunnerModelsSchema = z4.object({
   runner: NameSchema,
   cli: CliKindSchema,
-  models: z3.array(ModelOptionSchema)
+  models: z4.array(ModelOptionSchema)
 });
-var AgentStatusSchema = z3.enum(["active", "retired"]);
-var AgentSchema = z3.object({
+var AgentStatusSchema = z4.enum(["active", "retired"]);
+var AgentSchema = z4.object({
   name: NameSchema,
   role: NameSchema,
   cli: CliKindSchema.nullable(),
-  model: z3.string().optional(),
+  model: z4.string().optional(),
   /** The reasoning effort set for the agent's turns; the model's own default applies otherwise. */
-  effort: z3.string().optional(),
+  effort: z4.string().optional(),
   /** The runner preferred for the agent's turns where nothing else decides; any runner with its CLI otherwise. */
   homeRunner: NameSchema.optional(),
-  memberships: z3.array(NameSchema),
-  subscriptions: z3.array(ChannelRefSchema),
+  memberships: z4.array(NameSchema),
+  subscriptions: z4.array(ChannelRefSchema),
   status: AgentStatusSchema,
   createdAt: IsoDateTimeSchema,
-  tokenHash: z3.string().min(1),
+  tokenHash: z4.string().min(1),
   retiredAt: IsoDateTimeSchema.optional(),
-  retiredReason: z3.string().optional()
+  retiredReason: z4.string().optional()
 });
-var MemberSchema = z3.object({
+var MemberSchema = z4.object({
   name: NameSchema,
   role: NameSchema,
   cli: CliKindSchema.nullable(),
   homeRunner: NameSchema.optional(),
   status: AgentStatusSchema,
-  resident: z3.boolean().default(false),
+  resident: z4.boolean().default(false),
   /** The model configured on the record, if any; the CLI's own default applies otherwise. */
-  model: z3.string().optional(),
+  model: z4.string().optional(),
   /** The model the CLI reported on the citizen's last turn. */
-  lastModel: z3.string().optional(),
+  lastModel: z4.string().optional(),
   /** The reasoning effort configured on the record, if any; the model's own default applies otherwise. */
-  effort: z3.string().optional(),
+  effort: z4.string().optional(),
   /** The citizen's own skills, by name. */
-  skills: z3.array(NameSchema).default([]),
-  memberships: z3.array(NameSchema),
-  subscriptions: z3.array(ChannelRefSchema),
-  claimsHeld: z3.number().int().nonnegative().default(0),
-  tasksDone: z3.number().int().nonnegative().default(0),
+  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),
   lastTurnAt: IsoDateTimeSchema.optional(),
-  lastTurnOutcome: z3.string().optional(),
+  lastTurnOutcome: z4.string().optional(),
   createdAt: IsoDateTimeSchema,
   retiredAt: IsoDateTimeSchema.optional()
 });
-var RunnerOsSchema = z3.enum(["linux", "windows", "darwin"]);
-var RunnerSchema = z3.object({
+var RunnerOsSchema = z4.enum(["linux", "windows", "darwin"]);
+var RunnerSchema = z4.object({
   name: NameSchema,
   os: RunnerOsSchema,
-  clis: z3.array(CliKindSchema),
-  capabilities: z3.array(z3.string()),
+  clis: z4.array(CliKindSchema),
+  capabilities: z4.array(z4.string()),
   /** The release the runner reported when it last registered; absent until it has. */
-  version: z3.string().optional(),
-  status: z3.enum(["connected", "disconnected"]),
+  version: z4.string().optional(),
+  status: z4.enum(["connected", "disconnected"]),
   lastSeen: IsoDateTimeSchema.optional()
 });
-var ProposalKindSchema = z3.enum([
+var ProposalKindSchema = z4.enum([
   "role",
   "member",
   "channel",
@@ -442,43 +574,43 @@ var ProposalKindSchema = z3.enum([
   "skill",
   "archive"
 ]);
-var ProposalStatusSchema = z3.enum([
+var ProposalStatusSchema = z4.enum([
   "proposed",
   "approved",
   "rejected",
   "provisioned",
   "retired"
 ]);
-var MemberProposalSchema = z3.object({
+var MemberProposalSchema = z4.object({
   name: NameSchema,
   role: NameSchema,
   cli: CliKindSchema,
-  model: z3.string().optional(),
+  model: z4.string().optional(),
   homeRunner: NameSchema.optional(),
-  memberships: z3.array(NameSchema).default([]),
-  subscriptions: z3.array(ChannelRefSchema).default([]),
-  seedInstructions: z3.string().optional()
+  memberships: z4.array(NameSchema).default([]),
+  subscriptions: z4.array(ChannelRefSchema).default([]),
+  seedInstructions: z4.string().optional()
 });
-var ChannelProposalSchema = z3.object({
+var ChannelProposalSchema = z4.object({
   project: NameSchema.nullable().default(null),
   name: NameSchema,
-  purpose: z3.string().min(1)
+  purpose: z4.string().min(1)
 });
-var ReallocationProposalSchema = z3.object({
-  description: z3.string().min(1)
+var ReallocationProposalSchema = z4.object({
+  description: z4.string().min(1)
 });
-var RetirementProposalSchema = z3.object({
+var RetirementProposalSchema = z4.object({
   agent: NameSchema,
-  reason: z3.string().min(1)
+  reason: z4.string().min(1)
 });
-var ArchiveProposalSchema = z3.object({
+var ArchiveProposalSchema = z4.object({
   project: NameSchema,
-  reason: z3.string().min(1)
+  reason: z4.string().min(1)
 });
-var SkillProposalSchema = z3.object({
+var SkillProposalSchema = z4.object({
   name: NameSchema,
-  summary: z3.string().min(1).max(200),
-  body: z3.string().min(1)
+  summary: z4.string().min(1).max(200),
+  body: z4.string().min(1)
 });
 var ProposalCharterSchemas = {
   role: RoleCharterSchema,
@@ -550,17 +682,17 @@ function describeCharter(kind, charter) {
   }
   return `${kind} ${JSON.stringify(charter)}`;
 }
-var SkillSchema = z3.object({
+var SkillSchema = z4.object({
   name: NameSchema,
-  summary: z3.string().default(""),
-  scope: z3.enum(["own", "society"]),
-  path: z3.string().min(1)
+  summary: z4.string().default(""),
+  scope: z4.enum(["own", "society"]),
+  path: z4.string().min(1)
 });
-var HomeConflictSchema = z3.object({
+var HomeConflictSchema = z4.object({
   /** The copy, relative to the home. */
-  path: z3.string().min(1),
+  path: z4.string().min(1),
   /** The file beside it, whose version the board kept. */
-  file: z3.string().min(1),
+  file: z4.string().min(1),
   /** When the copy reached the board. */
   since: IsoDateTimeSchema
 });
@@ -568,200 +700,242 @@ var CONFLICT_COPY = /^(.+)\.conflict-[^/.]+$/;
 function conflictCopyOf(copy) {
   return CONFLICT_COPY.exec(copy)?.[1] ?? null;
 }
-var CommitIdSchema = z3.string().regex(/^[0-9a-f]{40}([0-9a-f]{24})?$/);
-var HomeFileChangeSchema = z3.object({
-  path: z3.string().min(1),
-  status: z3.enum(["added", "modified", "deleted"]),
+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"]),
   /** Lines added and removed, or null for a binary file. */
-  added: z3.number().int().nonnegative().nullable(),
-  removed: z3.number().int().nonnegative().nullable()
+  added: z4.number().int().nonnegative().nullable(),
+  removed: z4.number().int().nonnegative().nullable()
 });
-var HomeChangeSchema = z3.object({
+var HomeChangeSchema = z4.object({
   commit: CommitIdSchema,
   at: IsoDateTimeSchema,
-  kind: z3.enum(["turn", "board", "merge"]),
-  author: z3.string(),
+  kind: z4.enum(["turn", "board", "merge"]),
+  author: z4.string(),
   /** The turn that made it, from the runner's commit message. */
   turnId: UlidSchema.optional(),
-  subject: z3.string(),
-  files: z3.array(HomeFileChangeSchema)
+  subject: z4.string(),
+  files: z4.array(HomeFileChangeSchema)
 });
-var HomeHistorySchema = z3.object({
-  changes: z3.array(HomeChangeSchema),
+var HomeHistorySchema = z4.object({
+  changes: z4.array(HomeChangeSchema),
   /** Whether older commits remain past the ones read. */
-  more: z3.boolean()
+  more: z4.boolean()
 });
 var HomeFileDiffSchema = HomeFileChangeSchema.pick({ path: true, status: true }).extend({
-  patch: z3.string().nullable(),
+  patch: z4.string().nullable(),
   /** The patch was cut at its size limit. */
-  truncated: z3.boolean()
+  truncated: z4.boolean()
 });
-var KnowledgeSchema = z3.object({
+var KnowledgeSchema = z4.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
   updatedBy: NameSchema,
   updatedAt: IsoDateTimeSchema
 });
-var RemovedKnowledgeSchema = z3.object({
+var RemovedKnowledgeSchema = z4.object({
   topic: NameSchema,
   project: NameSchema.nullable(),
   removedBy: NameSchema,
   removedAt: IsoDateTimeSchema
 });
-var DashboardSchema = z3.object({
+var DashboardSchema = z4.object({
   project: NameSchema,
-  revision: z3.number().int().min(0),
+  revision: z4.number().int().min(0),
   /** Absent until someone updates the dashboard the project began with. */
   updatedBy: NameSchema.optional(),
   updatedAt: IsoDateTimeSchema.optional(),
-  body: z3.string()
+  body: z4.string()
 });
-var ProposalFrontmatterSchema = z3.object({
+var ProposalOriginSchema = z4.object({
+  scope: NameSchema,
+  thread: UlidSchema.optional(),
+  channel: NameSchema.optional()
+});
+var ProposalFrontmatterSchema = z4.object({
   id: UlidSchema,
   kind: ProposalKindSchema,
   proposedBy: NameSchema,
   status: ProposalStatusSchema,
   createdAt: IsoDateTimeSchema,
+  /** Absent for a proposal filed outside a turn, or before proposals recorded it. */
+  filedFrom: ProposalOriginSchema.optional(),
   decidedBy: NameSchema.optional(),
   decidedAt: IsoDateTimeSchema.optional(),
-  reason: z3.string().optional(),
-  charter: z3.record(z3.string(), z3.unknown()),
+  reason: z4.string().optional(),
+  charter: z4.record(z4.string(), z4.unknown()),
   /** What approval created, for kinds the board provisions: the agent, channel, role, or retirement. */
   provisionedAt: IsoDateTimeSchema.optional(),
-  provision: z3.record(z3.string(), z3.unknown()).optional()
+  provision: z4.record(z4.string(), z4.unknown()).optional()
 });
-var DecisionSchema = z3.object({
+var DecisionSchema = z4.object({
   id: UlidSchema,
   proposalId: UlidSchema,
   decidedBy: NameSchema,
-  outcome: z3.enum(["approved", "rejected"]),
-  reason: z3.string().optional(),
+  outcome: z4.enum(["approved", "rejected"]),
+  reason: z4.string().optional(),
   ts: IsoDateTimeSchema
 });
 
 // packages/shared/dist/verbs.js
-import { z as z4 } from "zod";
+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);
 var VerbInputs = {
-  post_message: z4.object({
+  post_message: z5.object({
     /** Required outside a thread; in one it may be left out, and must otherwise be the thread's. */
     channel: ChannelRefSchema.optional(),
-    body: z4.string().min(1),
+    body: z5.string().min(1),
     thread_id: UlidSchema.optional()
   }),
-  read_inbox: z4.object({
+  read_inbox: z5.object({
     since_cursor: UlidSchema.nullable().optional(),
-    limit: z4.number().int().positive().max(200).default(50),
-    advance: z4.boolean().default(true)
+    limit: z5.number().int().positive().max(200).default(50),
+    advance: z5.boolean().default(true)
   }),
-  search: z4.object({
-    query: z4.string().min(1),
+  search: z5.object({
+    query: z5.string().min(1),
     project: NameSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    limit: z4.number().int().positive().max(100).default(20)
+    limit: z5.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: z4.object({
+  open_thread: z5.object({
     task_id: UlidSchema.optional(),
     proposal_id: UlidSchema.optional(),
     channel: ChannelRefSchema.optional(),
-    title: z4.string().min(1).max(200).optional()
+    title: z5.string().min(1).max(200).optional()
   }),
-  close_thread: z4.object({ thread_id: UlidSchema, summary: z4.string().min(1) }),
-  create_task: z4.object({
+  close_thread: z5.object({ thread_id: UlidSchema, summary: z5.string().min(1) }),
+  create_task: z5.object({
     project: NameSchema,
-    title: z4.string().min(1).max(200),
-    body: z4.string().default(""),
+    title: z5.string().min(1).max(200),
+    body: z5.string().default(""),
     parent_id: UlidSchema.optional(),
-    required_capabilities: z4.array(z4.string()).default([]),
+    required_capabilities: z5.array(z5.string()).default([]),
     /** The plan; without it the task gets one stage, work, that anyone in the project may take. */
-    stages: z4.array(PlanStageSchema).min(1).optional(),
+    stages: z5.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: z4.object({ task_id: UlidSchema }),
-  release_task: z4.object({ task_id: UlidSchema }),
-  update_task: z4.object({
+  claim_task: z5.object({ task_id: UlidSchema }),
+  release_task: z5.object({ task_id: UlidSchema }),
+  update_task: z5.object({
     task_id: UlidSchema,
     /** Move the task back to this earlier stage. */
     stage: StageIdSchema.optional(),
-    status: z4.enum(["abandoned"]).optional(),
+    status: z5.enum(["abandoned"]).optional(),
     /** Posted to the task's thread as the caller, marked with the step when the task moved. */
-    note: z4.string().min(1).optional(),
-    blocked_by: z4.array(UlidSchema).optional(),
+    note: z5.string().min(1).optional(),
+    blocked_by: z5.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: z4.object({
+    pull_request: z5.object({
       url: PullRequestUrlSchema,
       merge_subject: MergeSubjectSchema.optional(),
-      merge_body: z4.string().max(2e4).optional()
+      merge_body: z5.string().max(2e4).optional()
     }).nullable().optional()
   }),
-  get_task: z4.object({ task_id: UlidSchema }),
-  subscribe: z4.object({ channel: ChannelRefSchema }),
-  unsubscribe: z4.object({ channel: ChannelRefSchema }),
-  propose: z4.object({
+  get_task: z5.object({ task_id: UlidSchema }),
+  subscribe: z5.object({ channel: ChannelRefSchema }),
+  unsubscribe: z5.object({ channel: ChannelRefSchema }),
+  propose: z5.object({
     kind: ProposalKindSchema,
-    charter: z4.record(z4.string(), z4.unknown()),
-    rationale: z4.string().default("")
+    charter: z5.record(z5.string(), z5.unknown()),
+    rationale: z5.string().default("")
   }),
-  approve: z4.object({ proposal_id: UlidSchema, reason: z4.string().optional() }),
-  reject: z4.object({ proposal_id: UlidSchema, reason: z4.string().min(1) }),
-  create_project: z4.object({
+  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({
     slug: NameSchema,
-    name: z4.string().min(1).optional(),
-    repo: z4.string().min(1).nullable().default(null),
+    name: z5.string().min(1).optional(),
+    repo: z5.string().min(1).nullable().default(null),
     default_branch: DefaultBranchSchema.default("main"),
     on_done: CompletionEffectSchema.optional()
   }),
-  join_project: z4.object({ project: NameSchema, agent: NameSchema.optional() }),
-  leave_project: z4.object({ project: NameSchema, agent: NameSchema.optional() }),
-  write_knowledge: z4.object({
+  join_project: z5.object({ project: NameSchema, agent: NameSchema.optional() }),
+  leave_project: z5.object({ project: NameSchema, agent: NameSchema.optional() }),
+  write_knowledge: z5.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: z4.string().min(1)
+    body: z5.string().min(1)
   }),
-  remove_knowledge: z4.object({
+  remove_knowledge: z5.object({
     /** As for write_knowledge: a project you belong to, or null for society knowledge. */
     project: NameSchema.nullable().default(null),
     topic: NameSchema
   }),
-  plan_task: z4.object({
+  plan_task: z5.object({
     task_id: UlidSchema,
-    stages: z4.array(PlanEditStageSchema),
+    stages: z5.array(PlanEditStageSchema),
     on_done: CompletionEffectSchema.optional()
   }),
   /** The note is posted to the task's thread as the caller, marked with the step. */
-  advance_task: z4.object({ task_id: UlidSchema, note: z4.string().min(1).optional() }),
-  configure_project: z4.object({
+  advance_task: z5.object({ task_id: UlidSchema, note: z5.string().min(1).optional() }),
+  configure_project: z5.object({
     project: NameSchema,
     on_done: CompletionEffectSchema.optional(),
     /** A new display name; the slug, which everything refers to the project by, never changes. */
-    name: z4.string().trim().min(1).max(120).optional(),
+    name: z5.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: z4.object({ project: NameSchema, reason: z4.string().min(1) }),
-  create_channel: z4.object({
+  archive_project: z5.object({ project: NameSchema, reason: z5.string().min(1) }),
+  create_channel: z5.object({
     /** A project, or null for a channel of the society. */
     project: NameSchema.nullable().default(null),
     name: NameSchema,
-    purpose: z4.string().min(1)
+    purpose: z5.string().min(1)
   }),
-  archive_channel: z4.object({ channel: ChannelRefSchema, reason: z4.string().min(1) }),
-  update_dashboard: z4.object({
+  archive_channel: z5.object({ channel: ChannelRefSchema, reason: z5.string().min(1) }),
+  update_dashboard: z5.object({
     project: NameSchema,
     /** The whole dashboard as markdown; the board keeps its frontmatter. */
-    body: z4.string().min(1),
+    body: z5.string().min(1),
     /** The `revision` in the frontmatter of the dashboard you read, 0 when it names none. */
-    revision: z4.number().int().min(0)
-  })
+    revision: z5.number().int().min(0)
+  }),
+  create_cron: z5.object({
+    title: CronTitleSchema,
+    /** What to do when it fires; quoted in the prompt of every turn it starts. */
+    note: CronNoteSchema,
+    /** Minute, hour, day of month, month, day of week, such as `0 9 * * 1-5`; or `at` instead. */
+    cron: CronExpressionSchema.optional(),
+    /** The IANA time zone `cron` is read in; the society's when left out. */
+    timezone: TimeZoneSchema.optional(),
+    /** One time to fire, instead of `cron`; the cron ends once it has fired. */
+    at: MomentSchema.optional(),
+    /** The citizen it wakes: yourself when left out. */
+    agent: NameSchema.optional(),
+    /** Where it fires: a project the citizen belongs to, or `society`; this turn's scope when left out. */
+    project: NameSchema.optional(),
+    /** An open thread there, whose conversation it fires in. */
+    thread_id: UlidSchema.optional(),
+    /** An open channel of that place other than general, whose conversation it fires in. */
+    channel: NameSchema.optional()
+  }),
+  update_cron: z5.object({
+    cron_id: UlidSchema,
+    /** Pause it, or resume it, which starts its schedule afresh from now. */
+    paused: z5.boolean().optional(),
+    title: CronTitleSchema.optional(),
+    note: CronNoteSchema.optional(),
+    /** A new expression, or `at` for one time; either starts the schedule afresh. */
+    cron: CronExpressionSchema.optional(),
+    /** The zone `cron` is read in; null for the society's. */
+    timezone: TimeZoneSchema.nullable().optional(),
+    at: MomentSchema.optional()
+  }),
+  remove_cron: z5.object({ cron_id: UlidSchema, reason: z5.string().trim().min(1) })
 };
 
 // packages/shared/dist/events.js
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var BOARD_EVENT_TYPES = [
   "society.initialized",
   "project.added",
@@ -814,30 +988,38 @@ var BOARD_EVENT_TYPES = [
   "turn.failed",
   "merge.completed",
   "merge.failed",
-  "workspace.leftovers"
+  "pull_request.closed",
+  "pull_request.close_failed",
+  "workspace.leftovers",
+  "society.configured",
+  "cron.created",
+  "cron.updated",
+  "cron.fired",
+  "cron.skipped",
+  "cron.ended"
 ];
-var BoardEventTypeSchema = z5.enum(BOARD_EVENT_TYPES);
-var BoardEventSchema = z5.object({
+var BoardEventTypeSchema = z6.enum(BOARD_EVENT_TYPES);
+var BoardEventSchema = z6.object({
   id: UlidSchema,
   ts: IsoDateTimeSchema,
   type: BoardEventTypeSchema,
   actor: NameSchema,
-  payload: z5.record(z5.string(), z5.unknown())
-});
-var UsageSchema = z5.object({
-  inputTokens: z5.number().int().nonnegative(),
-  outputTokens: z5.number().int().nonnegative(),
-  cacheReadTokens: z5.number().int().nonnegative().default(0),
-  cacheWriteTokens: z5.number().int().nonnegative().default(0)
-});
-var TurnStatusSchema = z5.object({
-  summary: z5.string().min(1),
-  claimsHeld: z5.array(UlidSchema).default([]),
-  blockedOn: z5.array(z5.string()).default([]),
-  needsUserDecision: z5.boolean().default(false),
-  memoryUpdated: z5.boolean().default(false)
-});
-var TurnExitReasonSchema = z5.enum([
+  payload: z6.record(z6.string(), z6.unknown())
+});
+var UsageSchema = z6.object({
+  inputTokens: z6.number().int().nonnegative(),
+  outputTokens: z6.number().int().nonnegative(),
+  cacheReadTokens: z6.number().int().nonnegative().default(0),
+  cacheWriteTokens: z6.number().int().nonnegative().default(0)
+});
+var TurnStatusSchema = z6.object({
+  summary: z6.string().min(1),
+  claimsHeld: z6.array(UlidSchema).default([]),
+  blockedOn: z6.array(z6.string()).default([]),
+  needsUserDecision: z6.boolean().default(false),
+  memoryUpdated: z6.boolean().default(false)
+});
+var TurnExitReasonSchema = z6.enum([
   "completed",
   "timeout",
   "error",
@@ -845,50 +1027,50 @@ var TurnExitReasonSchema = z5.enum([
   "blocked",
   "stopped"
 ]);
-var AgentEventSchema = z5.discriminatedUnion("type", [
-  z5.object({
-    type: z5.literal("turn_started"),
+var AgentEventSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("turn_started"),
     agent: NameSchema,
-    session: z5.string(),
+    session: z6.string(),
     runner: NameSchema,
     /** The model the CLI reports running, when it reports one. */
-    model: z5.string().optional()
+    model: z6.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.
    */
-  z5.object({
-    type: z5.literal("steered"),
-    steer: z5.string().min(1),
-    messages: z5.array(UlidSchema).optional(),
-    text: z5.string().optional()
+  z6.object({
+    type: z6.literal("steered"),
+    steer: z6.string().min(1),
+    messages: z6.array(UlidSchema).optional(),
+    text: z6.string().optional()
   }),
-  z5.object({ type: z5.literal("text"), delta: z5.string() }),
-  z5.object({ type: z5.literal("tool_call"), name: z5.string(), input: z5.unknown() }),
-  z5.object({
-    type: z5.literal("tool_result"),
-    name: z5.string(),
-    ok: z5.boolean(),
+  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(),
     /** What the tool returned, cut to `OUTPUT_LIMIT` characters by `capOutput`. */
-    output: z5.string().optional()
+    output: z6.string().optional()
   }),
-  z5.object({ type: z5.literal("approval_requested"), kind: z5.string(), detail: z5.unknown() }),
-  z5.object({
-    type: z5.literal("turn_completed"),
+  z6.object({ type: z6.literal("approval_requested"), kind: z6.string(), detail: z6.unknown() }),
+  z6.object({
+    type: z6.literal("turn_completed"),
     usage: UsageSchema,
-    costUsd: z5.number().nonnegative(),
+    costUsd: z6.number().nonnegative(),
     status: TurnStatusSchema.nullable(),
     exitReason: TurnExitReasonSchema
   }),
-  z5.object({ type: z5.literal("error"), message: z5.string() })
+  z6.object({ type: z6.literal("error"), message: z6.string() })
 ]);
-var TranscriptEntrySchema = z5.object({
+var TranscriptEntrySchema = z6.object({
   ts: IsoDateTimeSchema,
   event: AgentEventSchema
 });
-var LiveTurnEventSchema = z5.object({
-  seq: z5.number().int().positive(),
+var LiveTurnEventSchema = z6.object({
+  seq: z6.number().int().positive(),
   ts: IsoDateTimeSchema,
   agent: NameSchema,
   project: NameSchema,
@@ -900,97 +1082,97 @@ var LiveTurnEventSchema = z5.object({
 });
 
 // packages/shared/dist/turns.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // packages/shared/dist/runner.js
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var HOME_SCRATCH = "scratch";
 var HOME_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var RunnerHelloSchema = z6.object({
-  protocol: z6.number().int().positive(),
-  version: z6.string().min(1),
+var RunnerHelloSchema = z7.object({
+  protocol: z7.number().int().positive(),
+  version: z7.string().min(1),
   os: RunnerOsSchema,
-  clis: z6.array(CliKindSchema),
+  clis: z7.array(CliKindSchema),
   /** The CLIs whose adapter can keep a session warm between turns. */
-  residentClis: z6.array(CliKindSchema).default([]),
+  residentClis: z7.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can take input into a running turn; the server steers only these. */
-  steerableClis: z6.array(CliKindSchema).default([]),
+  steerableClis: z7.array(CliKindSchema).default([]),
   /** The CLIs whose adapter can stop a running turn; the server stops only these. */
-  stoppableClis: z6.array(CliKindSchema).default([]),
+  stoppableClis: z7.array(CliKindSchema).default([]),
   /** Whether the runner answers file reads on its projects' branches; one from before never does. */
-  branchReads: z6.boolean().default(false),
+  branchReads: z7.boolean().default(false),
   /** Whether the runner lists what a branch changed; one from before never does. */
-  branchChanges: z6.boolean().default(false),
-  capabilities: z6.array(z6.string()).default([]),
+  branchChanges: z7.boolean().default(false),
+  capabilities: z7.array(z7.string()).default([]),
   /** Turns the runner runs at once, or null for no limit. */
-  slots: z6.number().int().positive().nullable(),
+  slots: z7.number().int().positive().nullable(),
   /** Turns the runner is still running, when it registers again; the server fails the rest of its turns. */
-  turns: z6.array(UlidSchema).default([])
+  turns: z7.array(UlidSchema).default([])
 });
-var RunnerWelcomeSchema = z6.object({ name: NameSchema, version: z6.string() });
-var RunnerEnrollRequestSchema = z6.object({
-  protocol: z6.number().int().positive(),
-  version: z6.string().min(1).max(64),
-  hostname: z6.string().min(1).max(253),
+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),
   os: RunnerOsSchema,
-  clis: z6.array(CliKindSchema).max(8),
-  capabilities: z6.array(z6.string().min(1).max(64)).max(32).default([])
+  clis: z7.array(CliKindSchema).max(8),
+  capabilities: z7.array(z7.string().min(1).max(64)).max(32).default([])
 });
-var RunnerEnrollmentSchema = z6.object({
-  deviceCode: z6.string().min(1),
-  userCode: z6.string().min(1),
+var RunnerEnrollmentSchema = z7.object({
+  deviceCode: z7.string().min(1),
+  userCode: z7.string().min(1),
   expiresAt: IsoDateTimeSchema,
-  intervalMs: z6.number().int().positive()
+  intervalMs: z7.number().int().positive()
 });
-var RunnerEnrollPollSchema = z6.object({ deviceCode: z6.string().min(1) });
-var RunnerEnrollStatusSchema = z6.discriminatedUnion("status", [
-  z6.object({ status: z6.literal("pending") }),
-  z6.object({ status: z6.literal("approved"), name: NameSchema, token: z6.string().min(1) }),
-  z6.object({ status: z6.literal("denied") })
+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 PendingEnrollmentSchema = z6.object({
-  userCode: z6.string().min(1),
-  hostname: z6.string(),
+var PendingEnrollmentSchema = z7.object({
+  userCode: z7.string().min(1),
+  hostname: z7.string(),
   os: RunnerOsSchema,
-  clis: z6.array(CliKindSchema),
-  capabilities: z6.array(z6.string()),
-  version: z6.string(),
+  clis: z7.array(CliKindSchema),
+  capabilities: z7.array(z7.string()),
+  version: z7.string(),
   requestedAt: IsoDateTimeSchema,
   expiresAt: IsoDateTimeSchema
 });
-var ProjectRepoSchema = z6.object({
+var ProjectRepoSchema = z7.object({
   slug: NameSchema,
-  origin: z6.string().nullable(),
-  defaultBranch: z6.string().min(1),
+  origin: z7.string().nullable(),
+  defaultBranch: z7.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: z6.boolean()
+  boardLands: z7.boolean()
 });
-var TurnWorkspaceSchema = z6.discriminatedUnion("kind", [
-  z6.object({
-    kind: z6.literal("home"),
+var TurnWorkspaceSchema = z7.discriminatedUnion("kind", [
+  z7.object({
+    kind: z7.literal("home"),
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  z6.object({
-    kind: z6.literal("project"),
+  z7.object({
+    kind: z7.literal("project"),
     repo: ProjectRepoSchema,
-    branches: z6.array(z6.string().min(1)),
+    branches: z7.array(z7.string().min(1)),
     thread: UlidSchema.optional(),
     channel: NameSchema.optional()
   }),
-  z6.object({ kind: z6.literal("task"), repo: ProjectRepoSchema, taskId: UlidSchema })
+  z7.object({ kind: z7.literal("task"), repo: ProjectRepoSchema, taskId: UlidSchema })
 ]);
-var TurnJobSchema = z6.object({
+var TurnJobSchema = z7.object({
   turnId: UlidSchema,
   agent: NameSchema,
   role: NameSchema,
   cli: CliKindSchema,
-  model: z6.string().optional(),
+  model: z7.string().optional(),
   /** The reasoning effort set on the agent; absent for the model's own default. */
-  effort: z6.string().optional(),
+  effort: z7.string().optional(),
   /** A project slug, or the society scope. */
   scope: NameSchema,
   /** The thread whose conversation the turn is in; absent for the home conversation. */
@@ -1001,160 +1183,167 @@ var TurnJobSchema = z6.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: z6.string().min(1).nullable(),
+  session: z7.string().min(1).nullable(),
   /** The running total the session reported after its last turn, which a resumed session starts from. */
-  costSoFarUsd: z6.number().nonnegative(),
+  costSoFarUsd: z7.number().nonnegative(),
   /** The rendered charter, norms, memory core, and skills index, with `PATH_TOKENS` for places. */
-  instructions: z6.string(),
-  prompt: z6.string(),
-  mcp: z6.object({ url: z6.string().min(1), token: z6.string().min(1) }),
-  limits: z6.object({
-    timeoutMs: z6.number().int().positive().nullable(),
-    maxTurns: z6.number().int().positive().nullable()
+  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()
   }),
   /** Present when the runner keeps the conversation's session warm between turns, under `key`. */
-  resident: z6.object({ key: z6.string().min(1), idleMs: z6.number().int().positive() }).optional(),
+  resident: z7.object({ key: z7.string().min(1), idleMs: z7.number().int().positive() }).optional(),
   workspace: TurnWorkspaceSchema
 });
-var TurnWorkSchema = z6.object({ branch: z6.string().min(1), head: z6.string().min(1) });
-var TurnEventsSchema = z6.object({ entries: z6.array(TranscriptEntrySchema) });
-var TurnOutcomeSchema = z6.object({
+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({
   exitReason: TurnExitReasonSchema,
   status: TurnStatusSchema.nullable(),
-  error: z6.string().nullable(),
+  error: z7.string().nullable(),
   usage: UsageSchema,
-  costUsd: z6.number().nonnegative(),
+  costUsd: z7.number().nonnegative(),
   /** The session's running total after this turn, for CLIs that report one. */
-  sessionCostUsd: z6.number().nonnegative().optional(),
+  sessionCostUsd: z7.number().nonnegative().optional(),
   /** The session the CLI used, which differs from the job's for CLIs that assign their own ids. */
-  session: z6.string().min(1),
+  session: z7.string().min(1),
   /** The model the CLI reported, when it reported one. */
-  model: z6.string().nullable(),
+  model: z7.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: z6.boolean().default(false)
+  leftovers: z7.boolean().default(false)
 });
-var TurnAckSchema = z6.object({ dropWorkspace: z6.boolean() });
-var LandRequestSchema = z6.object({
+var TurnAckSchema = z7.object({ dropWorkspace: z7.boolean() });
+var LandRequestSchema = z7.object({
   repo: ProjectRepoSchema,
-  branch: z6.string().min(1),
+  branch: z7.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: z6.object({
-    url: z6.string().min(1),
-    subject: z6.string().min(1).optional(),
-    body: z6.string().optional()
+  pullRequest: z7.object({
+    url: z7.string().min(1),
+    subject: z7.string().min(1).optional(),
+    body: z7.string().optional()
   }).optional()
 });
-var MergeOutcomeSchema = z6.object({ ok: z6.boolean(), detail: z6.string() });
-var ModelListSchema = z6.array(ModelOptionSchema);
+var CloseRequestSchema = z7.object({
+  repo: ProjectRepoSchema,
+  url: z7.string().min(1),
+  comment: z7.string().min(1)
+});
+var MergeOutcomeSchema = z7.object({ ok: z7.boolean(), detail: z7.string() });
+var ModelListSchema = z7.array(ModelOptionSchema);
 var BRANCH_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
-var BranchPathSchema = z6.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 = z6.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/);
-var BranchReadSchema = z6.object({
+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({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema,
   path: BranchPathSchema
 });
-var BranchCommitSchema = z6.object({
-  id: z6.string().min(1),
+var BranchCommitSchema = z7.object({
+  id: z7.string().min(1),
   at: IsoDateTimeSchema,
-  author: z6.string()
+  author: z7.string()
 });
-var BranchFileSchema = z6.discriminatedUnion("kind", [
-  z6.object({
-    kind: z6.literal("file"),
+var BranchFileSchema = z7.discriminatedUnion("kind", [
+  z7.object({
+    kind: z7.literal("file"),
     path: BranchPathSchema,
     commit: BranchCommitSchema,
-    size: z6.number().int().nonnegative(),
-    content: z6.string().nullable()
+    size: z7.number().int().nonnegative(),
+    content: z7.string().nullable()
   }),
-  z6.object({
-    kind: z6.literal("dir"),
+  z7.object({
+    kind: z7.literal("dir"),
     path: BranchPathSchema,
     commit: BranchCommitSchema,
-    entries: z6.array(z6.object({
-      name: z6.string().min(1),
-      kind: z6.enum(["file", "dir"]),
-      size: z6.number().int().nonnegative().nullable()
+    entries: z7.array(z7.object({
+      name: z7.string().min(1),
+      kind: z7.enum(["file", "dir"]),
+      size: z7.number().int().nonnegative().nullable()
     }))
   })
 ]);
-var BranchChangesReadSchema = z6.object({
+var BranchChangesReadSchema = z7.object({
   repo: ProjectRepoSchema,
   branch: BranchNameSchema
 });
-var BranchFileChangeSchema = z6.object({
-  path: z6.string().min(1),
-  status: z6.enum(["added", "modified", "deleted"]),
+var BranchFileChangeSchema = z7.object({
+  path: z7.string().min(1),
+  status: z7.enum(["added", "modified", "deleted"]),
   /** Lines added and removed, or null for a binary file. */
-  added: z6.number().int().nonnegative().nullable(),
-  removed: z6.number().int().nonnegative().nullable(),
+  added: z7.number().int().nonnegative().nullable(),
+  removed: z7.number().int().nonnegative().nullable(),
   /** Absent when the file changed only through a merge of another branch. */
-  lastChange: z6.object({ author: z6.string(), at: IsoDateTimeSchema }).optional()
+  lastChange: z7.object({ author: z7.string(), at: IsoDateTimeSchema }).optional()
 });
-var BranchChangesSchema = z6.object({
+var BranchChangesSchema = z7.object({
   head: BranchCommitSchema,
-  files: z6.array(BranchFileChangeSchema),
-  total: z6.number().int().nonnegative()
+  files: z7.array(BranchFileChangeSchema),
+  total: z7.number().int().nonnegative()
 });
-var WorkspaceConversationSchema = z6.discriminatedUnion("kind", [
-  z6.object({ kind: z6.literal("thread"), id: UlidSchema }),
-  z6.object({ kind: z6.literal("channel"), scope: NameSchema, name: NameSchema })
+var WorkspaceConversationSchema = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("thread"), id: UlidSchema }),
+  z7.object({ kind: z7.literal("channel"), scope: NameSchema, name: NameSchema })
 ]);
-var HeldWorkspaceSchema = z6.object({
+var HeldWorkspaceSchema = z7.object({
   agent: NameSchema,
   scope: NameSchema,
   conversation: WorkspaceConversationSchema
 });
-var HeldWorkspacesSchema = z6.object({ workspaces: z6.array(HeldWorkspaceSchema) });
-var SweepResultSchema = z6.object({ kept: z6.array(HeldWorkspaceSchema) });
-var TurnSteerSchema = z6.object({ id: z6.uuid(), text: z6.string().min(1) });
-var RunnerMessageSchema = z6.discriminatedUnion("type", [
-  z6.object({ type: z6.literal("turn"), job: TurnJobSchema }),
-  z6.object({ type: z6.literal("land"), request: z6.string().min(1), land: LandRequestSchema }),
-  z6.object({ type: z6.literal("models"), request: z6.string().min(1), cli: CliKindSchema }),
+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 }),
+  /** 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 }),
   /** Answered with a `BranchFile`, or null when the branch or the path does not exist. */
-  z6.object({ type: z6.literal("file"), request: z6.string().min(1), read: BranchReadSchema }),
+  z7.object({ type: z7.literal("file"), request: z7.string().min(1), read: BranchReadSchema }),
   /** Answered with `BranchChanges`, or null when the repository or the branch does not exist. */
-  z6.object({
-    type: z6.literal("changes"),
-    request: z6.string().min(1),
+  z7.object({
+    type: z7.literal("changes"),
+    request: z7.string().min(1),
     read: BranchChangesReadSchema
   }),
   /** Answered with whether the CLI accepted it; that it took it comes as a `steered` event. */
-  z6.object({
-    type: z6.literal("steer"),
-    request: z6.string().min(1),
+  z7.object({
+    type: z7.literal("steer"),
+    request: z7.string().min(1),
     turnId: UlidSchema,
     steer: TurnSteerSchema
   }),
   /** Answered with whether the turn was there to stop; it ends `stopped`. */
-  z6.object({ type: z6.literal("stop"), request: z6.string().min(1), turnId: UlidSchema }),
+  z7.object({ type: z7.literal("stop"), request: z7.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.
    */
-  z6.object({
-    type: z6.literal("sweep"),
-    request: z6.string().min(1),
+  z7.object({
+    type: z7.literal("sweep"),
+    request: z7.string().min(1),
     conversation: WorkspaceConversationSchema
   })
 ]);
-var RunnerAnswerSchema = z6.discriminatedUnion("ok", [
-  z6.object({ ok: z6.literal(true), value: z6.unknown() }),
-  z6.object({ ok: z6.literal(false), error: z6.string() })
+var RunnerAnswerSchema = z7.discriminatedUnion("ok", [
+  z7.object({ ok: z7.literal(true), value: z7.unknown() }),
+  z7.object({ ok: z7.literal(false), error: z7.string() })
 ]);
-var WarmSessionsSchema = z6.object({ warm: z6.array(z6.string()) });
-var FileManifestSchema = z6.object({ files: z6.record(z6.string(), z6.string()) });
-var FileReadSchema = z6.object({ paths: z6.array(z6.string()) });
-var FileContentsSchema = z6.object({ files: z6.record(z6.string(), z6.string()) });
+var WarmSessionsSchema = z7.object({ warm: z7.array(z7.string()) });
+var FileManifestSchema = z7.object({ files: z7.record(z7.string(), z7.string()) });
+var FileReadSchema = z7.object({ paths: z7.array(z7.string()) });
+var FileContentsSchema = z7.object({ files: z7.record(z7.string(), z7.string()) });
 function isSafeRelativePath(file) {
   if (file.length === 0 || file.startsWith("/") || file.includes("\\") || file.includes("\0")) {
     return false;
@@ -1163,7 +1352,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z7.enum([
+var TriggerKindSchema = z8.enum([
   "mention",
   "stage",
   "task_done",
@@ -1174,27 +1363,32 @@ var TriggerKindSchema = z7.enum([
   "manual",
   "ops_event",
   "user_post",
-  "closing"
+  "closing",
+  "cron"
 ]);
-var TriggerSchema = z7.object({
+var TriggerSchema = z8.object({
   kind: TriggerKindSchema,
   from: NameSchema.optional(),
-  fromUser: z7.boolean().default(false),
-  reason: z7.string().default(""),
+  fromUser: z8.boolean().default(false),
+  reason: z8.string().default(""),
   taskId: UlidSchema.optional(),
   messageId: UlidSchema.optional(),
   /** The channel the waking message was posted in. */
-  channel: ChannelRefSchema.optional()
+  channel: ChannelRefSchema.optional(),
+  /** The cron that came due, for a `cron` wake. */
+  cronId: UlidSchema.optional()
 });
-var TurnThreadSchema = z7.object({ id: UlidSchema, task: z7.boolean() });
-var TurnDispatchSchema = z7.object({
+var TurnThreadSchema = z8.object({ id: UlidSchema, task: z8.boolean() });
+var TurnDispatchSchema = z8.object({
   agent: NameSchema,
   project: NameSchema,
   thread: TurnThreadSchema.optional(),
   channel: NameSchema.optional(),
   trigger: TriggerSchema,
-  priority: z7.number().int().min(0).max(2),
-  onboarding: z7.boolean().default(false)
+  priority: z8.number().int().min(0).max(2),
+  onboarding: z8.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()
 });
 function conversationPart(conversation) {
   return conversation.thread ?? (conversation.channel === void 0 ? void 0 : `#${conversation.channel}`);
@@ -1205,7 +1399,7 @@ function channelConversation(scope, channel) {
   const name = at < 0 ? channel : channel.slice(at + 1);
   return place === scope && name !== "general" ? name : void 0;
 }
-var TurnRecordSchema = z7.object({
+var TurnRecordSchema = z8.object({
   /** Assigned by the board when the turn begins; the turn's transcript is filed under it. */
   id: UlidSchema.optional(),
   agent: NameSchema,
@@ -1216,29 +1410,31 @@ var TurnRecordSchema = z7.object({
   channel: NameSchema.optional(),
   runner: NameSchema,
   cli: CliKindSchema.nullable(),
-  session: z7.string().nullable(),
+  session: z8.string().nullable(),
   trigger: TriggerSchema,
   startedAt: IsoDateTimeSchema,
   endedAt: IsoDateTimeSchema.nullable(),
   exitReason: TurnExitReasonSchema.nullable(),
   status: TurnStatusSchema.nullable(),
-  error: z7.string().nullable(),
+  error: z8.string().nullable(),
   usage: UsageSchema.nullable(),
-  costUsd: z7.number().nonnegative().default(0),
+  costUsd: z8.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: z7.number().nonnegative().optional(),
-  toolCalls: z7.number().int().nonnegative().default(0),
+  sessionCostUsd: z8.number().nonnegative().optional(),
+  toolCalls: z8.number().int().nonnegative().default(0),
   /** The model the CLI reported for this turn, else the model configured for the agent, else null. */
-  model: z7.string().nullable().default(null),
+  model: z8.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()
+  stoppedBy: NameSchema.optional(),
+  /** The crons whose fire started the turn, which record how it ended. */
+  crons: z8.array(UlidSchema).optional()
 });
-var RunningTurnSchema = z7.object({
+var RunningTurnSchema = z8.object({
   turnId: UlidSchema,
   agent: NameSchema,
   scope: NameSchema,
@@ -1246,49 +1442,49 @@ var RunningTurnSchema = z7.object({
   channel: NameSchema.optional(),
   cli: CliKindSchema,
   askedIn: ChannelRefSchema.optional(),
-  steerable: z7.boolean(),
-  stoppable: z7.boolean()
+  steerable: z8.boolean(),
+  stoppable: z8.boolean()
 });
-var SessionsFileSchema = z7.object({
-  claude: z7.string().optional(),
-  codex: z7.string().optional(),
+var SessionsFileSchema = z8.object({
+  claude: z8.string().optional(),
+  codex: z8.string().optional(),
   runner: NameSchema.optional()
 });
-var WakeRequestSchema = z7.object({
+var WakeRequestSchema = z8.object({
   agent: NameSchema,
   project: NameSchema,
-  reason: z7.string().default("manual wake"),
+  reason: z8.string().default("manual wake"),
   /** A manual wake, or a reflection turn requested ahead of the cadence. */
-  kind: z7.enum(["manual", "reflection"]).default("manual")
+  kind: z8.enum(["manual", "reflection"]).default("manual")
 });
-var TurnHistoryEntrySchema = z7.object({
+var TurnHistoryEntrySchema = z8.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: z7.enum(["completed", "failed"]),
+  outcome: z8.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: z7.string(),
-  exitReason: z7.string().nullable(),
-  costUsd: z7.number(),
+  trigger: z8.string(),
+  exitReason: z8.string().nullable(),
+  costUsd: z8.number(),
   /** The tokens the turn used; absent for turns logged before turns recorded them. */
   usage: UsageSchema.optional(),
-  model: z7.string().nullable(),
-  summary: z7.string().nullable(),
-  error: z7.string().nullable(),
+  model: z8.string().nullable(),
+  summary: z8.string().nullable(),
+  error: z8.string().nullable(),
   /** When the log recorded the turn's start; absent when the start is missing from the log. */
   startedAt: IsoDateTimeSchema.optional(),
-  toolCalls: z7.number().int().nonnegative().optional()
+  toolCalls: z8.number().int().nonnegative().optional()
 });
 
 // packages/shared/dist/ops.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var OPS_SIGNAL_KINDS = [
   "waiting_stage",
   "backlog",
@@ -1301,18 +1497,19 @@ var OPS_SIGNAL_KINDS = [
   "scaled",
   "runner",
   "home_conflict",
-  "stuck_workspace"
+  "stuck_workspace",
+  "cron_failing"
 ];
-var OpsSignalKindSchema = z8.enum(OPS_SIGNAL_KINDS);
-var OpsSignalSchema = z8.object({
+var OpsSignalKindSchema = z9.enum(OPS_SIGNAL_KINDS);
+var OpsSignalSchema = z9.object({
   kind: OpsSignalKindSchema,
   /** Identifies the condition, for example `backlog:demo:engineer`, so a persisting one is not logged again every pass. */
-  key: z8.string().min(1),
+  key: z9.string().min(1),
   /** One line a reader can act on. */
-  summary: z8.string().min(1),
+  summary: z9.string().min(1),
   /** The counter or timer value behind the signal. */
-  value: z8.number(),
-  threshold: z8.number().optional(),
+  value: z9.number(),
+  threshold: z9.number().optional(),
   project: NameSchema.optional(),
   agent: NameSchema.optional(),
   role: NameSchema.optional(),
@@ -1320,8 +1517,8 @@ var OpsSignalSchema = z8.object({
 });
 
 // packages/shared/dist/metrics.js
-import { z as z9 } from "zod";
-var MetricsWindowSchema = z9.enum(["24h", "7d", "all"]);
+import { z as z10 } from "zod";
+var MetricsWindowSchema = z10.enum(["24h", "7d", "all"]);
 var METRICS_WINDOW_MS = {
   "24h": 24 * 36e5,
   "7d": 7 * 24 * 36e5,
@@ -1332,9 +1529,9 @@ function isBoardAction(tool) {
   const verb = /^mcp__board__(.+)$/.exec(tool)?.[1];
   return verb !== void 0 && !READ_VERBS.some((read2) => read2 === verb);
 }
-var CountSchema = z9.number().int().nonnegative();
-var MsSchema = z9.number().nonnegative();
-var MetricsSchema = z9.object({
+var CountSchema = z10.number().int().nonnegative();
+var MsSchema = z10.number().nonnegative();
+var MetricsSchema = z10.object({
   window: MetricsWindowSchema,
   since: IsoDateTimeSchema.nullable(),
   until: IsoDateTimeSchema,
@@ -1342,12 +1539,12 @@ var MetricsSchema = z9.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: z9.object({
+  idle: z10.object({
     turns: CountSchema,
     idle: CountSchema,
     unknown: CountSchema,
-    byTrigger: z9.array(z9.object({ trigger: z9.string(), turns: CountSchema, idle: CountSchema })),
-    byAgent: z9.array(z9.object({
+    byTrigger: z10.array(z10.object({ trigger: z10.string(), turns: CountSchema, idle: CountSchema })),
+    byAgent: z10.array(z10.object({
       agent: NameSchema,
       role: NameSchema.nullable(),
       turns: CountSchema,
@@ -1355,33 +1552,33 @@ var MetricsSchema = z9.object({
     }))
   }),
   /** Work sent back to an earlier stage: over the tasks finished in the window, and by where. */
-  sentBack: z9.object({
+  sentBack: z10.object({
     finished: CountSchema,
     sendBacks: CountSchema,
     tasksSentBack: CountSchema,
-    byStage: z9.array(z9.object({ project: NameSchema, stage: z9.string(), count: CountSchema })),
-    bySender: z9.array(z9.object({ agent: NameSchema, count: CountSchema }))
+    byStage: z10.array(z10.object({ project: NameSchema, stage: z10.string(), count: CountSchema })),
+    bySender: z10.array(z10.object({ agent: NameSchema, count: CountSchema }))
   }),
   /** Posts in the threads of the tasks finished in the window, the board's own notices left out. */
-  messages: z9.object({
+  messages: z10.object({
     finished: CountSchema,
     messages: CountSchema,
-    byProject: z9.array(z9.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
-    busiest: z9.array(z9.object({
+    byProject: z10.array(z10.object({ project: NameSchema, finished: CountSchema, messages: CountSchema })),
+    busiest: z10.array(z10.object({
       taskId: UlidSchema,
-      title: z9.string(),
+      title: z10.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: z9.object({
+  latency: z10.object({
     mentions: CountSchema,
     /** Mentions no turn has followed yet. */
     unanswered: CountSchema,
     medianMs: MsSchema.nullable(),
     slowestMs: MsSchema.nullable(),
-    byAgent: z9.array(z9.object({
+    byAgent: z10.array(z10.object({
       agent: NameSchema,
       mentions: CountSchema,
       medianMs: MsSchema,
@@ -1389,81 +1586,81 @@ var MetricsSchema = z9.object({
     }))
   }),
   /** The user's decisions: proposals decided, questions answered, and stages passed or sent back. */
-  decisions: z9.object({
+  decisions: z10.object({
     total: CountSchema,
-    byDay: z9.array(z9.object({
-      day: z9.string(),
+    byDay: z10.array(z10.object({
+      day: z10.string(),
       proposals: CountSchema,
       answers: CountSchema,
       stages: CountSchema
     }))
   }),
   /** Tasks that needed a capability no connected runner offered, and whether they still do. */
-  blocked: z9.array(z9.object({
+  blocked: z10.array(z10.object({
     taskId: UlidSchema,
-    title: z9.string().nullable(),
+    title: z10.string().nullable(),
     project: NameSchema.nullable(),
-    summary: z9.string(),
+    summary: z10.string(),
     firstAt: IsoDateTimeSchema,
     lastAt: IsoDateTimeSchema,
-    holds: z9.boolean()
+    holds: z10.boolean()
   }))
 });
 
 // packages/shared/dist/config.js
-import { z as z10 } from "zod";
-var LogLevelSchema = z10.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
-var GithubSignInSchema = z10.object({
-  clientId: z10.string().min(1),
-  clientSecret: z10.string().min(1),
+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),
   /** Logins, lowercased; GitHub logins are case-insensitive. */
-  users: z10.array(z10.string().min(1)).min(1)
+  users: z11.array(z11.string().min(1)).min(1)
 });
-var ServerConfigSchema = z10.object({
-  dataDir: z10.string().min(1),
-  host: z10.string().min(1),
-  port: z10.number().int().positive().max(65535),
+var ServerConfigSchema = z11.object({
+  dataDir: z11.string().min(1),
+  host: z11.string().min(1),
+  port: z11.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: z10.string().min(1).nullable(),
+  publicUrl: z11.string().min(1).nullable(),
   logLevel: LogLevelSchema,
   /** Turns running at once across every runner, or null for no limit beyond each runner's own. */
-  concurrency: z10.number().int().positive().nullable(),
+  concurrency: z11.number().int().positive().nullable(),
   /** How long one turn may run before it is stopped, or null for no limit. */
-  turnTimeoutMs: z10.number().int().positive().nullable(),
+  turnTimeoutMs: z11.number().int().positive().nullable(),
   /** Rounds of tool calls one Claude turn may take, or null for no limit. */
-  toolRounds: z10.number().int().positive().nullable(),
+  toolRounds: z11.number().int().positive().nullable(),
   /** How long a resident session stays warm after its last turn. */
-  residentIdleMs: z10.number().int().positive(),
+  residentIdleMs: z11.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: z10.number().int().min(0).max(16)
+  trustedProxies: z11.number().int().min(0).max(16)
 });
-var RunnerConfigSchema = z10.object({
+var RunnerConfigSchema = z11.object({
   /** The board server, for example http://127.0.0.1:4700. */
-  serverUrl: z10.string().url(),
+  serverUrl: z11.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: z10.string().min(1).nullable(),
+  token: z11.string().min(1).nullable(),
   /** The runner's own data directory: the board mirror, agent homes, repositories, worktrees. */
-  dataDir: z10.string().min(1),
+  dataDir: z11.string().min(1),
   logLevel: LogLevelSchema,
   /** Turns this machine runs at once, or null for no limit. */
-  slots: z10.number().int().positive().nullable(),
-  clis: z10.array(CliKindSchema).min(1),
-  capabilities: z10.array(z10.string())
+  slots: z11.number().int().positive().nullable(),
+  clis: z11.array(CliKindSchema).min(1),
+  capabilities: z11.array(z11.string())
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.12";
+var STELLARIS_VERSION = "0.3.14";
 
 // packages/board-core/dist/errors.js
 var BoardError = class extends Error {
@@ -2008,32 +2205,32 @@ function filesOf(lines, status) {
 }
 
 // packages/board-core/dist/metrics.js
-import { z as z11 } from "zod";
-var TurnPayload = z11.object({
-  turnId: z11.string().optional(),
-  project: z11.string(),
-  thread: z11.string().optional(),
-  channel: z11.string().optional(),
-  trigger: z11.string()
-});
-var TaskPayload = z11.object({
-  taskId: z11.string(),
-  project: z11.string(),
-  from: z11.string().optional()
-});
-var MessagePayload = z11.object({
-  id: z11.string().optional(),
-  channel: z11.string(),
-  thread: z11.string().nullable().optional(),
-  mentions: z11.array(z11.string()).default([])
-});
-var SteeredPayload = z11.object({ messages: z11.array(z11.string()) });
-var SignalPayload = z11.object({
-  kind: z11.string(),
-  key: z11.string(),
-  summary: z11.string(),
-  taskId: z11.string().optional(),
-  project: z11.string().optional()
+import { z as z12 } from "zod";
+var TurnPayload = z12.object({
+  turnId: z12.string().optional(),
+  project: z12.string(),
+  thread: z12.string().optional(),
+  channel: z12.string().optional(),
+  trigger: z12.string()
+});
+var TaskPayload = z12.object({
+  taskId: z12.string(),
+  project: z12.string(),
+  from: z12.string().optional()
+});
+var MessagePayload = z12.object({
+  id: z12.string().optional(),
+  channel: z12.string(),
+  thread: z12.string().nullable().optional(),
+  mentions: z12.array(z12.string()).default([])
+});
+var SteeredPayload = z12.object({ messages: z12.array(z12.string()) });
+var SignalPayload = z12.object({
+  kind: z12.string(),
+  key: z12.string(),
+  summary: z12.string(),
+  taskId: z12.string().optional(),
+  project: z12.string().optional()
 });
 function median(values) {
   const sorted = values.toSorted((a, b) => a - b);
@@ -2402,6 +2599,13 @@ var BoardPaths = class {
   members() {
     return path5.join(this.society, "members");
   }
+  /** Crons, one file each with its note as the body; ended ones stay. */
+  crons() {
+    return path5.join(this.society, "crons");
+  }
+  cron(id) {
+    return path5.join(this.crons(), `${id}.md`);
+  }
   member(name) {
     return path5.join(this.members(), `${name}.md`);
   }
@@ -2548,41 +2752,41 @@ 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 = z12.object({
-  runners: z12.record(z12.string(), z12.object({ tokenHash: z12.string().min(1) }))
+var RunnerTokensSchema = z13.object({
+  runners: z13.record(z13.string(), z13.object({ tokenHash: z13.string().min(1) }))
 });
-var SignInsSchema = z12.object({
-  signIns: z12.array(z12.object({
-    tokenHash: z12.string().min(1),
-    login: z12.string().min(1),
+var SignInsSchema = z13.object({
+  signIns: z13.array(z13.object({
+    tokenHash: z13.string().min(1),
+    login: z13.string().min(1),
     /** The account's picture at the identity provider; sign-ins from before it have none. */
-    avatarUrl: z12.url().optional(),
+    avatarUrl: z13.url().optional(),
     createdAt: IsoDateTimeSchema,
     expiresAt: IsoDateTimeSchema
   })).default([])
 });
-var TurnHistoryPayloadSchema = z12.object({
+var TurnHistoryPayloadSchema = z13.object({
   project: NameSchema,
   thread: UlidSchema.optional(),
   channel: NameSchema.optional(),
-  trigger: z12.string().default("manual"),
-  exitReason: z12.string().nullable().default(null),
-  costUsd: z12.number().default(0),
+  trigger: z13.string().default("manual"),
+  exitReason: z13.string().nullable().default(null),
+  costUsd: z13.number().default(0),
   usage: UsageSchema.optional(),
-  model: z12.string().nullable().default(null),
-  summary: z12.string().nullable().default(null),
-  error: z12.string().nullable().default(null),
-  toolCalls: z12.number().int().nonnegative().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 = z12.object({ project: NameSchema, turnId: UlidSchema.optional() });
-var CursorsSchema = z12.object({
-  digest: z12.string().nullable(),
-  scopes: z12.record(z12.string(), z12.string()).default({}),
-  threadsFrom: z12.record(z12.string(), z12.string().nullable()).default({}),
-  channelsFrom: z12.record(z12.string(), z12.string().nullable()).default({}),
+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({}),
   /** How far a work role has read news, which goes to whichever of its general conversations reads first. */
-  news: z12.string().optional()
+  news: z13.string().optional()
 });
 var NO_CURSORS = { digest: null, scopes: {}, threadsFrom: {}, channelsFrom: {} };
 function conversationKey(scope, part) {
@@ -2621,7 +2825,7 @@ function byId(a, b) {
 function turnTime(record) {
   return record.endedAt ?? record.startedAt;
 }
-var PausedSchema = z12.object({ paused: z12.boolean() });
+var PausedSchema = z13.object({ paused: z13.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) {
@@ -2633,7 +2837,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 = z12.object({ applied: z12.array(z12.string()).default([]) });
+var AlignmentsSchema = z13.object({ applied: z13.array(z13.string()).default([]) });
 var FOLLOW_DECISIONS = "ops-readers-follow-decisions";
 var THREAD_RECORDS = "threads-as-records";
 var DIGEST_CURSORS = "digest-replaces-inbox";
@@ -2645,6 +2849,8 @@ var ASKS_CHANNEL_OPENED = "asks-channel-opened";
 var KNOWLEDGE_REMOVAL = "knowledge-removal-granted";
 var CHANNEL_CONVERSATIONS = "channel-conversations";
 var DASHBOARD_UPDATES = "dashboard-updates-granted";
+var CRON_VERBS = "cron-verbs-granted";
+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.";
 var DASHBOARD_LINE = "The project's members keep this page current with update_dashboard.";
 var PLANNING_ROLES = [USER_ROLE, "steward", "concierge"];
@@ -2846,7 +3052,8 @@ var Board = class _Board {
       ASKS_CHANNEL_OPENED,
       KNOWLEDGE_REMOVAL,
       CHANNEL_CONVERSATIONS,
-      DASHBOARD_UPDATES
+      DASHBOARD_UPDATES,
+      CRON_VERBS
     ].filter((name) => !applied.includes(name));
     if (pending.length === 0) {
       return;
@@ -2885,6 +3092,9 @@ var Board = class _Board {
       await this.grantBesideKnowledge("update_dashboard");
       await this.rewordDashboards();
     }
+    if (pending.includes(CRON_VERBS)) {
+      await this.grantToEveryRole(CRON_VERB_NAMES);
+    }
     await writeJson(file, { applied: [...applied, ...pending] });
   }
   /**
@@ -2898,6 +3108,15 @@ var Board = class _Board {
       }
     }
   }
+  /** Grants verbs once to every charter but the user's, which holds every verb already. */
+  async grantToEveryRole(verbs) {
+    for (const charter of await this.listRoles()) {
+      const missing = verbs.filter((verb) => !charter.verbs.includes(verb));
+      if (charter.name !== USER_ROLE && missing.length > 0) {
+        await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, ...missing] }, { verbsAdded: missing });
+      }
+    }
+  }
   /** A dashboard still saying agents may edit its file says how it changes now. */
   async rewordDashboards() {
     for (const slug of await listDirs(this.paths.projects())) {
@@ -3042,7 +3261,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), z12.record(z12.string(), z12.unknown()));
+        const raw = await readMarkdown(path6.join(this.paths.tasks(slug), file), z13.record(z13.string(), z13.unknown()));
         const legacy = raw.data["thread"];
         if (legacy === void 0) {
           continue;
@@ -3120,7 +3339,7 @@ var Board = class _Board {
    * turns, so it follows nothing now.
    */
   async renameInboxCursors() {
-    const Legacy = z12.object({ inbox: z12.string().nullable() });
+    const Legacy = z13.object({ inbox: z13.string().nullable() });
     for (const agent2 of await this.listAgents()) {
       const file = this.paths.agentCursors(agent2.name);
       if (await exists(file)) {
@@ -3166,7 +3385,7 @@ ${charter.purpose}
    */
   async alignSeedRole(seed) {
     const file = this.paths.role(seed.name);
-    const raw = await readMarkdown(file, z12.record(z12.string(), z12.unknown()));
+    const raw = await readMarkdown(file, z13.record(z13.string(), z13.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));
@@ -3479,14 +3698,14 @@ ${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, z12.record(z12.string(), z12.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
   }
   /** Knowledge topics of a project, or of the society when the project is null. */
   async listKnowledge(project2) {
     const dir = project2 === null ? this.paths.societyKnowledge() : this.paths.projectKnowledge(project2);
     const topics = [];
     for (const file of await listFiles(dir)) {
-      const doc = await readMarkdown(path6.join(dir, file), z12.record(z12.string(), z12.unknown()));
+      const doc = await readMarkdown(path6.join(dir, file), z13.record(z13.string(), z13.unknown()));
       const parsed = KnowledgeSchema.safeParse({
         ...doc.data,
         project: project2,
@@ -3886,6 +4105,21 @@ ${DASHBOARD_LINE}
       await this.events.append("paused.changed", actor.name, { paused });
     });
   }
+  /** Sets the society's time zone, the user's alone: crons that name none are read in it. */
+  async setTimezone(actor, zone) {
+    this.assertUser(actor, "only the user sets the society's time zone");
+    const timezone = TimeZoneSchema.parse(zone);
+    return this.mutex.run(async () => {
+      const doc = await readMarkdown(this.paths.societyFile(), SocietySchema);
+      const society = { ...doc.data, timezone };
+      await writeMarkdown(this.paths.societyFile(), society, doc.body);
+      await this.events.append("society.configured", actor.name, {
+        timezone,
+        previousTimezone: doc.data.timezone
+      });
+      return society;
+    });
+  }
   /** Releases every claim whose lease has expired. Called by the scheduler on its tick. */
   async expireLeases() {
     return this.mutex.run(async () => {
@@ -4308,6 +4542,241 @@ ${current.body}`);
       return updated;
     });
   }
+  /** Every cron, ended ones included, oldest first. */
+  async listCrons() {
+    const crons = [];
+    for (const file of await listFiles(this.paths.crons())) {
+      crons.push(await this.readCronFile(path6.join(this.paths.crons(), file)));
+    }
+    return crons;
+  }
+  async readCron(id) {
+    const file = this.paths.cron(id);
+    if (!await exists(file)) {
+      throw new BoardError("NOT_FOUND", `cron ${id} not found`);
+    }
+    return this.readCronFile(file);
+  }
+  /**
+   * Sets a cron: one that wakes its setter, or, set by a planning role, any citizen. Without a
+   * place named it fires in the conversation of the turn that set it.
+   */
+  async createCron(actor, input) {
+    const args = VerbInputs.create_cron.parse(input);
+    await this.authorize(actor, "create_cron");
+    const target = args.agent ?? actor.name;
+    this.assertMayCron(actor, target, "set");
+    if (args.cron === void 0 === (args.at === void 0)) {
+      throw new BoardError("VALIDATION", "a cron needs either cron, a five-field expression, or at, one time");
+    }
+    return this.mutex.run(async () => {
+      const agent2 = await this.readAgent(target);
+      if (agent2.status !== "active" || agent2.cli === null) {
+        throw new BoardError("INVALID_STATE", `${target} takes no turns, so no cron can wake it`);
+      }
+      const where = await this.cronConversation(actor, agent2, args);
+      const now = this.now();
+      const schedule = await this.cronSchedule(args, void 0, now);
+      if (schedule === void 0) {
+        throw new BoardError("VALIDATION", "a cron needs a schedule");
+      }
+      const cron2 = await this.writeCron({
+        id: this.newId(),
+        title: args.title,
+        agent: agent2.name,
+        ...where,
+        schedule,
+        createdBy: actor.name,
+        createdAt: now.toISOString(),
+        since: now.toISOString(),
+        failures: 0,
+        note: args.note
+      });
+      await this.events.append("cron.created", actor.name, {
+        ...this.cronPayload(cron2),
+        title: cron2.title,
+        schedule: cron2.schedule
+      });
+      return cron2;
+    });
+  }
+  /** Pauses, resumes, retitles, rewrites, or reschedules a cron; resuming or rescheduling starts it afresh. */
+  async updateCron(actor, input) {
+    const args = VerbInputs.update_cron.parse(input);
+    await this.authorize(actor, "update_cron");
+    if (args.cron !== void 0 && args.at !== void 0) {
+      throw new BoardError("VALIDATION", "a cron fires on an expression or at one time, not both");
+    }
+    return this.mutex.run(async () => {
+      const current = await this.readCron(args.cron_id);
+      this.assertMayCron(actor, current.agent, "change");
+      if (current.ended !== void 0) {
+        throw new BoardError("INVALID_STATE", `cron ${current.id} has ended (${current.ended.reason})`);
+      }
+      const now = this.now();
+      const schedule = await this.cronSchedule(args, current.schedule, now);
+      const resumed = args.paused === false && current.paused !== void 0;
+      const changed = [
+        ...args.title === void 0 ? [] : ["title"],
+        ...args.note === void 0 ? [] : ["note"],
+        ...schedule === void 0 ? [] : ["schedule"],
+        ...args.paused === true && current.paused === void 0 ? ["paused"] : [],
+        ...resumed ? ["resumed"] : []
+      ];
+      if (changed.length === 0 && args.paused === void 0) {
+        throw new BoardError("VALIDATION", "update_cron needs paused, title, note, cron, timezone, or at");
+      }
+      const ts = now.toISOString();
+      const { paused: wasPaused, ...rest } = current;
+      const paused = args.paused === void 0 ? wasPaused : args.paused ? wasPaused ?? { at: ts, by: actor.name } : void 0;
+      const cron2 = await this.writeCron({
+        ...rest,
+        ...args.title === void 0 ? {} : { title: args.title },
+        ...args.note === void 0 ? {} : { note: args.note },
+        ...schedule === void 0 ? {} : { schedule },
+        ...schedule !== void 0 || resumed ? { since: ts } : {},
+        ...paused === void 0 ? {} : { paused }
+      });
+      if (changed.length > 0) {
+        await this.events.append("cron.updated", actor.name, {
+          ...this.cronPayload(cron2),
+          changed,
+          ...schedule === void 0 ? {} : { schedule }
+        });
+      }
+      return cron2;
+    });
+  }
+  /** Ends a cron for good: its setter's, or anyone's for a planning role. */
+  async removeCron(actor, input) {
+    const args = VerbInputs.remove_cron.parse(input);
+    await this.authorize(actor, "remove_cron");
+    return this.mutex.run(async () => {
+      const current = await this.readCron(args.cron_id);
+      this.assertMayCron(actor, current.agent, "end");
+      if (current.ended !== void 0) {
+        throw new BoardError("INVALID_STATE", `cron ${current.id} has ended already (${current.ended.reason})`);
+      }
+      return this.endCronUnlocked(current, actor.name, args.reason);
+    });
+  }
+  /** A cron wakes its setter; one that wakes another citizen is the planning roles' to set, change, and end. */
+  assertMayCron(actor, agent2, what) {
+    if (agent2 !== actor.name && !PLANNING_ROLES.includes(actor.role)) {
+      throw new BoardError("FORBIDDEN", `only the user, the steward, and the concierge ${what} a cron that wakes another citizen`);
+    }
+  }
+  /**
+   * Where a cron fires for its citizen: the thread, the channel, or the scope's home it names, else
+   * the conversation of the turn that set it when it wakes its setter, else its home outside projects.
+   */
+  async cronConversation(actor, agent2, named) {
+    const own = actor.name === agent2.name;
+    if (named.project === void 0 && named.thread_id === void 0 && named.channel === void 0) {
+      return own && actor.scope !== void 0 ? this.cronConversation(actor, agent2, {
+        project: actor.scope,
+        thread_id: actor.thread,
+        channel: actor.channel
+      }) : { scope: SOCIETY_SCOPE };
+    }
+    if (named.thread_id !== void 0) {
+      const { thread: thread2 } = await this.findThread(named.thread_id);
+      if (thread2.state !== "open") {
+        throw new BoardError("INVALID_STATE", `thread ${thread2.id} is closed`);
+      }
+      const scope2 = wakeScope(agent2, parseChannelRef(thread2.channel).project);
+      if (named.project !== void 0 && named.project !== scope2) {
+        throw new BoardError("VALIDATION", `thread ${thread2.id} is on ${thread2.channel}, so ${agent2.name}'s conversation there is in ${scope2}, not ${named.project}`);
+      }
+      return { scope: scope2, thread: thread2.id };
+    }
+    const scope = named.project ?? (own ? actor.scope : void 0) ?? SOCIETY_SCOPE;
+    if (scope !== SOCIETY_SCOPE) {
+      await this.readActiveProject(scope);
+      if (!agent2.memberships.includes(scope)) {
+        throw new BoardError("VALIDATION", `${agent2.name} is not a member of ${scope}`);
+      }
+    }
+    if (named.channel === void 0 || named.channel === "general") {
+      return { scope };
+    }
+    await this.assertChannelOpen(channelRef(scope === SOCIETY_SCOPE ? null : scope, named.channel));
+    return { scope, channel: named.channel };
+  }
+  /**
+   * The schedule a cron verb asks for, or undefined when it asks for none: an expression, read in
+   * its zone or the society's, which must name a time to come and no two fires closer than the
+   * floor, or one time to come. A zone alone keeps the expression of `existing`.
+   */
+  async cronSchedule(args, existing, now) {
+    if (args.at !== void 0) {
+      if (args.timezone !== void 0) {
+        throw new BoardError("VALIDATION", "at carries its own offset; timezone is for a cron expression");
+      }
+      const at = new Date(args.at);
+      if (at <= now) {
+        throw new BoardError("VALIDATION", `${args.at} has passed; a cron fires at a time to come`);
+      }
+      return { at: at.toISOString() };
+    }
+    if (args.cron === void 0 && args.timezone === void 0) {
+      return void 0;
+    }
+    const expression = args.cron ?? (existing === void 0 || isOneTime(existing) ? void 0 : existing.cron);
+    if (expression === void 0) {
+      throw new BoardError("VALIDATION", "timezone is for a cron expression, which this cron has not");
+    }
+    const kept = args.timezone === void 0 && existing !== void 0 && !isOneTime(existing) ? existing.timezone : args.timezone ?? void 0;
+    const schedule = {
+      cron: expression,
+      ...kept === void 0 ? {} : { timezone: kept }
+    };
+    const { timezone: societyZone } = await this.society();
+    if (fireTimes(schedule, societyZone, now, 1).length === 0) {
+      throw new BoardError("VALIDATION", `${expression} names no time to come`);
+    }
+    const gap = shortestGapMs(schedule, societyZone, now);
+    if (gap !== null && gap < CRON_FLOOR_MS) {
+      throw new BoardError("VALIDATION", `${expression} fires ${Math.round(gap / 6e4)} minute(s) apart at its closest; a cron fires at most every ${CRON_FLOOR_MS / 6e4} minutes, and every fire is a turn`);
+    }
+    return schedule;
+  }
+  /** A cron's events name its citizen and the conversation it fires in, as turn events do. */
+  cronPayload(cron2) {
+    return {
+      cronId: cron2.id,
+      agent: cron2.agent,
+      project: cron2.scope,
+      ...cron2.thread === void 0 ? {} : { thread: cron2.thread },
+      ...cron2.channel === void 0 ? {} : { channel: cron2.channel }
+    };
+  }
+  async readCronFile(file) {
+    const doc = await readMarkdown(file, CronFrontmatterSchema);
+    return { ...doc.data, note: doc.body.trimEnd() };
+  }
+  async writeCron(cron2) {
+    const { note, ...frontmatter } = cron2;
+    const data = CronFrontmatterSchema.parse(Object.fromEntries(Object.entries(frontmatter).filter(([, value]) => value !== void 0)));
+    await writeMarkdown(this.paths.cron(cron2.id), data, note);
+    return { ...data, note };
+  }
+  async endCronUnlocked(cron2, by, reason) {
+    const ended = await this.writeCron({
+      ...cron2,
+      ended: { at: this.now().toISOString(), by, reason }
+    });
+    await this.events.append("cron.ended", by, { ...this.cronPayload(ended), reason });
+    return ended;
+  }
+  /** Ends every running cron `ends` picks, in the transaction that ends the conversation it fires in. */
+  async endCronsUnlocked(by, reason, ends) {
+    for (const cron2 of await this.listCrons()) {
+      if (cron2.ended === void 0 && ends(cron2)) {
+        await this.endCronUnlocked(cron2, by, reason);
+      }
+    }
+  }
   async openThread(actor, input) {
     const args = VerbInputs.open_thread.parse(input);
     await this.authorize(actor, "open_thread");
@@ -4524,6 +4993,7 @@ ${args.summary}`);
         threadId: thread2.id,
         channel: thread2.channel
       });
+      await this.endCronsUnlocked(actor.name, "its thread closed", (cron2) => cron2.thread === thread2.id);
       return summary;
     });
   }
@@ -5025,6 +5495,13 @@ ${args.summary}`);
           proposedBy: actor.name,
           status: "proposed",
           createdAt: this.now().toISOString(),
+          ...actor.scope === void 0 ? {} : {
+            filedFrom: {
+              scope: actor.scope,
+              ...actor.thread === void 0 ? {} : { thread: actor.thread },
+              ...actor.channel === void 0 ? {} : { channel: actor.channel }
+            }
+          },
           charter: parsed.data
         }),
         body: args.rationale
@@ -5196,6 +5673,7 @@ ${rationale}`}`);
         members: project2.members.filter((member) => member !== target)
       }));
       await this.refreshMember(target);
+      await this.endCronsUnlocked(actor.name, `${target} left ${args.project}`, (cron2) => cron2.agent === target && cron2.scope === args.project);
       await this.events.append("agent.left", actor.name, {
         name: target,
         project: args.project,
@@ -5264,6 +5742,12 @@ ${rationale}`}`);
         return this.archiveChannel(actor, VerbInputs.archive_channel.parse(input));
       case "update_dashboard":
         return this.updateDashboard(actor, VerbInputs.update_dashboard.parse(input));
+      case "create_cron":
+        return this.createCron(actor, VerbInputs.create_cron.parse(input));
+      case "update_cron":
+        return this.updateCron(actor, VerbInputs.update_cron.parse(input));
+      case "remove_cron":
+        return this.removeCron(actor, VerbInputs.remove_cron.parse(input));
       default:
         throw new BoardError("VALIDATION", `unknown verb ${String(verb)}`);
     }
@@ -5310,7 +5794,7 @@ ${rationale}`}`);
   }
   async readAgentRoleBody(agent2) {
     const file = this.paths.agentRole(agent2);
-    return await exists(file) ? (await readMarkdown(file, z12.record(z12.string(), z12.unknown()))).body : "";
+    return await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
   }
   /** The steps of one finished turn, as the runner handed them over when it ended. */
   /**
@@ -5488,6 +5972,9 @@ ${rationale}`}`);
       }
       await this.writeTurnRecord(parsed);
       await this.refreshMember(parsed.agent);
+      for (const id of parsed.crons ?? []) {
+        await this.recordCronRun(id, parsed, failed);
+      }
       if (parsed.exitReason === "stopped") {
         await this.events.append("turn.stopped", parsed.stoppedBy ?? USER_NAME, {
           ...parsed.id === void 0 ? {} : { turnId: parsed.id },
@@ -5525,6 +6012,29 @@ ${rationale}`}`);
       });
     });
   }
+  /**
+   * Records how closing an abandoned `ghpr` task's pull request on GitHub went, once: the task's
+   * link keeps it, so a restart does not try again.
+   */
+  async recordPullRequestClosed(actor, input) {
+    return this.mutex.run(async () => {
+      const location = await this.findTask(input.taskId);
+      const current = location.task;
+      const pull = current.pullRequest;
+      if (pull === void 0 || pull.closed !== void 0) {
+        return current;
+      }
+      const task2 = await this.writeTask(location.project, {
+        ...current,
+        pullRequest: {
+          ...pull,
+          closed: { at: this.now().toISOString(), ok: input.ok, detail: input.detail }
+        }
+      });
+      await this.events.append(input.ok ? "pull_request.closed" : "pull_request.close_failed", actor.name, { project: location.project, taskId: task2.id, url: pull.url, detail: input.detail });
+      return task2;
+    });
+  }
   /**
    * Records that a citizen's workspace in a conversation that has ended holds work on no branch, so
    * the scheduler gives the citizen a closing turn there to decide about it. False, recording
@@ -5546,6 +6056,45 @@ ${rationale}`}`);
       return true;
     });
   }
+  /**
+   * Records a cron's fire, which the scheduler made; a one-time cron ends with it. Null, recording
+   * nothing, for a cron ended or paused since the scheduler read it, which does not fire.
+   */
+  async cronFired(id, at) {
+    return this.mutex.run(async () => {
+      const current = await this.readCron(id);
+      if (current.ended !== void 0 || current.paused !== void 0) {
+        return null;
+      }
+      const cron2 = await this.writeCron({ ...current, lastFiredAt: at });
+      await this.events.append("cron.fired", SYSTEM_ACTOR.name, this.cronPayload(cron2));
+      return isOneTime(cron2.schedule) ? this.endCronUnlocked(cron2, SYSTEM_ACTOR.name, "fired once, as set") : cron2;
+    });
+  }
+  /** Records a time a cron passed because the turn of its previous fire was still queued or running. */
+  async cronSkipped(id, at) {
+    return this.mutex.run(async () => {
+      const cron2 = await this.writeCron({ ...await this.readCron(id), lastSkippedAt: at });
+      await this.events.append("cron.skipped", SYSTEM_ACTOR.name, this.cronPayload(cron2));
+      return cron2;
+    });
+  }
+  /**
+   * How the turn a cron's fire started ended. A failure counts toward `cron_failing`, a completed
+   * turn clears the count, and a stop, the user's decision, leaves it.
+   */
+  async recordCronRun(id, record, failed) {
+    if (record.id === void 0 || !await exists(this.paths.cron(id))) {
+      return;
+    }
+    const cron2 = await this.readCron(id);
+    const outcome = record.exitReason === "stopped" ? "stopped" : failed ? "failed" : "completed";
+    await this.writeCron({
+      ...cron2,
+      lastRun: { turnId: record.id, at: record.endedAt ?? this.now().toISOString(), outcome },
+      failures: outcome === "failed" ? cron2.failures + 1 : outcome === "completed" ? 0 : cron2.failures
+    });
+  }
   /**
    * Whether a conversation with a workspace of its own has ended: a thread closed, a task ended
    * (for one from before tasks had threads), or a channel archived.
@@ -5645,7 +6194,7 @@ ${rationale}`}`);
       return { project: slug, revision: 0, body: "" };
     }
     const { data, body } = await readLooseMarkdown(file);
-    const revision = z12.number().int().min(0).safeParse(data["revision"]);
+    const revision = z13.number().int().min(0).safeParse(data["revision"]);
     const updatedBy = NameSchema.safeParse(data["updatedBy"]);
     const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
     return {
@@ -5936,7 +6485,7 @@ ${seed}
         continue;
       }
       const file = this.paths.agentRole(agent2.name);
-      const body = await exists(file) ? (await readMarkdown(file, z12.record(z12.string(), z12.unknown()))).body : "";
+      const body = await exists(file) ? (await readMarkdown(file, z13.record(z13.string(), z13.unknown()))).body : "";
       const at = body.indexOf(`
 ${SEED_INSTRUCTIONS_HEADING}
 `);
@@ -6380,6 +6929,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         archivedChannels: [...current.archivedChannels, archived]
       }));
     }
+    await this.endCronsUnlocked(by, `${ref} was archived`, (cron2) => cron2.scope === scope && cron2.channel === channel || cron2.thread !== void 0 && threadsClosed.includes(cron2.thread));
     await this.events.append("channel.archived", by, {
       channel: ref,
       reason,
@@ -6484,6 +7034,7 @@ ${charter.purpose}
       });
       threadsClosed.push(doc.data.id);
     }
+    await this.endCronsUnlocked(by, `project ${slug} was archived`, (cron2) => cron2.scope === slug || cron2.thread !== void 0 && threadsClosed.includes(cron2.thread));
     const project2 = await this.updateProject(slug, (p) => ({
       ...p,
       members: [],
@@ -6548,6 +7099,7 @@ ${charter.purpose}
     }
     this.tokenIndex.delete(current.tokenHash);
     await this.refreshMember(name);
+    await this.endCronsUnlocked(by, `${name} was retired`, (cron2) => cron2.agent === name);
     await this.events.append("agent.retired", by, {
       name,
       role: agent2.role,
@@ -6757,7 +7309,8 @@ ${charter.purpose}
         proposalId,
         outcome,
         kind: proposal2.kind,
-        proposedBy: proposal2.proposedBy
+        proposedBy: proposal2.proposedBy,
+        ...proposal2.filedFrom === void 0 ? {} : { filedFrom: proposal2.filedFrom }
       });
       if (provision !== void 0) {
         await this.events.append("proposal.provisioned", actor.name, {
@@ -6858,6 +7411,7 @@ ${charter.purpose}
       channel: found.thread.channel,
       ended
     });
+    await this.endCronsUnlocked(by, `its thread closed: its ${found.thread.subject?.kind ?? "subject"} was ${ended}`, (cron2) => cron2.thread === subjectId);
   }
   async readMessagesIn(dir, since) {
     const messages = [];
@@ -7293,6 +7847,66 @@ program.command("resume").description("Allow wakeups again").action(async () =>
   await board.setPaused(board.userActor(), false);
   print({ paused: false }, () => "Society resumed");
 });
+program.command("society").description("The society's settings").command("timezone [zone]").description("Show the society's time zone, or set it: crons that name none are read in it").action(async (zone) => {
+  const board = await open();
+  const society = zone === void 0 ? await board.society() : await board.setTimezone(board.userActor(), zone);
+  print({ timezone: society.timezone }, () => `Time zone: ${society.timezone}`);
+});
+function describeCron(cron2, timeZone) {
+  const where = [
+    cron2.scope,
+    cron2.thread,
+    cron2.channel === void 0 ? void 0 : `#${cron2.channel}`
+  ].filter((part) => part !== void 0).join("/");
+  const next = nextFire(cron2, timeZone);
+  const state = cron2.ended !== void 0 ? `ended (${cron2.ended.reason})` : cron2.paused !== void 0 ? "paused" : next === null ? "no time to come" : `next ${next.toISOString()}`;
+  return `${cron2.id}	${cron2.agent}	${where}	${describeSchedule(cron2.schedule, timeZone)}	${state}	${cron2.title}`;
+}
+var cron = program.command("cron").description("Crons that wake citizens on a clock");
+cron.command("list").description("List crons, ended ones too with --all").option("--all", "include ended crons", false).action(async (opts) => {
+  const board = await open();
+  const { timezone } = await board.society();
+  const crons = (await board.listCrons()).filter((each) => opts.all || each.ended === void 0);
+  print(crons, () => crons.length === 0 ? "No crons." : crons.map((each) => describeCron(each, timezone)).join("\n"));
+});
+cron.command("add <agent> <title>").description("Set a cron that wakes a citizen, with a note on what to do then").requiredOption("--note <text>", "what the citizen does when it fires").option("--cron <expression>", "five fields: minute hour day-of-month month day-of-week").option("--timezone <zone>", "the zone the expression is read in; the society's otherwise").option("--at <time>", "one time to fire, with its offset, instead of --cron").option("--project <slug>", "where it fires: a project the citizen is in, or society").option("--thread <id>", "an open thread there whose conversation it fires in").option("--channel <name>", "an open channel there, other than general, whose conversation it fires in").option("--as <agent>", "act as this agent instead of the user").action(async (agentName, title, opts) => {
+  const board = await open();
+  const created = await board.createCron(await actorFor(board, opts.as), {
+    title,
+    note: opts.note,
+    agent: agentName,
+    ...opts.cron === void 0 ? {} : { cron: opts.cron },
+    ...opts.timezone === void 0 ? {} : { timezone: opts.timezone },
+    ...opts.at === void 0 ? {} : { at: opts.at },
+    ...opts.project === void 0 ? {} : { project: opts.project },
+    ...opts.thread === void 0 ? {} : { thread_id: opts.thread },
+    ...opts.channel === void 0 ? {} : { channel: opts.channel }
+  });
+  const { timezone } = await board.society();
+  print(created, () => `Cron set: ${describeCron(created, timezone)}`);
+});
+for (const [name, paused] of [
+  ["pause", true],
+  ["resume", false]
+]) {
+  cron.command(`${name} <id>`).description(paused ? "Pause a cron" : "Resume a paused cron from its next time").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
+    const board = await open();
+    const updated = await board.updateCron(await actorFor(board, opts.as), {
+      cron_id: id,
+      paused
+    });
+    const { timezone } = await board.society();
+    print(updated, () => describeCron(updated, timezone));
+  });
+}
+cron.command("remove <id>").description("End a cron for good").requiredOption("--reason <text>", "why it ends").option("--as <agent>", "act as this agent instead of the user").action(async (id, opts) => {
+  const board = await open();
+  const removed = await board.removeCron(await actorFor(board, opts.as), {
+    cron_id: id,
+    reason: opts.reason
+  });
+  print(removed, () => `Cron ${removed.id} ended`);
+});
 var knowledge = program.command("knowledge").description("Shared knowledge, by project or society");
 knowledge.command("list [project]").description("List knowledge topics of a project, or of the society when no project is given").action(async (projectSlug) => {
   const board = await open();