@kubitnodes/stellaris 0.3.12 → 0.3.14

package/dist/server/index.js

@@ -9,7 +9,7 @@ import { serve } from "@hono/node-server";
 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,141 @@ 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 CRON_FAILING_RUNS = 3;
+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(cron, societyZone, floorMs = CRON_FLOOR_MS) {
+  if (cron.ended !== void 0 || cron.paused !== void 0) {
+    return null;
+  }
+  const fired = cron.lastFiredAt === void 0 ? null : Date.parse(cron.lastFiredAt);
+  const since = Date.parse(cron.since);
+  if (isOneTime(cron.schedule)) {
+    return fired !== null && fired >= since ? null : new Date(cron.schedule.at);
+  }
+  const from = Math.max(since, fired === null ? since : fired + floorMs - FIRE_SLACK_MS, cron.lastSkippedAt === void 0 ? since : Date.parse(cron.lastSkippedAt));
+  return fireTimes(cron.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}`;
+}
+function localTime(date, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    weekday: "long",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const part = (type) => parts.find((each) => each.type === type)?.value ?? "";
+  return `${part("weekday")} ${part("year")}-${part("month")}-${part("day")} ${part("hour")}:${part("minute")}`;
+}
+
+// packages/shared/dist/board.js
 var ASK_CHANNEL = "asks";
 var SOCIETY_CHANNELS = ["general", "governance", ASK_CHANNEL];
 var PROJECT_DEFAULT_CHANNELS = ["general"];
@@ -172,30 +312,32 @@ var SOCIETY_SCOPE = "society";
 function wakeScope(member, project) {
   return project !== null && member.memberships.includes(project) ? project : 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 +345,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 +353,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 +423,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 +442,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 +472,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 +508,79 @@ function mayHoldStage(member, task) {
   }
   return !(stage.gate && task.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 +589,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 +697,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,196 +715,238 @@ 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 ProposalOriginSchema = z4.object({
+  scope: NameSchema,
+  thread: UlidSchema.optional(),
+  channel: NameSchema.optional()
 });
-var ProposalFrontmatterSchema = z3.object({
+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) })
 };
 var VERB_DESCRIPTIONS = {
   post_message: "Post a markdown message to a channel, or into a thread when thread_id is given; a thread's message goes to the thread's channel.",
@@ -786,11 +975,14 @@ var VERB_DESCRIPTIONS = {
   archive_project: "Archive a project whose work is finished or has moved: its members leave, its open threads close, and nothing more is posted, filed, or joined there, while its files and history stay. Refused while a task there is in play.",
   create_channel: "Open a channel in a project, or with project null in the society, for a workstream such as a release, whose tasks are filed there. You follow it; a notice in the place's general announces it, and members subscribe when it concerns them. User, steward, concierge.",
   archive_channel: "Archive a channel whose workstream is done: its open threads close, its followers stop following it, and nothing more is posted or filed there, while its history stays readable. Refused while a task filed there is in play, and for the channels the board itself uses. User, steward, concierge.",
-  update_dashboard: "Replace the dashboard of a project you are a member of, the status page the user reads on its view, with a whole markdown body. Pass the revision from the frontmatter of the dashboard you read; if it was updated since, the call is refused with the current text to merge yours into. dashboard.md in the board projection is a copy, so editing it changes nothing."
+  update_dashboard: "Replace the dashboard of a project you are a member of, the status page the user reads on its view, with a whole markdown body. Pass the revision from the frontmatter of the dashboard you read; if it was updated since, the call is refused with the current text to merge yours into. dashboard.md in the board projection is a copy, so editing it changes nothing.",
+  create_cron: "Set a cron that wakes you later: a title, a note on what to do then, and either cron, a five-field expression (minute hour day-of-month month day-of-week) read in timezone or the society's, or at, one time. It fires in this turn's conversation unless you name a project, thread_id, or channel, at most every 15 minutes, and every fire is a turn. Only the user, the steward, and the concierge set one that wakes another citizen (agent).",
+  update_cron: "Pause or resume a cron, or change its title, note, or schedule; resuming or rescheduling starts it afresh from now. Yours, or anyone's for the user, the steward, and the concierge.",
+  remove_cron: "End a cron for good, with a reason. Yours, or anyone's for the user, the steward, and the concierge. A cron also ends with its conversation, and a one-time cron once it fires."
 };
 
 // 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",
@@ -843,30 +1035,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())
+  payload: z6.record(z6.string(), z6.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 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 = 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 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 = z5.enum([
+var TurnExitReasonSchema = z6.enum([
   "completed",
   "timeout",
   "error",
@@ -874,50 +1074,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,
@@ -929,10 +1129,10 @@ 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 RUNNER_PROTOCOL = 1;
 var PATH_TOKENS = {
   home: "{{stellaris:home}}",
@@ -943,67 +1143,67 @@ var SERVER_TOKEN = "{{stellaris:server}}";
 var WORKSPACE_TOKEN = "{{stellaris:workspace}}";
 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()
 });
 function projectRepo(project) {
   return {
@@ -1013,29 +1213,29 @@ function projectRepo(project) {
     boardLands: project.onDone !== "none"
   };
 }
-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. */
@@ -1046,112 +1246,117 @@ 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 })
 ]);
 function workspaceConversationOf(turn) {
   if (turn.thread !== void 0) {
@@ -1159,53 +1364,55 @@ function workspaceConversationOf(turn) {
   }
   return turn.channel === void 0 ? null : { kind: "channel", scope: turn.scope, name: turn.channel };
 }
-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;
@@ -1214,7 +1421,7 @@ function isSafeRelativePath(file) {
 }
 
 // packages/shared/dist/turns.js
-var TriggerKindSchema = z7.enum([
+var TriggerKindSchema = z8.enum([
   "mention",
   "stage",
   "task_done",
@@ -1225,27 +1432,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}`);
@@ -1269,7 +1481,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,
@@ -1280,29 +1492,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,
@@ -1310,49 +1524,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",
@@ -1365,9 +1579,10 @@ var OPS_SIGNAL_KINDS = [
   "scaled",
   "runner",
   "home_conflict",
-  "stuck_workspace"
+  "stuck_workspace",
+  "cron_failing"
 ];
-var OpsSignalKindSchema = z8.enum(OPS_SIGNAL_KINDS);
+var OpsSignalKindSchema = z9.enum(OPS_SIGNAL_KINDS);
 var WAKING_SIGNAL_KINDS = [
   "backlog",
   "role_gap",
@@ -1377,15 +1592,15 @@ var WAKING_SIGNAL_KINDS = [
   "blocked_capability",
   "scaled"
 ];
-var OpsSignalSchema = z8.object({
+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(),
@@ -1393,8 +1608,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,
@@ -1405,9 +1620,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,
@@ -1415,12 +1630,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,
@@ -1428,33 +1643,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,
@@ -1462,61 +1677,61 @@ 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)
 });
 function limit(value, fallback) {
   if (value === void 0 || value.trim() === "") {
@@ -1554,25 +1769,25 @@ function loadServerConfig(env) {
     trustedProxies: Number(env["STELLARIS_TRUSTED_PROXIES"] ?? "0")
   });
 }
-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 {
@@ -2120,32 +2335,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()
+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 = z11.object({
-  taskId: z11.string(),
-  project: z11.string(),
-  from: z11.string().optional()
+var TaskPayload = z12.object({
+  taskId: z12.string(),
+  project: z12.string(),
+  from: z12.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 MessagePayload = z12.object({
+  id: z12.string().optional(),
+  channel: z12.string(),
+  thread: z12.string().nullable().optional(),
+  mentions: z12.array(z12.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()
+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);
@@ -2514,6 +2729,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`);
   }
@@ -2660,41 +2882,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) {
@@ -2733,7 +2955,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) {
@@ -2745,7 +2967,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";
@@ -2757,6 +2979,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"];
@@ -2958,7 +3182,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;
@@ -2997,6 +3222,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] });
   }
   /**
@@ -3010,6 +3238,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())) {
@@ -3154,7 +3391,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;
@@ -3232,7 +3469,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 agent of await this.listAgents()) {
       const file = this.paths.agentCursors(agent.name);
       if (await exists(file)) {
@@ -3278,7 +3515,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));
@@ -3591,14 +3828,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(project) {
     const dir = project === null ? this.paths.societyKnowledge() : this.paths.projectKnowledge(project);
     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,
@@ -3998,6 +4235,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 () => {
@@ -4420,6 +4672,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 agent = await this.readAgent(target);
+      if (agent.status !== "active" || agent.cli === null) {
+        throw new BoardError("INVALID_STATE", `${target} takes no turns, so no cron can wake it`);
+      }
+      const where = await this.cronConversation(actor, agent, 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 cron = await this.writeCron({
+        id: this.newId(),
+        title: args.title,
+        agent: agent.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(cron),
+        title: cron.title,
+        schedule: cron.schedule
+      });
+      return cron;
+    });
+  }
+  /** 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 cron = 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(cron),
+          changed,
+          ...schedule === void 0 ? {} : { schedule }
+        });
+      }
+      return cron;
+    });
+  }
+  /** 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, agent, what) {
+    if (agent !== 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, agent, named) {
+    const own = actor.name === agent.name;
+    if (named.project === void 0 && named.thread_id === void 0 && named.channel === void 0) {
+      return own && actor.scope !== void 0 ? this.cronConversation(actor, agent, {
+        project: actor.scope,
+        thread_id: actor.thread,
+        channel: actor.channel
+      }) : { scope: SOCIETY_SCOPE };
+    }
+    if (named.thread_id !== void 0) {
+      const { thread } = await this.findThread(named.thread_id);
+      if (thread.state !== "open") {
+        throw new BoardError("INVALID_STATE", `thread ${thread.id} is closed`);
+      }
+      const scope2 = wakeScope(agent, parseChannelRef(thread.channel).project);
+      if (named.project !== void 0 && named.project !== scope2) {
+        throw new BoardError("VALIDATION", `thread ${thread.id} is on ${thread.channel}, so ${agent.name}'s conversation there is in ${scope2}, not ${named.project}`);
+      }
+      return { scope: scope2, thread: thread.id };
+    }
+    const scope = named.project ?? (own ? actor.scope : void 0) ?? SOCIETY_SCOPE;
+    if (scope !== SOCIETY_SCOPE) {
+      await this.readActiveProject(scope);
+      if (!agent.memberships.includes(scope)) {
+        throw new BoardError("VALIDATION", `${agent.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(cron) {
+    return {
+      cronId: cron.id,
+      agent: cron.agent,
+      project: cron.scope,
+      ...cron.thread === void 0 ? {} : { thread: cron.thread },
+      ...cron.channel === void 0 ? {} : { channel: cron.channel }
+    };
+  }
+  async readCronFile(file) {
+    const doc = await readMarkdown(file, CronFrontmatterSchema);
+    return { ...doc.data, note: doc.body.trimEnd() };
+  }
+  async writeCron(cron) {
+    const { note, ...frontmatter } = cron;
+    const data = CronFrontmatterSchema.parse(Object.fromEntries(Object.entries(frontmatter).filter(([, value]) => value !== void 0)));
+    await writeMarkdown(this.paths.cron(cron.id), data, note);
+    return { ...data, note };
+  }
+  async endCronUnlocked(cron, by, reason) {
+    const ended = await this.writeCron({
+      ...cron,
+      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 cron of await this.listCrons()) {
+      if (cron.ended === void 0 && ends(cron)) {
+        await this.endCronUnlocked(cron, by, reason);
+      }
+    }
+  }
   async openThread(actor, input) {
     const args = VerbInputs.open_thread.parse(input);
     await this.authorize(actor, "open_thread");
@@ -4636,6 +5123,7 @@ ${args.summary}`);
         threadId: thread.id,
         channel: thread.channel
       });
+      await this.endCronsUnlocked(actor.name, "its thread closed", (cron) => cron.thread === thread.id);
       return summary;
     });
   }
@@ -5137,6 +5625,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
@@ -5308,6 +5803,7 @@ ${rationale}`}`);
         members: project.members.filter((member) => member !== target)
       }));
       await this.refreshMember(target);
+      await this.endCronsUnlocked(actor.name, `${target} left ${args.project}`, (cron) => cron.agent === target && cron.scope === args.project);
       await this.events.append("agent.left", actor.name, {
         name: target,
         project: args.project,
@@ -5376,6 +5872,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)}`);
     }
@@ -5422,7 +5924,7 @@ ${rationale}`}`);
   }
   async readAgentRoleBody(agent) {
     const file = this.paths.agentRole(agent);
-    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. */
   /**
@@ -5600,6 +6102,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 },
@@ -5637,6 +6142,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 task = 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: task.id, url: pull.url, detail: input.detail });
+      return task;
+    });
+  }
   /**
    * 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
@@ -5658,6 +6186,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 cron = await this.writeCron({ ...current, lastFiredAt: at });
+      await this.events.append("cron.fired", SYSTEM_ACTOR.name, this.cronPayload(cron));
+      return isOneTime(cron.schedule) ? this.endCronUnlocked(cron, SYSTEM_ACTOR.name, "fired once, as set") : cron;
+    });
+  }
+  /** 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 cron = await this.writeCron({ ...await this.readCron(id), lastSkippedAt: at });
+      await this.events.append("cron.skipped", SYSTEM_ACTOR.name, this.cronPayload(cron));
+      return cron;
+    });
+  }
+  /**
+   * 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 cron = await this.readCron(id);
+    const outcome = record.exitReason === "stopped" ? "stopped" : failed ? "failed" : "completed";
+    await this.writeCron({
+      ...cron,
+      lastRun: { turnId: record.id, at: record.endedAt ?? this.now().toISOString(), outcome },
+      failures: outcome === "failed" ? cron.failures + 1 : outcome === "completed" ? 0 : cron.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.
@@ -5757,7 +6324,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 {
@@ -6048,7 +6615,7 @@ ${seed}
         continue;
       }
       const file = this.paths.agentRole(agent.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}
 `);
@@ -6492,6 +7059,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`, (cron) => cron.scope === scope && cron.channel === channel || cron.thread !== void 0 && threadsClosed.includes(cron.thread));
     await this.events.append("channel.archived", by, {
       channel: ref,
       reason,
@@ -6596,6 +7164,7 @@ ${charter.purpose}
       });
       threadsClosed.push(doc.data.id);
     }
+    await this.endCronsUnlocked(by, `project ${slug} was archived`, (cron) => cron.scope === slug || cron.thread !== void 0 && threadsClosed.includes(cron.thread));
     const project = await this.updateProject(slug, (p) => ({
       ...p,
       members: [],
@@ -6660,6 +7229,7 @@ ${charter.purpose}
     }
     this.tokenIndex.delete(current.tokenHash);
     await this.refreshMember(name);
+    await this.endCronsUnlocked(by, `${name} was retired`, (cron) => cron.agent === name);
     await this.events.append("agent.retired", by, {
       name,
       role: agent.role,
@@ -6869,7 +7439,8 @@ ${charter.purpose}
         proposalId,
         outcome,
         kind: proposal.kind,
-        proposedBy: proposal.proposedBy
+        proposedBy: proposal.proposedBy,
+        ...proposal.filedFrom === void 0 ? {} : { filedFrom: proposal.filedFrom }
       });
       if (provision !== void 0) {
         await this.events.append("proposal.provisioned", actor.name, {
@@ -6970,6 +7541,7 @@ ${charter.purpose}
       channel: found.thread.channel,
       ended
     });
+    await this.endCronsUnlocked(by, `its thread closed: its ${found.thread.subject?.kind ?? "subject"} was ${ended}`, (cron) => cron.thread === subjectId);
   }
   async readMessagesIn(dir, since) {
     const messages = [];
@@ -7033,6 +7605,8 @@ function decideWake(input) {
       return { wake: true, reason: "user post", priority: 2 };
     case "closing":
       return { wake: true, reason: "an ended conversation left work on no branch", priority: 1 };
+    case "cron":
+      return { wake: true, reason: "a cron came due", priority: 1 };
     case "heartbeat":
       break;
   }
@@ -7047,7 +7621,7 @@ function decideWake(input) {
 }
 
 // packages/scheduler/dist/scheduler.js
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function besideFields(beside) {
   if (beside === void 0) {
     return {};
@@ -7074,21 +7648,21 @@ var DEFAULT_TIMINGS = Object.freeze({
   scaleCooldownMs: 36e5,
   reflectionMs: 24 * 36e5
 });
-var SchedulerTimingsSchema = z13.object({
-  pollMs: z13.number().positive(),
-  debounceMs: z13.number().nonnegative(),
-  userDebounceMs: z13.number().nonnegative(),
-  heartbeatMs: z13.number().positive(),
-  waitingStageMs: z13.number().positive(),
-  leaseSweepMs: z13.number().positive(),
-  opsIntervalMs: z13.number().positive(),
-  signalRepeatMs: z13.number().positive(),
-  costReportMs: z13.number().positive(),
-  staleThreadMs: z13.number().positive(),
-  idleMemberMs: z13.number().positive(),
-  homeConflictMs: z13.number().positive(),
-  scaleCooldownMs: z13.number().positive(),
-  reflectionMs: z13.number().positive()
+var SchedulerTimingsSchema = z14.object({
+  pollMs: z14.number().positive(),
+  debounceMs: z14.number().nonnegative(),
+  userDebounceMs: z14.number().nonnegative(),
+  heartbeatMs: z14.number().positive(),
+  waitingStageMs: z14.number().positive(),
+  leaseSweepMs: z14.number().positive(),
+  opsIntervalMs: z14.number().positive(),
+  signalRepeatMs: z14.number().positive(),
+  costReportMs: z14.number().positive(),
+  staleThreadMs: z14.number().positive(),
+  idleMemberMs: z14.number().positive(),
+  homeConflictMs: z14.number().positive(),
+  scaleCooldownMs: z14.number().positive(),
+  reflectionMs: z14.number().positive()
 }).partial();
 function parseTimings(input) {
   const parsed = SchedulerTimingsSchema.parse(input);
@@ -7100,31 +7674,32 @@ function parseTimings(input) {
   }
   return overrides;
 }
-var PendingSchema = z13.object({
+var PendingSchema = z14.object({
   dispatch: TurnDispatchSchema,
-  readyAt: z13.number(),
-  stageWakes: z13.array(TriggerSchema).optional(),
-  holder: z13.boolean().optional(),
+  readyAt: z14.number(),
+  stageWakes: z14.array(TriggerSchema).optional(),
+  holder: z14.boolean().optional(),
   newestMessage: UlidSchema.optional(),
-  onlyMessages: z13.boolean().optional(),
-  steeredThrough: UlidSchema.optional()
+  onlyMessages: z14.boolean().optional(),
+  steeredThrough: UlidSchema.optional(),
+  onlyCrons: z14.boolean().optional()
 });
-var StateSchema = z13.object({
-  cursor: z13.string().nullable(),
-  lastHeartbeat: z13.record(z13.string(), z13.string()),
+var StateSchema = z14.object({
+  cursor: z14.string().nullable(),
+  lastHeartbeat: z14.record(z14.string(), z14.string()),
   /** Waiting stages already signalled, as `task:stage`, so each is logged once while it waits. */
-  waitingSeen: z13.record(z13.string(), z13.string()).default({}),
+  waitingSeen: z14.record(z14.string(), z14.string()).default({}),
   /** Queued dispatches survive a restart; the cursor has already moved past the events that made them. */
-  pending: z13.record(z13.string(), PendingSchema).default({}),
-  opsReported: z13.record(z13.string(), z13.string()).default({}),
-  releaseCounts: z13.record(z13.string(), z13.number().int().nonnegative()).default({}),
-  lastOps: z13.string().nullable().default(null),
-  lastScaled: z13.record(z13.string(), z13.string()).default({}),
-  lastCostReport: z13.string().nullable().default(null),
-  costSinceReport: z13.number().nonnegative().default(0),
-  turnsSinceReport: z13.number().int().nonnegative().default(0),
+  pending: z14.record(z14.string(), PendingSchema).default({}),
+  opsReported: z14.record(z14.string(), z14.string()).default({}),
+  releaseCounts: z14.record(z14.string(), z14.number().int().nonnegative()).default({}),
+  lastOps: z14.string().nullable().default(null),
+  lastScaled: z14.record(z14.string(), z14.string()).default({}),
+  lastCostReport: z14.string().nullable().default(null),
+  costSinceReport: z14.number().nonnegative().default(0),
+  turnsSinceReport: z14.number().int().nonnegative().default(0),
   /** When each member last reflected, or was first seen; the cadence counts from here. */
-  lastReflection: z13.record(z13.string(), z13.string()).default({})
+  lastReflection: z14.record(z14.string(), z14.string()).default({})
 });
 function messageOf(trigger) {
   return trigger.kind === "mention" || trigger.kind === "user_post" ? trigger.messageId : void 0;
@@ -7150,6 +7725,9 @@ function stringArray(value) {
 function stringOf(value) {
   return typeof value === "string" ? value : null;
 }
+function awaitsClosing(task) {
+  return task.status === "abandoned" && task.onDone === "ghpr" && task.pullRequest !== void 0 && task.pullRequest.closed === void 0;
+}
 function inPlay(task) {
   return (task.status === "open" || task.status === "claimed") && !task.completing;
 }
@@ -7182,6 +7760,9 @@ var Scheduler = class {
   steering = /* @__PURE__ */ new Map();
   /** Tasks whose completion effect waits for the turn that finished their last stage to end. */
   completions = /* @__PURE__ */ new Map();
+  /** Abandoned `ghpr` tasks whose pull request waits to be closed, by task id, with its project. */
+  closings = /* @__PURE__ */ new Map();
+  /** Completions and closings under way. */
   completing = /* @__PURE__ */ new Set();
   /** Running turns that must run alone among their citizen's, by session key: see `heldBack`. */
   exclusive = /* @__PURE__ */ new Map();
@@ -7189,6 +7770,8 @@ var Scheduler = class {
   landing = /* @__PURE__ */ new Set();
   /** Sweeps of ended conversations' workspaces under way, which `drain` and `stop` wait for. */
   sweeping = /* @__PURE__ */ new Set();
+  /** Crons whose fire's turn is running; a cron's next time passes while one is. */
+  cronsInFlight = /* @__PURE__ */ new Set();
   state = StateSchema.parse({
     cursor: null,
     lastHeartbeat: {}
@@ -7268,6 +7851,7 @@ var Scheduler = class {
       this.state.cursor = event.id;
     }
     if (!paused) {
+      await this.checkCrons(now);
       await this.checkHeartbeats(now);
       await this.checkWaitingStages(now);
       await this.checkReflections(now);
@@ -7281,6 +7865,7 @@ var Scheduler = class {
       this.lastSweep = now;
     }
     this.runCompletions();
+    this.runClosings();
     if (!paused) {
       await this.dispatchReady(now);
     }
@@ -7308,6 +7893,9 @@ var Scheduler = class {
         if (task.completing) {
           this.completions.set(task.id, { project: project.slug, actor: USER_NAME });
         }
+        if (awaitsClosing(task)) {
+          this.closings.set(task.id, project.slug);
+        }
       }
     }
     this.loaded = true;
@@ -7416,6 +8004,7 @@ var Scheduler = class {
         const taskId = stringOf(payload["taskId"]);
         if (taskId !== null && payload["to"] === "abandoned") {
           delete this.state.releaseCounts[taskId];
+          await this.queueClosing(taskId);
         }
         if (taskId !== null) {
           await this.pruneStageWakes(taskId);
@@ -7520,6 +8109,13 @@ var Scheduler = class {
         }
         return;
       }
+      case "cron.ended": {
+        const cronId = stringOf(payload["cronId"]);
+        if (cronId !== null && event.actor !== SYSTEM_ACTOR.name) {
+          this.dropCronWakes(cronId);
+        }
+        return;
+      }
       case "proposal.decided": {
         const proposalId = stringOf(payload["proposalId"]);
         const proposer = stringOf(payload["proposedBy"]);
@@ -7755,13 +8351,16 @@ var Scheduler = class {
       reason: "a conversation you took part in has ended, and its workspace holds work on no branch"
     }, now, beside);
   }
-  /** A decided proposal wakes the citizen that made it, to carry on with what it enables. */
+  /**
+   * A decided proposal wakes the citizen that made it, to carry on with what it enables, in the
+   * conversation it was filed from, where that work waits on the decision.
+   */
   async wakeProposer(proposalId, proposer, event, now) {
     const agent = await this.tryReadAgent(proposer);
     if (agent === null) {
       return;
     }
-    const scope = this.scopeForProject(agent, null);
+    const { scope, beside } = await this.filedFrom(agent, event.payload["filedFrom"]);
     const kind = stringOf(event.payload["kind"]) ?? "";
     const outcome = stringOf(event.payload["outcome"]) ?? "decided";
     this.enqueue(agent.name, scope, {
@@ -7769,7 +8368,27 @@ var Scheduler = class {
       from: event.actor,
       fromUser: event.actor === USER_NAME,
       reason: `your ${kind} proposal ${proposalId} was ${outcome} by ${event.actor}`
-    }, now);
+    }, now, beside);
+  }
+  /**
+   * The conversation a proposal was filed from while it is still open; its scope's home once it
+   * has ended; and the home outside projects when the citizen has left that scope, or the proposal
+   * names none, filed outside a turn or before proposals recorded it.
+   */
+  async filedFrom(agent, recorded) {
+    const origin = ProposalOriginSchema.safeParse(recorded);
+    if (!origin.success || origin.data.scope !== SOCIETY_SCOPE && !agent.memberships.includes(origin.data.scope)) {
+      return { scope: this.scopeForProject(agent, null) };
+    }
+    const scope = origin.data.scope;
+    const conversation = workspaceConversationOf(origin.data);
+    if (conversation === null || await this.board.conversationEnded(conversation)) {
+      return { scope };
+    }
+    return {
+      scope,
+      beside: conversation.kind === "thread" ? { thread: await this.conversationOf(conversation.id, scope) } : { channel: conversation.name }
+    };
   }
   /**
    * A thread's conversation for a turn in `scope`, and whether it is a task's in that scope, whose
@@ -7828,6 +8447,7 @@ var Scheduler = class {
     const readyAt = now + debounce;
     const existing = this.pending.get(key);
     const message = messageOf(trigger);
+    const cron = trigger.kind === "cron" ? trigger.cronId : void 0;
     if (existing === void 0) {
       this.pending.set(key, {
         dispatch: {
@@ -7836,24 +8456,30 @@ var Scheduler = class {
           ...besideFields(beside),
           trigger,
           priority: decision.priority,
-          onboarding: trigger.kind === "onboarding"
+          onboarding: trigger.kind === "onboarding",
+          ...cron === void 0 ? {} : { crons: [cron] }
         },
         readyAt,
         ...trigger.kind === "stage" ? { stageWakes: [trigger] } : {},
         ...message === void 0 ? {} : { newestMessage: message },
-        onlyMessages: message !== void 0
+        onlyMessages: message !== void 0,
+        onlyCrons: cron !== void 0
       });
       return;
     }
     const newestMessage = later(existing.newestMessage, message);
     const keepNew = decision.priority > existing.dispatch.priority;
     const priority = keepNew ? decision.priority : existing.dispatch.priority;
+    const crons = [
+      .../* @__PURE__ */ new Set([...existing.dispatch.crons ?? [], ...cron === void 0 ? [] : [cron]])
+    ];
     this.pending.set(key, {
       dispatch: {
         ...existing.dispatch,
         trigger: keepNew ? trigger : existing.dispatch.trigger,
         priority,
-        onboarding: existing.dispatch.onboarding || trigger.kind === "onboarding"
+        onboarding: existing.dispatch.onboarding || trigger.kind === "onboarding",
+        ...crons.length === 0 ? {} : { crons }
       },
       readyAt: Math.min(existing.readyAt, readyAt),
       ...existing.stageWakes !== void 0 && trigger.kind === "stage" ? {
@@ -7862,7 +8488,8 @@ var Scheduler = class {
       } : {},
       ...newestMessage === void 0 ? {} : { newestMessage },
       onlyMessages: existing.onlyMessages === true && message !== void 0,
-      ...existing.steeredThrough === void 0 ? {} : { steeredThrough: existing.steeredThrough }
+      ...existing.steeredThrough === void 0 ? {} : { steeredThrough: existing.steeredThrough },
+      onlyCrons: existing.onlyCrons === true && cron !== void 0
     });
   }
   /** Debounce coalesces chatter: mentions, stage handoffs, and bursts of signals. Everything else runs at once. */
@@ -7972,6 +8599,71 @@ var Scheduler = class {
       }
     }
   }
+  /**
+   * Each active cron whose next time has come wakes its citizen in its conversation, unless the turn
+   * of its previous fire is still queued or running, in which case the time passes. The fire is
+   * recorded on the board, so its next time counts from it and a restart does not fire it again.
+   */
+  async checkCrons(now) {
+    const crons = (await this.board.listCrons()).filter((cron) => cron.ended === void 0 && cron.paused === void 0);
+    if (crons.length === 0) {
+      return;
+    }
+    const { timezone } = await this.board.society();
+    for (const cron of crons) {
+      const due = nextFire(cron, timezone);
+      if (due === null || due.getTime() > now) {
+        continue;
+      }
+      if (this.cronQueuedOrRunning(cron.id)) {
+        await this.board.cronSkipped(cron.id, iso(now));
+        this.log.info({ cron: cron.id, agent: cron.agent }, "cron time passed, its previous turn has not ended");
+        continue;
+      }
+      const agent = await this.tryReadAgent(cron.agent);
+      if (agent === null) {
+        continue;
+      }
+      if (await this.board.cronFired(cron.id, iso(now)) === null) {
+        continue;
+      }
+      this.enqueue(agent.name, cron.scope, {
+        kind: "cron",
+        from: cron.createdBy,
+        fromUser: cron.createdBy === USER_NAME,
+        reason: `cron "${cron.title}" came due`,
+        cronId: cron.id
+      }, now, await this.cronConversation(cron));
+    }
+  }
+  /** The conversation a cron fires in, beside its scope's home or none for the home. */
+  async cronConversation(cron) {
+    if (cron.thread !== void 0) {
+      return { thread: await this.conversationOf(cron.thread, cron.scope) };
+    }
+    return cron.channel === void 0 ? void 0 : { channel: cron.channel };
+  }
+  /** Whether a cron's wake waits in the queue or its turn is running. */
+  cronQueuedOrRunning(id) {
+    return this.cronsInFlight.has(id) || [...this.pending.values()].some((item) => item.dispatch.crons?.includes(id) === true);
+  }
+  /** Takes an ended cron out of the queued wakes, and drops a wake left with nothing else to run. */
+  dropCronWakes(id) {
+    for (const [key, item] of this.pending) {
+      const crons = item.dispatch.crons;
+      if (crons?.includes(id) !== true) {
+        continue;
+      }
+      const rest = crons.filter((each) => each !== id);
+      if (rest.length === 0 && item.onlyCrons === true) {
+        this.pending.delete(key);
+        this.log.info({ agent: item.dispatch.agent, cron: id }, "dropping cron wake, the cron ended");
+        continue;
+      }
+      const { crons: _crons, ...dispatch } = item.dispatch;
+      item.dispatch = rest.length === 0 ? dispatch : { ...dispatch, crons: rest };
+    }
+  }
   /**
    * Every `reflectionMs`, a member whose charter reflects takes a reflection turn in the scope of
    * its latest working turn, unless it has not worked since its last reflection.
@@ -8186,6 +8878,7 @@ var Scheduler = class {
         });
       }
     }
+    const crons = (await this.board.listCrons()).filter((cron) => cron.ended === void 0);
     for (const agent of await this.board.listAgents()) {
       if (agent.status !== "active" || agent.cli === null) {
         continue;
@@ -8210,6 +8903,20 @@ var Scheduler = class {
           role: agent.role
         });
       }
+      for (const cron of crons.filter((each) => each.agent === agent.name)) {
+        if (cron.failures >= CRON_FAILING_RUNS) {
+          signals.push({
+            kind: "cron_failing",
+            key: `cron_failing:${cron.id}`,
+            summary: `${agent.name}'s cron ${cron.id} "${cron.title}" has had ${cron.failures} failed turns in a row`,
+            value: cron.failures,
+            threshold: CRON_FAILING_RUNS,
+            agent: agent.name,
+            role: agent.role,
+            ...cron.scope === SOCIETY_SCOPE ? {} : { project: cron.scope }
+          });
+        }
+      }
       const left = (await this.board.listHomeConflicts(agent.name)).filter((conflict) => now - Date.parse(conflict.since) >= this.timings.homeConflictMs);
       if (left.length > 0) {
         const oldest = Math.max(...left.map((conflict) => now - Date.parse(conflict.since)));
@@ -8377,6 +9084,10 @@ var Scheduler = class {
         channel: dispatch.channel,
         trigger: dispatch.trigger.kind
       }, "dispatching turn");
+      const crons = dispatch.crons ?? [];
+      for (const id of crons) {
+        this.cronsInFlight.add(id);
+      }
       const promise = (async () => {
         try {
           const record = await this.runner.runTurn(dispatch, assignment);
@@ -8391,6 +9102,9 @@ var Scheduler = class {
         } finally {
           this.running.delete(key);
           this.exclusive.delete(key);
+          for (const id of crons) {
+            this.cronsInFlight.delete(id);
+          }
         }
       })();
       this.running.set(key, promise);
@@ -8419,6 +9133,40 @@ var Scheduler = class {
     }
     return others.some((other) => this.exclusive.get(other) === "reflection");
   }
+  /** Queues closing an abandoned task's pull request, when it is a `ghpr` task with one open. */
+  async queueClosing(taskId) {
+    if (this.runner.closePullRequest === void 0) {
+      return;
+    }
+    try {
+      const { task } = await this.board.findTask(taskId);
+      if (awaitsClosing(task)) {
+        this.closings.set(taskId, task.project);
+      }
+    } catch {
+    }
+  }
+  /** Starts closing each queued pull request; one whose runner is away waits in the queue. */
+  runClosings() {
+    const close = this.runner.closePullRequest?.bind(this.runner);
+    if (close === void 0) {
+      return;
+    }
+    for (const [taskId, project] of this.closings) {
+      this.closings.delete(taskId);
+      const promise = close(project, taskId).then((outcome) => {
+        if (outcome === "deferred" && !this.closings.has(taskId)) {
+          this.closings.set(taskId, project);
+        }
+        return void 0;
+      }).catch((error) => {
+        this.log.error({ project, taskId, error: String(error) }, "closing a pull request failed");
+      }).finally(() => {
+        this.completing.delete(promise);
+      });
+      this.completing.add(promise);
+    }
+  }
   /** Starts each queued completion once the turn that finished the task's last stage has ended. */
   runCompletions() {
     for (const [taskId, item] of this.completions) {
@@ -8455,6 +9203,7 @@ var TURN_CONTRACT = [
   "- Work only inside your worktree. In a task's conversation it is a worktree of its own on the task's branch `task/<id>`: commit your work there. After each turn the runner commits what you left on the branch and lets it go for the next holder. Your home worktree is on your own branch, `agent/<name>`, for work tied to no task; nothing lands from it by itself. In a proposal's, a topic's, or a channel's conversation it is a worktree of its own, detached at the project's default branch, which goes when the thread closes or the channel is archived, so work that should last goes on a task's branch. Before each turn the runner fetches the project's remote and brings what holds no work of yours up to the default branch: your own branch when it has no commits of its own, a task's branch nobody has worked on, and a detached worktree with nothing uncommitted; what it leaves where it is, and why, is under Your workspace in the prompt. It never merges or commits for you.",
   "- Posts that would wake this conversation may arrive while you work, delivered into the turn under a heading that says so and formatted like the digest. They are part of this turn: act on them now, after the step in hand, or not at all, as with the digest. The user may also stop a turn; the next turn is told.",
   "- Silence is allowed. If the digest needs no reply, post nothing.",
+  "- To come back to something later, set a cron with create_cron: a note on what to do then, and a five-field cron expression or one time with at. It wakes you in this conversation unless you name another, at most every fifteen minutes, and every fire is a paid turn, so end a cron with remove_cron once it has done its job. Never wait by holding a stage, sleeping, or leaving a process running: a turn's board token ends with the turn, so nothing it leaves behind can act on the board. The society's crons are under society/crons/ in the board projection.",
   "- An @mention wakes the citizen named, and every wake costs a turn. Address someone with @ only when you need them to act; when you merely refer to citizens, write their names plainly. @user wakes nobody, since the user takes no turns; it is what puts a question before the user, so use it only when you need the user to answer or decide.",
   "- A thread is a conversation off a channel that reaches only its participants and whoever is mentioned in it. Every task has one, opened with it under the task's id on the channel of its project it was filed in, general unless it was filed in another: talk about a task there, with post_message and its thread_id, and the notes you give advance_task and update_task are posted there as you. Its participants are the task's creator, its stage holders and assignees, whoever may take the stage that waits, and anyone who posted; it closes when the task ends. Every proposal has one too, in governance, opened with its pitch and closed by its decision. Open other threads with open_thread on a channel with a title, for any other topic; close_thread posts your summary to its channel.",
   "- Route every lesson: about you, your craft, or the user, write it to memory/core.md in your home directory, and keep that file short by moving detail to memory/<topic>.md, your archive; a durable fact about a project's codebase or process goes through `write_knowledge` on that project; something the whole project should know now, post it to the project channel, and anything about one task, in the task's thread.",
@@ -8617,6 +9366,17 @@ function messageLines(messages, threads) {
   }
   return lines;
 }
+function cronLines(cron, timeZone) {
+  const previous = cron.lastRun === void 0 ? "" : ` The turn of its previous fire ${cron.lastRun.outcome === "stopped" ? "was stopped by the user" : cron.lastRun.outcome} at ${cron.lastRun.at}.`;
+  const next = nextFire(cron, timeZone);
+  const state = isOneTime(cron.schedule) ? " It fired once, as set, and has ended." : cron.ended !== void 0 ? ` ${cron.ended.by} has ended it since it fired (${cron.ended.reason}), so do what it asks only if it still matters.` : next === null ? "" : ` Next it fires at ${next.toISOString()}.`;
+  return [
+    `- "${cron.title}" (cron ${cron.id}), set by ${cron.createdBy} at ${cron.createdAt}, fires ${describeSchedule(cron.schedule, timeZone)}.${previous}${state}`,
+    "",
+    clip(cron.note).split("\n").map((line) => `  ${line}`).join("\n"),
+    ""
+  ];
+}
 function buildSteerText(messages, threads) {
   return `${[
     `## New in this conversation while you work (${messages.length})`,
@@ -8637,6 +9397,10 @@ function buildTurnPrompt(input) {
   if (dispatch.trigger.taskId !== void 0) {
     lines.push(`Task in question: ${dispatch.trigger.taskId}`);
   }
+  if (input.clock !== void 0) {
+    const { now, timeZone } = input.clock;
+    lines.push(`It is ${now.toISOString()} now, ${localTime(now, timeZone)} in the society's time zone, ${timeZone}.`);
+  }
   const askedIn = dispatch.trigger.channel === void 0 ? null : parseChannelRef(dispatch.trigger.channel).project;
   if (dispatch.project === SOCIETY_SCOPE && askedIn !== null) {
     lines.push(`You were asked in ${dispatch.trigger.channel}, in project ${askedIn}, which you are not a member of, so this turn is outside any project. Answer there with post_message. If the work needs you in ${askedIn}, ask the concierge or @user to add you, or join it with join_project if your charter grants that verb.`);
@@ -8651,7 +9415,10 @@ function buildTurnPrompt(input) {
     lines.push("A task you created is done. Tell whoever asked for it, if anyone did.");
   }
   if (dispatch.trigger.kind === "proposal_decided") {
-    lines.push("A proposal you made was decided; the decision is the last post in its thread. Carry on with what an approval enables or a rejection asks, and stay silent if nothing follows.");
+    lines.push("A proposal you made was decided; the decision is the last post in the proposal's thread. A decision wakes you in the conversation you filed the proposal from, or at home once that has ended. Carry on with what an approval enables or a rejection asks, and stay silent if nothing follows.");
+  }
+  if (dispatch.trigger.kind === "cron") {
+    lines.push("A cron came due: what it asks is under Crons below.");
   }
   if (dispatch.trigger.kind === "user_post") {
     lines.push("The user posted. Route it: answer where it was posted, in its thread when it came in one, or create what it needs: a task with a plan whose stages name who does them, a thread, or a project, adding citizens to a project first when they are not members. Stay silent when the user already addressed a citizen and nothing else is needed.");
@@ -8679,6 +9446,11 @@ function buildTurnPrompt(input) {
   if (ending !== null) {
     lines.push("", "## This conversation has ended", "", `${capitalized(ending.how)}. You are woken once more because your workspace here still holds work on no branch, listed under Your workspace, and it is removed when this turn ends, whatever it still holds. You may not be the one who ended the conversation, and the work may not be yours to finish, so decide for each piece:`, "- It is yours and it matters: land it through a task. File one, or use one you hold, switch this worktree to its branch task/<id> (git switch -c task/<id> for a task filed in this turn), and commit there.", `- It matters but is someone else's to finish: put it on a task's branch the same way, then hand that task to whoever should own it and ask them in ${ending.askIn} with a mention, since this conversation takes no more posts.`, "- It is disposable: leave it, and it goes with the workspace.");
   }
+  const crons = input.crons ?? [];
+  if (crons.length > 0) {
+    const timeZone = input.clock?.timeZone ?? DEFAULT_TIME_ZONE;
+    lines.push("", "## Crons", "", "Each of these came due for this turn; its note says what to do. Change one with update_cron, or end it with remove_cron, by its id.", "", ...crons.flatMap((cron) => cronLines(cron, timeZone)));
+  }
   lines.push("", WORKSPACE_TOKEN);
   const conflicts = input.conflicts ?? [];
   if (dispatch.trigger.kind === "reflection") {
@@ -8737,7 +9509,7 @@ function buildTurnPrompt(input) {
   }
   if (project !== void 0 && project !== null && landing === "ghpr") {
     const base = project.defaultBranch;
-    lines.push("", `## Project ${project.slug}`, "", `A finished task lands by the board merging its pull request on GitHub into ${base}. Open the pull request yourself, from a branch named for what it does that holds the same files as task/<id>, as \`git push origin task/<id>:<branch>\` gives, and link it to the task with update_task pull_request before its last stage completes, with the merge commit's merge_subject and merge_body, which you may change by linking again until it lands. Never merge the pull request or ${base} yourself, nor push other work to ${base}: the board merges once the task's stages are done, and the runner refuses the pushes.`);
+    lines.push("", `## Project ${project.slug}`, "", `A finished task lands by the board merging its pull request on GitHub into ${base}. Open the pull request yourself, from a branch named for what it does that holds the same files as task/<id>, as \`git push origin task/<id>:<branch>\` gives, and link it to the task with update_task pull_request before its last stage completes, with the merge commit's merge_subject and merge_body, which you may change by linking again until it lands. Never merge the pull request or ${base} yourself, nor push other work to ${base}: the board merges once the task's stages are done, and the runner refuses the pushes. Abandoning the task closes its linked pull request and deletes its branch.`);
   }
   if (conflicts.length > 0) {
     lines.push("", "## Edits to reconcile in your home", "", "Two of your turns changed these files at once on different runners. The file in place kept the other turn's version; yours is the copy named here, beside it. Merge what still holds into the file, then delete the copy.", "", ...conflicts.map((conflict) => `- ${conflict.path}, beside ${conflict.file}, since ${conflict.since}`));
@@ -8861,7 +9633,8 @@ var TurnHost = class {
       usage: null,
       costUsd: 0,
       toolCalls: 0,
-      model: agent.model ?? null
+      model: agent.model ?? null,
+      ...dispatch.crons === void 0 ? {} : { crons: dispatch.crons }
     };
     if (agent.status === "retired") {
       return { failed: await this.fail(base, `${agent.name} is retired`) };
@@ -8948,8 +9721,18 @@ var TurnHost = class {
       ...threadRecord.state === "closed" ? { replyIn: await this.replyIn(threadRecord) } : {}
     };
     const ending = dispatch.trigger.kind === "closing" ? await this.endingOf(dispatch.project, threadRecord, task, channel) : null;
+    const society = await this.board.society();
+    const crons = [];
+    for (const id of dispatch.crons ?? []) {
+      const cron = await this.board.readCron(id).catch(() => null);
+      if (cron !== null) {
+        crons.push(cron);
+      }
+    }
     const prompt = buildTurnPrompt({
       dispatch,
+      clock: { now: this.now(), timeZone: society.timezone },
+      crons,
       messages,
       threads,
       conversation,
@@ -9308,7 +10091,8 @@ var TurnHost = class {
       usage: null,
       costUsd: 0,
       toolCalls: 0,
-      model: agent?.model ?? null
+      model: agent?.model ?? null,
+      ...dispatch.crons === void 0 ? {} : { crons: dispatch.crons }
     }, reason);
   }
   /**
@@ -9895,6 +10679,49 @@ var RunnerHub = class {
     });
     return "done";
   }
+  /**
+   * Closes the pull request of a `ghpr` task abandoned with one linked, on the runner its project
+   * lives on, whose `gh` login reaches GitHub, and records how it went on the task; `deferred`
+   * while that runner is away.
+   */
+  async closePullRequest(project, taskId) {
+    const { task } = await this.board.findTask(taskId);
+    const pull = task.pullRequest;
+    if (task.status !== "abandoned" || task.onDone !== "ghpr" || pull === void 0 || pull.closed !== void 0) {
+      return "done";
+    }
+    const record = await this.board.readProject(project);
+    let outcome = {
+      ok: false,
+      detail: `${project} lives on no runner yet, so none could close ${pull.url}`
+    };
+    if (record.runner !== void 0) {
+      const seat = this.seats.get(record.runner);
+      if (seat === void 0 || seat.send === null) {
+        return "deferred";
+      }
+      try {
+        outcome = MergeOutcomeSchema.parse(await this.request(seat, (request) => ({
+          type: "close",
+          request,
+          close: {
+            repo: projectRepo(record),
+            url: pull.url,
+            comment: `Closed by Stellaris: the task this pull request was opened for, "${task.title}", was abandoned.`
+          }
+        })));
+      } catch (error) {
+        this.log.warn({ project, taskId, error: String(error) }, "closing a pull request deferred");
+        return "deferred";
+      }
+    }
+    await this.board.recordPullRequestClosed(SYSTEM_ACTOR, {
+      taskId,
+      ok: outcome.ok,
+      detail: outcome.detail
+    });
+    return "done";
+  }
   /**
    * One path on a branch of a project's repository, read on the runner the project lives on.
    * NOT_FOUND when the project has no runner yet or the branch or the path does not exist, and
@@ -10171,20 +10998,20 @@ async function handleMcpRequest(board2, actor, request, version) {
 import { Hono as Hono3 } from "hono";
 import { compress } from "hono/compress";
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { z as z15, ZodError } from "zod";
+import { z as z16, ZodError } from "zod";
 
 // apps/server/dist/github-auth.js
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { Hono } from "hono";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var SIGN_IN_TTL_MS = 30 * 24 * 36e5;
 var STATE_TTL_MS = 10 * 6e4;
 var MAX_STATES = 1e3;
-var TokenAnswerSchema = z14.object({ access_token: z14.string().min(1) });
-var GithubUserSchema = z14.object({
-  login: z14.string().min(1),
-  id: z14.number().int(),
-  avatar_url: z14.string().optional()
+var TokenAnswerSchema = z15.object({ access_token: z15.string().min(1) });
+var GithubUserSchema = z15.object({
+  login: z15.string().min(1),
+  id: z15.number().int(),
+  avatar_url: z15.string().optional()
 });
 function githubAvatar(url) {
   try {
@@ -10658,17 +11485,18 @@ var ERROR_STATUS = {
   INVALID_TRANSITION: 409,
   INVALID_STATE: 409
 };
-var RetireBodySchema = z15.object({ reason: z15.string().min(1) });
-var RunnerBodySchema = z15.object({ name: NameSchema });
-var EnrollmentApprovalSchema = z15.object({ name: NameSchema });
-var HomeRunnerBodySchema = z15.object({ runner: NameSchema.nullable() });
-var ModelBodySchema = z15.object({ model: ModelNameSchema.nullable() });
-var EffortBodySchema = z15.object({ effort: EffortSchema.nullable() });
-var HistoryLimitSchema = z15.coerce.number().int().min(1).max(500);
-var ChannelBodySchema = z15.object({
+var RetireBodySchema = z16.object({ reason: z16.string().min(1) });
+var RunnerBodySchema = z16.object({ name: NameSchema });
+var EnrollmentApprovalSchema = z16.object({ name: NameSchema });
+var HomeRunnerBodySchema = z16.object({ runner: NameSchema.nullable() });
+var ModelBodySchema = z16.object({ model: ModelNameSchema.nullable() });
+var EffortBodySchema = z16.object({ effort: EffortSchema.nullable() });
+var HistoryLimitSchema = z16.coerce.number().int().min(1).max(500);
+var TimezoneBodySchema = z16.object({ timezone: TimeZoneSchema });
+var ChannelBodySchema = z16.object({
   project: NameSchema.nullable().default(null),
   name: NameSchema,
-  purpose: z15.string().min(1)
+  purpose: z16.string().min(1)
 });
 function bearer2(c) {
   const header = c.req.header("authorization") ?? "";
@@ -10717,6 +11545,10 @@ function createApp(deps) {
   });
   api.delete("/sign-in", async (c) => c.json({ signedOut: await board2.signOut(bearer2(c) ?? "") }));
   api.get("/society", async (c) => c.json(await board2.society()));
+  api.put("/society/timezone", async (c) => {
+    const body = TimezoneBodySchema.parse(await c.req.json());
+    return c.json(await board2.setTimezone(c.get("actor"), body.timezone));
+  });
   api.get("/version", (c) => c.json({ version }));
   api.get("/agents", async (c) => c.json((await board2.listAgents()).map(({ tokenHash: _hash, ...agent }) => agent)));
   api.get("/members", async (c) => c.json(await board2.listMembers()));
@@ -10768,6 +11600,7 @@ function createApp(deps) {
     });
   }
   api.get("/proposals", async (c) => c.json(await board2.listProposals()));
+  api.get("/crons", async (c) => c.json(await board2.listCrons()));
   api.get("/proposals/:id", async (c) => c.json(await board2.readProposal(c.req.param("id"))));
   api.get("/signals", async (c) => c.json(await board2.listSignals(Number(c.req.query("limit") ?? "100"))));
   api.get("/metrics", async (c) => {
@@ -10817,7 +11650,7 @@ function createApp(deps) {
   });
   api.put("/roles/:name", async (c) => {
     const charter = RoleCharterSchema.parse({
-      ...z15.record(z15.string(), z15.unknown()).parse(await c.req.json()),
+      ...z16.record(z16.string(), z16.unknown()).parse(await c.req.json()),
       name: c.req.param("name")
     });
     return c.json(await board2.setRoleCharter(c.get("actor"), charter));