@kubitnodes/stellaris 0.3.27 → 0.4.1

package/dist/server/index.js

@@ -3,7 +3,6 @@
 // apps/server/dist/index.js
 import { access as access2 } from "node:fs/promises";
 import path11 from "node:path";
-import { serve } from "@hono/node-server";
 
 // packages/board-core/dist/board.js
 import { chmod as chmod2, cp, mkdir as mkdir5, readdir as readdir4, readFile as readFile4, rename as rename3, rm as rm3, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
@@ -65,7 +64,8 @@ var VERB_NAMES = [
   "update_cron",
   "remove_cron",
   "remove_skill",
-  "upload_image"
+  "upload_image",
+  "read_image"
 ];
 var VerbNameSchema = z2.enum(VERB_NAMES);
 var CharterTriggerSchema = z2.enum(["user_post", "ops_event", "heartbeat"]);
@@ -95,6 +95,7 @@ var USER_NAME = "user";
 var MEMBER_VERBS = [
   "post_message",
   "upload_image",
+  "read_image",
   "read_inbox",
   "search",
   "open_thread",
@@ -226,7 +227,12 @@ var CronScheduleSchema = z3.union([
 var CronRunSchema = z3.object({
   turnId: UlidSchema,
   at: IsoDateTimeSchema,
-  outcome: z3.enum(["completed", "failed", "stopped"])
+  outcome: z3.enum(["completed", "failed", "stopped"]),
+  /**
+   * For a failed one, the first turn of the cron's citizen in its conversation that was shown the
+   * failure and completed, and when it ended.
+   */
+  caughtUp: z3.object({ turnId: UlidSchema, at: IsoDateTimeSchema }).optional()
 });
 var CronFrontmatterSchema = z3.object({
   id: UlidSchema,
@@ -273,6 +279,16 @@ function shortestGapMs(schedule, societyZone, after) {
   }
   return shortest;
 }
+function firesInTask(cron, task) {
+  return cron.scope === task.project && cron.thread === task.id;
+}
+function cronFailure(cron) {
+  return cron.lastRun?.outcome === "failed" && cron.lastRun.caughtUp === void 0 ? cron.lastRun : null;
+}
+function cronStoppedAt(cron) {
+  const times = [cron.paused?.at, cron.ended?.at, cronFailure(cron)?.at].filter((at) => at !== void 0);
+  return times.reduce((first, at) => first === null || Date.parse(at) < Date.parse(first) ? at : first, null);
+}
 function nextFire(cron, societyZone, floorMs = CRON_FLOOR_MS) {
   if (cron.ended !== void 0 || cron.paused !== void 0) {
     return null;
@@ -382,6 +398,21 @@ function quotaLevel(quota, now) {
   const high = quota.windows.some((window) => windowCurrent(window, now) && window.usedPercent !== null && window.usedPercent >= QUOTA_WARNING_PERCENT);
   return quota.status === "warning" || high ? "warning" : "ok";
 }
+var UNKNOWN_LIMIT_HOLD_MS = 30 * 6e4;
+function stopsTurns(quota) {
+  return quota.status === "limited" && !(quota.source === "read" && quota.extraUsage?.enabled === true);
+}
+function limitHold(quota, now) {
+  if (!stopsTurns(quota)) {
+    return null;
+  }
+  const known = quota.limitedUntil !== null;
+  const until = quota.limitedUntil ?? new Date(Date.parse(quota.observedAt) + UNKNOWN_LIMIT_HOLD_MS).toISOString();
+  return Date.parse(until) > now.getTime() ? { until, known } : null;
+}
+function limitLapsed(quota, now) {
+  return stopsTurns(quota) && quota.limitedUntil === null && limitHold(quota, now) === null;
+}
 var WINDOW_NAMES = {
   five_hour: "5h",
   seven_day: "7d",
@@ -704,6 +735,7 @@ var MemberSchema = z5.object({
 });
 var RunnerOsSchema = z5.enum(["linux", "windows", "darwin"]);
 var GitIdentityPartSchema = z5.enum(["name", "email"]);
+var RunnerPauseSchema = z5.object({ at: IsoDateTimeSchema, by: NameSchema });
 var RunnerSchema = z5.object({
   name: NameSchema,
   os: RunnerOsSchema,
@@ -722,8 +754,29 @@ var RunnerSchema = z5.object({
    * Each CLI's plan quota as its login on this runner last reported it, from a turn's stream or a
    * read; absent until one has.
    */
-  quotas: z5.partialRecord(CliKindSchema, CliQuotaSchema).optional()
+  quotas: z5.partialRecord(CliKindSchema, CliQuotaSchema).optional(),
+  /** The user's pause of the whole runner: no turn starts on it until the user resumes it. */
+  paused: RunnerPauseSchema.optional(),
+  /**
+   * The user's pauses of single CLIs on the runner, each apart from the runner's own: no turn of
+   * that CLI starts on it until the user resumes it.
+   */
+  pausedClis: z5.partialRecord(CliKindSchema, RunnerPauseSchema).optional()
 });
+function runnerPause(runner, cli) {
+  return runner.paused ?? runner.pausedClis?.[cli];
+}
+function runnerLimitHold(runner, cli, now) {
+  const quota = runner.quotas?.[cli];
+  return quota === void 0 ? null : limitHold(quota, now);
+}
+function heldOn(runners2, runner, cli, now) {
+  if (runner === void 0 || cli === null) {
+    return false;
+  }
+  const record = runners2.find((each) => each.name === runner);
+  return record !== void 0 && (runnerPause(record, cli) !== void 0 || runnerLimitHold(record, cli, now) !== null);
+}
 var ProposalKindSchema = z5.enum([
   "role",
   "member",
@@ -1073,7 +1126,21 @@ function imageTypeOf(bytes) {
   return null;
 }
 var ImagePathSchema = z6.string().min(1).max(4096).refine((value) => !value.includes("\0"), { message: "a path with no NUL character" });
+var ImageNameSchema = z6.string().max(1024);
+function imageDescription(name) {
+  return name.replaceAll(/[[\]\\\r\n`]/g, "");
+}
 var IMAGE_SCHEME = "image:";
+var ImageRefSchema = z6.string().regex(/^(?:image:)?[0-9A-HJKMNP-TV-Z]{26}$/, "expected an image's id or image:<id>");
+function imageIdOf(ref) {
+  return ref.startsWith(IMAGE_SCHEME) ? ref.slice(IMAGE_SCHEME.length) : ref;
+}
+var ImageFileSchema = z6.object({
+  id: UlidSchema,
+  type: ImageTypeSchema,
+  size: z6.number().int().positive(),
+  path: ImagePathSchema
+});
 var UploadedImageSchema = z6.object({
   id: UlidSchema,
   type: ImageTypeSchema,
@@ -1238,6 +1305,10 @@ var VerbInputs = {
   upload_image: z7.object({
     /** The image file on the machine your turn runs on: absolute, or relative to your working directory. */
     path: ImagePathSchema
+  }),
+  read_image: z7.object({
+    /** The image's id, or its `image:<id>` address as a post shows it. */
+    image_id: ImageRefSchema
   })
 };
 var VERB_DESCRIPTIONS = {
@@ -1249,7 +1320,7 @@ var VERB_DESCRIPTIONS = {
   create_task: "Create a task in a project with its plan: stages of {name, role or agent, gate}. Without stages it gets one stage, work, that anyone in the project may take. File it in a channel of the project, such as a release's, or general by default; its thread opens there with it, under the task's id, for everything said about the work.",
   claim_task: "Hold the task's current stage. Claims are leases renewed by every turn that touches the task.",
   release_task: "Let go of the stage you hold so someone else can take it.",
-  update_task: "Move a task back to an earlier stage (the current stage's holder, the user, the steward, or the concierge; anyone else asks the concierge in the task's thread), abandon it, set the tasks it is blocked by (blocked_by: its stage wakes nobody until they have all ended), or link its pull request (pull_request: url, with the merge commit's merge_subject and merge_body), which a ghpr task needs before its last stage completes. A note is posted to the task's thread.",
+  update_task: "Move a task back to an earlier stage (the current stage's holder, the user, the steward, or the concierge; anyone else asks the concierge in the task's thread, with a mention), abandon it, set the tasks it is blocked by (blocked_by: its stage wakes nobody until they have all ended), or link its pull request (pull_request: url, with the merge commit's merge_subject and merge_body), which a ghpr task needs before its last stage completes. A note is posted to the task's thread.",
   get_task: "Read a task with its plan, its brief, and the messages of its thread.",
   subscribe: "Subscribe to a channel. Subscriptions feed your digest; they never wake you.",
   unsubscribe: "Unsubscribe from a channel.",
@@ -1272,7 +1343,8 @@ var VERB_DESCRIPTIONS = {
   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.",
   remove_skill: "Remove a skill from the society's skills, with a reason, when it is wrong, superseded, or no longer used: no skills index lists it from the next turn, and a notice in general says so with the reason. Its proposer's own copy stays in its home. Steward and user only; the board keeps its text aside for the user to restore.",
-  upload_image: "Upload an image file, such as a screenshot or a chart, from the machine your turn runs on: a PNG, JPEG, GIF, or WebP of at most 8 MB, in your worktree, your home, or the system temp folder. Returns its id and the markdown that shows it in a post, `![what it shows](image:<id>)`; write what it shows as the alt text."
+  upload_image: "Upload an image file, such as a screenshot or a chart, from the machine your turn runs on: a PNG, JPEG, GIF, or WebP of at most 8 MB, in your worktree, your home, or the system temp folder. Returns its id and the markdown that shows it in a post, `![what it shows](image:<id>)`; write what it shows as the alt text.",
+  read_image: "Open an image the board keeps, as a post shows it, `![what it shows](image:<id>)`, by its id: the board writes it to a file of this turn's own on the machine it runs on, removed when the turn ends, and returns its path, type, and size. Open the path with your file tools to see the image."
 };
 
 // packages/shared/dist/events.js
@@ -1323,6 +1395,8 @@ var BOARD_EVENT_TYPES = [
   "user.token_rotated",
   "runner.changed",
   "runner.quota",
+  "runner.paused",
+  "runner.resumed",
   "ops.signal",
   "paused.changed",
   "wake.requested",
@@ -1472,6 +1546,11 @@ var RunnerHelloSchema = z9.object({
   quotaReads: z9.boolean().default(false),
   /** Whether the runner reads an image a turn running there uploads; one from before never does. */
   imageReads: z9.boolean().default(false),
+  /**
+   * Whether the runner writes an image the board sends for a turn running there to open, for
+   * `read_image`; one from before never does.
+   */
+  imageWrites: z9.boolean().default(false),
   /**
    * Whether the runner carries a project's repository out to another runner and in from one, and
    * removes its copy once the project has moved; one from before never does.
@@ -1593,6 +1672,12 @@ var TurnJobSchema = z9.object({
   usageSoFar: UsageSchema.optional(),
   /** The rendered charter, norms, memory core, and skills index, with `PATH_TOKENS` for places. */
   instructions: z9.string(),
+  /**
+   * The hash of `instructions` without the first turn's section (`instructionsHash` in
+   * `turn-host`): a warm process started on other instructions starts afresh, so a compaction in
+   * it puts back the current ones. Absent from a server from before, when the text is compared.
+   */
+  instructionsHash: z9.string().optional(),
   prompt: z9.string(),
   mcp: z9.object({ url: z9.string().min(1), token: z9.string().min(1) }),
   limits: z9.object({
@@ -1777,6 +1862,13 @@ var TurnImageSchema = z9.discriminatedUnion("kind", [
   }),
   z9.object({ kind: z9.literal("refused"), why: ImageRefusalSchema, detail: z9.string() })
 ]);
+var TurnImageWriteSchema = z9.object({
+  turnId: UlidSchema,
+  id: UlidSchema,
+  type: ImageTypeSchema,
+  content: z9.string()
+});
+var TurnImageFileSchema = z9.object({ path: ImagePathSchema });
 var WorkspaceConversationSchema = z9.discriminatedUnion("kind", [
   z9.object({ kind: z9.literal("thread"), id: UlidSchema }),
   z9.object({ kind: z9.literal("channel"), scope: NameSchema, name: NameSchema }),
@@ -1799,6 +1891,10 @@ var HeldWorkspaceSchema = z9.object({
 var HeldWorkspacesSchema = z9.object({ workspaces: z9.array(HeldWorkspaceSchema) });
 var SweepResultSchema = z9.object({ kept: z9.array(HeldWorkspaceSchema) });
 var MOVE_PACK_LIMIT_BYTES = 256 * 1024 * 1024;
+var MOVE_FLOOR_BYTES_PER_SECOND = 16 * 1024;
+function moveTransferMs(bytes) {
+  return 10 * 6e4 + Math.ceil(bytes / MOVE_FLOOR_BYTES_PER_SECOND) * 1e3;
+}
 var RepoRefsSchema = z9.record(z9.string().regex(/^refs\/(heads|tags)\/\S+$/), z9.string().regex(/^[0-9a-f]{40}([0-9a-f]{24})?$/));
 var ProjectExportSchema = z9.object({ move: UlidSchema, repo: ProjectRepoSchema });
 var HeldWorkSchema = z9.object({
@@ -1822,7 +1918,9 @@ var ProjectExportedSchema = z9.discriminatedUnion("ok", [
 var ProjectImportSchema = z9.object({
   move: UlidSchema,
   repo: ProjectRepoSchema,
-  pullRequests: z9.boolean()
+  pullRequests: z9.boolean(),
+  /** The packs' size the old runner measured, which the clone's clock is sized from; the cap if unsaid. */
+  bytes: z9.number().int().nonnegative().optional()
 });
 var ProjectImportedSchema = z9.object({ refs: RepoRefsSchema });
 var ProjectReleaseSchema = z9.object({ slug: NameSchema });
@@ -1862,6 +1960,15 @@ var RunnerMessageSchema = z9.discriminatedUnion("type", [
    * whose hello says `imageReads`.
    */
   z9.object({ type: z9.literal("image"), request: z9.string().min(1), read: TurnImageReadSchema }),
+  /**
+   * Answered with a `TurnImageFile`, or null when the turn is not running there. Sent only to
+   * runners whose hello says `imageWrites`.
+   */
+  z9.object({
+    type: z9.literal("image_write"),
+    request: z9.string().min(1),
+    write: TurnImageWriteSchema
+  }),
   /** Answered with whether the CLI accepted it; that it took it comes as a `steered` event. */
   z9.object({
     type: z9.literal("steer"),
@@ -1927,6 +2034,7 @@ var TriggerKindSchema = z10.enum([
   "closing",
   "cron"
 ]);
+var HeartbeatCauseSchema = z10.enum(["unread", "held", "waiting"]);
 var TriggerSchema = z10.object({
   kind: TriggerKindSchema,
   from: NameSchema.optional(),
@@ -1937,7 +2045,9 @@ var TriggerSchema = z10.object({
   /** The channel the waking message was posted in. */
   channel: ChannelRefSchema.optional(),
   /** The cron that came due, for a `cron` wake. */
-  cronId: UlidSchema.optional()
+  cronId: UlidSchema.optional(),
+  /** What a `heartbeat` woke for; absent on records from before the board kept it. */
+  heartbeat: HeartbeatCauseSchema.optional()
 });
 var TurnThreadSchema = z10.object({ id: UlidSchema, task: z10.boolean() });
 var TurnDispatchSchema = z10.object({
@@ -2019,6 +2129,12 @@ var TurnRecordSchema = z10.object({
    * one. A resumed session's next turn measures its own usage from here.
    */
   sessionUsage: UsageSchema.optional(),
+  /**
+   * The SHA-256 of the instructions the session holds after this turn, the first turn's section
+   * left out (`instructionsHash` in `turn-host`): those it began with, or the latest a prompt
+   * carried. Absent when the board does not know them, as for records from before it kept them.
+   */
+  sessionInstructionsHash: z10.string().optional(),
   /**
    * The whole input of the turn's latest model call in the session's own thread, as the runner
    * reported it: how large the session had grown. Absent for a turn that made no call.
@@ -2043,7 +2159,13 @@ var TurnRecordSchema = z10.object({
    */
   sessionDropped: z10.boolean().optional(),
   /** The crons whose fire started the turn, which record how it ended. */
-  crons: z10.array(UlidSchema).optional()
+  crons: z10.array(UlidSchema).optional(),
+  /**
+   * The failed fires its prompt named: each of its citizen's crons in its conversation whose latest
+   * fire's turn failed with nothing catching it up (`cronFailure`), but those it carries, with that
+   * turn. Completing it catches each up.
+   */
+  cronFailures: z10.array(z10.object({ cron: UlidSchema, turnId: UlidSchema })).optional()
 });
 var RunningTurnSchema = z10.object({
   turnId: UlidSchema,
@@ -2085,6 +2207,8 @@ var TurnHistoryEntrySchema = z10.object({
   /** The project whose channels' conversation the turn was in, for a turn in the society scope. */
   place: NameSchema.optional(),
   trigger: z10.string(),
+  /** What a `heartbeat` woke for; absent on turns logged before the board kept it. */
+  heartbeat: HeartbeatCauseSchema.optional(),
   exitReason: z10.string().nullable(),
   costUsd: z10.number(),
   /** The tokens the turn used; absent for turns logged before turns recorded them. */
@@ -2158,7 +2282,7 @@ var METRICS_WINDOW_MS = {
   "7d": 7 * 24 * 36e5,
   all: null
 };
-var READ_VERBS = ["read_inbox", "search", "get_task"];
+var READ_VERBS = ["read_inbox", "search", "get_task", "read_image"];
 function isBoardAction(tool) {
   const verb = /^mcp__board__(.+)$/.exec(tool)?.[1];
   return verb !== void 0 && !READ_VERBS.some((read2) => read2 === verb);
@@ -2172,12 +2296,19 @@ var MetricsSchema = z12.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.
+   * Heartbeats are split by what each woke for, and those recorded before the board kept it are a
+   * row without one.
    */
   idle: z12.object({
     turns: CountSchema,
     idle: CountSchema,
     unknown: CountSchema,
-    byTrigger: z12.array(z12.object({ trigger: z12.string(), turns: CountSchema, idle: CountSchema })),
+    byTrigger: z12.array(z12.object({
+      trigger: z12.string(),
+      heartbeat: HeartbeatCauseSchema.optional(),
+      turns: CountSchema,
+      idle: CountSchema
+    })),
     byAgent: z12.array(z12.object({
       agent: NameSchema,
       role: NameSchema.nullable(),
@@ -2355,7 +2486,7 @@ var RunnerConfigSchema = z13.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.27";
+var STELLARIS_VERSION = "0.4.1";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -3119,7 +3250,8 @@ var TurnPayload = z14.object({
   thread: z14.string().optional(),
   channel: z14.string().optional(),
   place: z14.string().optional(),
-  trigger: z14.string()
+  trigger: z14.string(),
+  heartbeat: HeartbeatCauseSchema.optional().catch(void 0)
 });
 var TaskPayload = z14.object({
   taskId: z14.string(),
@@ -3219,13 +3351,12 @@ function computeMetrics(input) {
         const nothing = actions === 0 ? 1 : 0;
         turns2 += 1;
         idle += nothing;
-        for (const [rows, key] of [
-          [turnRows, turn.data.trigger],
-          [agentRows, event.actor]
-        ]) {
-          const row = rows.get(key) ?? { turns: 0, idle: 0 };
-          rows.set(key, { turns: row.turns + 1, idle: row.idle + nothing });
-        }
+        const { trigger, heartbeat } = turn.data;
+        const key = heartbeat === void 0 ? trigger : `${trigger}\0${heartbeat}`;
+        const row = turnRows.get(key) ?? { trigger, heartbeat, turns: 0, idle: 0 };
+        turnRows.set(key, { ...row, turns: row.turns + 1, idle: row.idle + nothing });
+        const own = agentRows.get(event.actor) ?? { turns: 0, idle: 0 };
+        agentRows.set(event.actor, { turns: own.turns + 1, idle: own.idle + nothing });
         break;
       }
       case "turn.started": {
@@ -3381,7 +3512,10 @@ function computeMetrics(input) {
       turns: turns2,
       idle,
       unknown,
-      byTrigger: [...turnRows].map(([trigger, row]) => ({ trigger, ...row })).toSorted((a, b) => b.idle - a.idle || b.turns - a.turns),
+      byTrigger: [...turnRows.values()].map(({ heartbeat, ...row }) => ({
+        ...row,
+        ...heartbeat === void 0 ? {} : { heartbeat }
+      })).toSorted((a, b) => b.idle - a.idle || b.turns - a.turns),
       byAgent: [...agentRows].map(([agent, row]) => ({ agent, role: citizens.get(agent)?.role ?? null, ...row })).toSorted((a, b) => b.idle - a.idle || b.turns - a.turns)
     },
     sentBack: {
@@ -3441,6 +3575,8 @@ var TurnHistoryPayloadSchema = z15.object({
   channel: NameSchema.optional(),
   place: NameSchema.optional(),
   trigger: z15.string().default("manual"),
+  // One a later board added reads as none, so the turn stays in the history.
+  heartbeat: HeartbeatCauseSchema.optional().catch(void 0),
   exitReason: z15.string().nullable().default(null),
   costUsd: z15.number().default(0),
   usage: UsageSchema.optional(),
@@ -3866,7 +4002,10 @@ var SignInsSchema = z16.object({
     expiresAt: IsoDateTimeSchema
   })).default([])
 });
-var TurnStartPayloadSchema = z16.object({ turnId: UlidSchema });
+var TurnStartPayloadSchema = z16.object({
+  turnId: UlidSchema,
+  heartbeat: TurnHistoryPayloadSchema.shape.heartbeat
+});
 var CursorsSchema = z16.object({
   digest: z16.string().nullable(),
   scopes: z16.record(z16.string(), z16.string()).default({}),
@@ -3938,6 +4077,9 @@ function skillFolderOf(proposal) {
 function proposedFrom(origin, where) {
   return origin !== void 0 && origin.scope === where.scope && origin.thread === where.thread && origin.channel === where.channel && origin.place === where.place;
 }
+function latestLease(a, b) {
+  return a === null ? b : b === null || a >= b ? a : b;
+}
 function megabytes(bytes) {
   return (bytes / (1024 * 1024)).toFixed(1).replace(/\.0$/, "");
 }
@@ -3963,8 +4105,10 @@ function plain(value) {
     return "";
   return JSON.stringify(value);
 }
-function sentence(summary) {
-  return summary.trim().replace(/\.+$/, "");
+var SENTENCE_END = /[.…?!]["'”’»)\]}*_]*$/u;
+function asSentence(text) {
+  const trimmed = text.trim();
+  return SENTENCE_END.test(trimmed) ? trimmed : `${trimmed}.`;
 }
 function skillSummary(data, body) {
   const description = data["description"];
@@ -4077,6 +4221,7 @@ var Board = class _Board {
   /** The turns in flight, which the server hosting them supplies; none until it does. */
   turnsInFlight = () => [];
   imageSource = null;
+  imageSink = null;
   newId = monotonicFactory();
   events;
   actionCounts = /* @__PURE__ */ new Map();
@@ -4127,10 +4272,13 @@ var Board = class _Board {
   /**
    * Applies each one-time alignment an existing society has not had yet, and remembers it, so a
    * member that later chooses otherwise keeps its choice. A new alignment is a name and a method in
-   * this list; once every board has applied it, both are deleted. None is pending.
+   * this list; once every board has applied it, both are deleted.
    */
   async applyAlignments() {
-    const alignments = [];
+    const alignments = [
+      // Whoever may show an image in a post may open one a post shows.
+      { name: "image-reads-granted", apply: () => this.grantBeside("upload_image", "read_image") }
+    ];
     const file = path8.join(this.paths.state(), "alignments.json");
     const { applied } = await exists(file) ? await readJson(file, AlignmentsSchema) : { applied: [] };
     const pending = alignments.filter(({ name }) => !applied.includes(name));
@@ -4142,6 +4290,17 @@ var Board = class _Board {
     }
     await writeJson(file, { applied: [...applied, ...pending.map(({ name }) => name)] });
   }
+  /**
+   * Grants `verb` once to every charter granting `beside`, the work roles' charters in practice;
+   * seed roles have it from their seed.
+   */
+  async grantBeside(beside, verb) {
+    for (const charter of await this.listRoles()) {
+      if (charter.verbs.includes(beside) && !charter.verbs.includes(verb)) {
+        await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, verb] }, { verbsAdded: [verb] });
+      }
+    }
+  }
   /** Writes every missing seed charter and aligns the existing ones with their seed. */
   async ensureSeedRoles() {
     await ensureDir(this.paths.roles());
@@ -4909,6 +5068,46 @@ ${DASHBOARD_LINE}
       return next;
     });
   }
+  /**
+   * Pauses or resumes a runner, the user's alone: the whole runner, or with `cli` that CLI on it
+   * alone, each apart from the other. While either holds, no turn it covers starts there; their
+   * wakes wait in the scheduler's queue, and a turn under way finishes. Pausing what is paused, or
+   * resuming what is not, changes nothing and logs nothing.
+   */
+  async setRunnerPaused(actor, name, change) {
+    this.assertUser(actor, "only the user may pause or resume a runner");
+    const cli = change.cli === void 0 ? void 0 : CliKindSchema.parse(change.cli);
+    return this.mutex.run(async () => {
+      const file = this.paths.runner(name);
+      if (!await exists(file)) {
+        throw new BoardError("NOT_FOUND", `runner ${name} not found`);
+      }
+      const doc = await readMarkdown(file, RunnerSchema);
+      const { paused, pausedClis, ...rest } = doc.data;
+      if (cli !== void 0 && change.paused && !doc.data.clis.includes(cli)) {
+        throw new BoardError("INVALID_STATE", `runner ${name} has no ${cli} to pause`);
+      }
+      const current = cli === void 0 ? paused : pausedClis?.[cli];
+      if (current !== void 0 === change.paused) {
+        return doc.data;
+      }
+      const pause = change.paused ? { at: this.now().toISOString(), by: actor.name } : void 0;
+      const clis = cli === void 0 ? { ...pausedClis } : { ...pausedClis, [cli]: pause };
+      const kept = Object.entries(clis).filter(([, each]) => each !== void 0);
+      const whole = cli === void 0 ? pause : paused;
+      const next = RunnerSchema.parse({
+        ...rest,
+        ...whole === void 0 ? {} : { paused: whole },
+        ...kept.length === 0 ? {} : { pausedClis: Object.fromEntries(kept) }
+      });
+      await writeMarkdown(file, next, doc.body);
+      await this.events.append(change.paused ? "runner.paused" : "runner.resumed", actor.name, {
+        name,
+        ...cli === void 0 ? {} : { cli }
+      });
+      return next;
+    });
+  }
   /**
    * Logs an operations signal as an `ops.signal` event. No channel carries it: the scheduler wakes
    * its readers from the event, the runner lists it in their prompts, and the interface's log shows
@@ -4943,8 +5142,9 @@ ${DASHBOARD_LINE}
       }
       if (event.type === "turn.started") {
         const start = TurnStartPayloadSchema.safeParse(event.payload);
-        if (start.success)
-          starts.set(start.data.turnId, event.ts);
+        if (start.success) {
+          starts.set(start.data.turnId, { ts: event.ts, heartbeat: start.data.heartbeat });
+        }
         continue;
       }
       if (event.type !== "turn.completed" && event.type !== "turn.failed") {
@@ -4952,17 +5152,19 @@ ${DASHBOARD_LINE}
       }
       const parsed = TurnHistoryPayloadSchema.safeParse(event.payload);
       if (parsed.success) {
-        const { turnId } = parsed.data;
-        const startedAt = turnId === void 0 ? void 0 : starts.get(turnId);
-        if (turnId !== void 0) {
-          starts.delete(turnId);
+        const { heartbeat: ended, ...turn } = parsed.data;
+        const start = turn.turnId === void 0 ? void 0 : starts.get(turn.turnId);
+        if (turn.turnId !== void 0) {
+          starts.delete(turn.turnId);
         }
+        const heartbeat = ended ?? start?.heartbeat;
         entries.push({
           id: event.id,
           ts: event.ts,
           outcome: event.type === "turn.failed" ? "failed" : "completed",
-          ...parsed.data,
-          ...startedAt === void 0 ? {} : { startedAt }
+          ...turn,
+          ...heartbeat === void 0 ? {} : { heartbeat },
+          ...start === void 0 ? {} : { startedAt: start.ts }
         });
       }
     }
@@ -4992,14 +5194,31 @@ ${DASHBOARD_LINE}
       return society;
     });
   }
-  /** Releases every claim whose lease has expired. Called by the scheduler on its tick. */
+  /**
+   * Releases every claim whose lease has expired, but for a holder's that its own cron in the
+   * task's thread keeps (`keptLease`). Called by the scheduler on its tick.
+   */
   async expireLeases() {
     return this.mutex.run(async () => {
       const expired = [];
       const now = this.now();
+      let crons;
+      let runners2;
       for (const project of await listDirs(this.paths.projects())) {
+        let place;
         for (const task of await this.listTasks(project)) {
-          if (task.status === "claimed" && this.leaseExpired(task, now)) {
+          if (task.status !== "claimed") {
+            continue;
+          }
+          crons ??= await this.listCrons();
+          runners2 ??= await this.listRunners();
+          place ??= await this.readProject(project);
+          const kept = latestLease(this.keptLease(task, crons, now), await this.pausedLease(task, runners2, place.runner, now));
+          if (kept !== null) {
+            await this.writeTask(project, { ...task, leaseExpiresAt: kept });
+            continue;
+          }
+          if (this.leaseExpired(task, now)) {
             const released = await this.writeTask(project, {
               ...task,
               status: "open",
@@ -5068,20 +5287,24 @@ ${DASHBOARD_LINE}
    * general channel, one of its other channels, one of its threads, or, in the society scope, a
    * project's channels. The heartbeat asks, so that it wakes a member where its unread
    * messages are and nowhere else. Society channels count only for a member woken in the society
-   * scope; a project member reads them at its next turn. Two kinds of post are in the digest but not
+   * scope; a project member reads them at its next turn. Some posts are in the digest but not
    * counted, and are read when the member wakes for something else: a task step's, which wakes
-   * whoever it hands work to, and the board's own, operations signals and landing announcements,
-   * whose signals that call for action wake their readers directly. A closed thread counts for
-   * nothing: its conversation has ended, and a turn there could only read its posts and be refused
-   * a reply, while a wake queued before it closed, as for a mention, still runs there.
+   * whoever it hands work to; the board's own, operations signals and landing announcements, whose
+   * signals that call for action wake their readers directly; and a knowledge topic's notice, which
+   * asks nothing of anyone. In a task's thread a post counts only for whoever the current stage is
+   * for, its holder or, while nobody holds it, a member who may take it, and for the task's creator
+   * when it mentions the user, so the creator can put a wait on the user in; a post that asks the
+   * reader counts wherever it is. A closed thread counts for nothing: its conversation has ended,
+   * and a turn there could only read its posts and be refused a reply, while a wake queued before
+   * it closed, as for a mention, still runs there.
    */
   async unreadByConversation(actor) {
     const { cursors, upto } = await this.digestSnapshot(actor.name);
     const counts = /* @__PURE__ */ new Map();
-    const closed = /* @__PURE__ */ new Map();
+    const threadCounts = /* @__PURE__ */ new Map();
     const unscoped = { name: actor.name, role: actor.role };
-    for (const { scope, part, message, news } of await this.digestSince(unscoped, cursors, upto)) {
-      if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name) {
+    for (const { scope, part, message, news, asked } of await this.digestSince(unscoped, cursors, upto)) {
+      if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name || message.notice?.kind === "knowledge") {
         continue;
       }
       const posted = parseChannelRef(message.channel).project ?? SOCIETY_SCOPE;
@@ -5090,12 +5313,13 @@ ${DASHBOARD_LINE}
       }
       const thread = threadOfPart(part);
       if (thread !== void 0) {
-        let ended = closed.get(thread);
-        if (ended === void 0) {
-          ended = (await this.tryFindThread(thread))?.thread.state === "closed";
-          closed.set(thread, ended);
+        let counted = threadCounts.get(thread);
+        if (counted === void 0) {
+          counted = await this.threadCount(actor, thread);
+          threadCounts.set(thread, counted);
         }
-        if (ended) {
+        const forReader = counted === "every" || counted !== "none" && asked === true || counted === "asks-user" && message.mentions.includes(USER_NAME);
+        if (!forReader) {
           continue;
         }
       }
@@ -5248,7 +5472,7 @@ ${DASHBOARD_LINE}
         include = participates;
       }
       if (include && message.author !== actor.name) {
-        collected.push({ scope: filedIn, part, message });
+        collected.push({ scope: filedIn, part, message, ...asked ? { asked: true } : {} });
       }
     }
     return collected.toSorted(byId);
@@ -5468,7 +5692,7 @@ ${current.body}`);
         name: args.name,
         reason: args.reason
       });
-      await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${args.name} removed from the society by ${actor.name}: ${sentence(withoutMentions(args.reason))}. Every citizen's skills index stops listing it from its next turn.`);
+      await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${args.name} removed from the society by ${actor.name}: ${asSentence(withoutMentions(args.reason))} Every citizen's skills index stops listing it from its next turn.`);
       return removed;
     });
   }
@@ -5525,12 +5749,30 @@ ${current.body}`);
       throw new BoardError("NOT_FOUND", "this board has no runners to read an image from");
     }
     const bytes = await this.imageSource(actor, args.path);
+    return this.keepImage(actor, bytes, args.path, path8.basename(args.path));
+  }
+  /**
+   * Keeps an image the user posts from a composer, as its bytes, under the same checks as an image
+   * a turn uploads. `name`, the file's, describes it in the markdown answered; without one the
+   * description is empty, for the user to write.
+   */
+  async postImage(actor, bytes, name) {
+    this.assertUser(actor, "only the user posts an image's bytes; a turn uploads one with upload_image");
+    const given = name === void 0 ? "" : ImageNameSchema.parse(name);
+    return this.keepImage(actor, bytes, given === "" ? "the image" : given, given);
+  }
+  /**
+   * Keeps `bytes` under a new id when they are a PNG, JPEG, GIF, or WebP of at most
+   * `IMAGE_LIMIT_BYTES`, and answers the markdown that shows them, described by `name`. `what`
+   * names the image in a refusal.
+   */
+  async keepImage(actor, bytes, what, name) {
     const type = imageTypeOf(bytes);
     if (type === null) {
-      throw new BoardError("VALIDATION", `${args.path} is not a PNG, JPEG, GIF, or WebP image by its first bytes`);
+      throw new BoardError("VALIDATION", `${what} is not a PNG, JPEG, GIF, or WebP image by its first bytes`);
     }
     if (bytes.byteLength > IMAGE_LIMIT_BYTES) {
-      throw new BoardError("VALIDATION", `${args.path} is ${bytes.byteLength} bytes, over the ${IMAGE_LIMIT_BYTES} an image may be`);
+      throw new BoardError("VALIDATION", `${what} is ${bytes.byteLength} bytes, over the ${IMAGE_LIMIT_BYTES} an image may be`);
     }
     return this.mutex.run(async () => {
       const id = this.newId();
@@ -5540,15 +5782,37 @@ ${current.body}`);
         type,
         size: bytes.byteLength
       });
-      const name = path8.basename(args.path).replaceAll(/[[\]\\\r\n]/g, "");
+      const description = imageDescription(name);
       return {
         id,
         type,
         size: bytes.byteLength,
-        markdown: `![${name}](${IMAGE_SCHEME}${id})`
+        markdown: `![${description}](${IMAGE_SCHEME}${id})`
       };
     });
   }
+  /**
+   * Opens an image the board keeps for the calling turn, by its id or its `image:<id>` address:
+   * the runner the turn runs on writes the bytes to a file in a folder of the turn's own in the
+   * system temp folder, removed when the turn ends, and the board answers its path, for the
+   * citizen to open with its own file tools, since a post reaches a turn as markdown and an image
+   * in it as its address. Any image the board keeps may be opened: every post, brief, topic, and
+   * dashboard that could show one is in the projection every turn reads.
+   */
+  async openImage(actor, input) {
+    const args = VerbInputs.read_image.parse(input);
+    await this.authorize(actor, "read_image");
+    if (actor.scope === void 0) {
+      throw new BoardError("INVALID_STATE", "read_image writes the image on the machine a turn runs on, so only a turn can call it");
+    }
+    if (this.imageSink === null) {
+      throw new BoardError("NOT_FOUND", "this board has no runners to write an image to");
+    }
+    const id = imageIdOf(args.image_id);
+    const { type, bytes } = await this.readImage(id);
+    const file = await this.imageSink(actor, { id, type, bytes });
+    return { id, type, size: bytes.byteLength, path: file };
+  }
   /** An uploaded image's bytes and kind, which its first bytes tell. */
   async readImage(id) {
     const file = this.paths.image(UlidSchema.parse(id));
@@ -5894,6 +6158,13 @@ ${current.body}`);
   readImagesWith(source) {
     this.imageSource = source;
   }
+  /**
+   * Where `read_image` writes an image to: the runner the calling turn runs on, through the server
+   * that hosts the runners. Without one, as in the admin CLI, nothing can be opened.
+   */
+  openImagesWith(sink) {
+    this.imageSink = sink;
+  }
   /**
    * Refuses to end conversations while another citizen's turn is in one of them: `cut` picks the
    * turns that would lose theirs. The caller's own turn is exempt, since ending a conversation
@@ -6491,7 +6762,7 @@ ${args.summary}`);
       });
       const thread = await this.openThreadUnlocked(actor.name, this.proposalThreadOpening(proposal));
       const rationale = args.rationale.trim();
-      await this.appendThreadMessage(actor.name, thread.id, `Proposal ${proposal.id}: ${describeCharter(proposal.kind, proposal.charter)}.${rationale.length === 0 ? "" : `
+      await this.appendThreadMessage(actor.name, thread.id, `Proposal ${proposal.id}: ${asSentence(describeCharter(proposal.kind, proposal.charter))}${rationale.length === 0 ? "" : `
 
 ${rationale}`}`);
       return proposal;
@@ -6729,6 +7000,8 @@ ${rationale}`}`);
         return this.removeCron(actor, VerbInputs.remove_cron.parse(input));
       case "upload_image":
         return this.uploadImage(actor, VerbInputs.upload_image.parse(input));
+      case "read_image":
+        return this.openImage(actor, VerbInputs.read_image.parse(input));
       default:
         throw new BoardError("VALIDATION", `unknown verb ${String(verb)}`);
     }
@@ -6964,6 +7237,7 @@ ${rationale}`}`);
         ...parsed.channel === void 0 ? {} : { channel: parsed.channel },
         ...parsed.place === void 0 ? {} : { place: parsed.place },
         trigger: parsed.trigger.kind,
+        ...parsed.trigger.heartbeat === void 0 ? {} : { heartbeat: parsed.trigger.heartbeat },
         session: parsed.session,
         runner: parsed.runner
       });
@@ -6986,6 +7260,11 @@ ${rationale}`}`);
       for (const id of parsed.crons ?? []) {
         await this.recordCronRun(id, parsed, failed);
       }
+      if (parsed.exitReason === "completed" || parsed.exitReason === "blocked") {
+        for (const shown of parsed.cronFailures ?? []) {
+          await this.catchUpCron(shown, parsed);
+        }
+      }
       if (parsed.exitReason === "stopped") {
         await this.events.append("turn.stopped", parsed.stoppedBy ?? USER_NAME, {
           ...parsed.id === void 0 ? {} : { turnId: parsed.id },
@@ -7003,6 +7282,7 @@ ${rationale}`}`);
         ...parsed.channel === void 0 ? {} : { channel: parsed.channel },
         ...parsed.place === void 0 ? {} : { place: parsed.place },
         trigger: parsed.trigger.kind,
+        ...parsed.trigger.heartbeat === void 0 ? {} : { heartbeat: parsed.trigger.heartbeat },
         session: parsed.session,
         exitReason: parsed.exitReason,
         costUsd: parsed.costUsd,
@@ -7126,6 +7406,27 @@ ${rationale}`}`);
       failures: outcome === "failed" ? cron.failures + 1 : outcome === "completed" ? 0 : cron.failures
     });
   }
+  /**
+   * Marks a cron's failed fire caught up by a completed turn whose prompt named it, while that
+   * failure is still its latest run. Its schedule and its run of failures stay as they are.
+   */
+  async catchUpCron(shown, record) {
+    if (record.id === void 0 || !await exists(this.paths.cron(shown.cron))) {
+      return;
+    }
+    const cron = await this.readCron(shown.cron);
+    const failure = cronFailure(cron);
+    if (failure === null || failure.turnId !== shown.turnId) {
+      return;
+    }
+    await this.writeCron({
+      ...cron,
+      lastRun: {
+        ...failure,
+        caughtUp: { turnId: record.id, at: record.endedAt ?? this.now().toISOString() }
+      }
+    });
+  }
   /**
    * Whether a conversation with a workspace of its own has ended: a thread closed, a task ended
    * (for one from before tasks had threads), a channel archived, or a project archived, which ends
@@ -7165,7 +7466,7 @@ ${rationale}`}`);
       const ts = this.now().toISOString();
       const landed = current.onDone !== "none";
       if (landed) {
-        await this.postTaskNote(actor.name, current, input.ok ? `${sentence(input.detail)}.` : `Landing failed: ${sentence(input.detail)}. The task waits at its last stage for its participants to reshape the plan.`, input.ok ? { action: "landed", stage: current.stage, to: null } : { action: "reopened", stage: current.stage, to: current.stage });
+        await this.postTaskNote(actor.name, current, input.ok ? asSentence(input.detail) : `Landing failed: ${asSentence(input.detail)} The task waits at its last stage for its participants to reshape the plan.`, input.ok ? { action: "landed", stage: current.stage, to: null } : { action: "reopened", stage: current.stage, to: current.stage });
       }
       if (input.ok) {
         const task2 = await this.writeEndedTask(actor.name, location.project, {
@@ -7185,7 +7486,7 @@ ${rationale}`}`);
           await this.refreshMember(name);
         }
         if (landed) {
-          await this.appendMessage(actor.name, channelRef(location.project, task2.channel), `Task ${task2.id} "${task2.title}" is done: ${sentence(input.detail)}.`);
+          await this.appendMessage(actor.name, channelRef(location.project, task2.channel), `Task ${task2.id} "${task2.title}" is done: ${asSentence(input.detail)}`);
         }
         return task2;
       }
@@ -7896,7 +8197,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       files: taken.files.length,
       ...meta
     });
-    await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${skill.name} ${replaced ? "updated in" : "promoted to"} the society: ${sentence(skill.summary)}. Every citizen's skills index now lists it.`);
+    await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${skill.name} ${replaced ? "updated in" : "promoted to"} the society: ${asSentence(skill.summary)} Every citizen's skills index now lists it.`);
     return replaced;
   }
   /**
@@ -8143,7 +8444,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     });
     const purpose = withoutMentions(input.purpose);
     await this.appendMessage(SYSTEM_ACTOR.name, ref, `Channel ${ref} opened: ${purpose}`);
-    await this.appendMessage(SYSTEM_ACTOR.name, channelRef(input.project, "general"), `Channel ${ref} opened by ${by}: ${purpose}. Subscribe to it to follow its posts; its tasks and mentions reach whoever they concern either way.`);
+    await this.appendMessage(SYSTEM_ACTOR.name, channelRef(input.project, "general"), `Channel ${ref} opened by ${by}: ${asSentence(purpose)} Subscribe to it to follow its posts; its tasks and mentions reach whoever they concern either way.`);
     return ref;
   }
   /**
@@ -8495,7 +8796,7 @@ ${charter.purpose}
   }
   assertMayGate(actor, what) {
     if (!PLANNING_ROLES.includes(actor.role)) {
-      throw new BoardError("FORBIDDEN", `only the user, the steward, and the concierge may ${what}; ask one of them in the task's thread`);
+      throw new BoardError("FORBIDDEN", `only the user, the steward, and the concierge may ${what}; ask one of them in the task's thread, with a mention`);
     }
   }
   /** The user holds anything; everyone else must be a project member the current stage admits. */
@@ -8537,6 +8838,52 @@ ${charter.purpose}
   leaseEnd(now) {
     return new Date(now.getTime() + this.leaseMs).toISOString();
   }
+  /**
+   * The lease a holder's own crons in the task's thread keep its claim to, when later than the one
+   * it has, else null. While one of them is pending, the lease is renewed for a full lease once less
+   * than half is left, so it never lapses between fires that may be hours apart; once every one is
+   * paused, ended, or failed at its latest fire with nothing catching it up (`cronStoppedAt`), it
+   * runs a full lease from when the last of them stopped.
+   */
+  keptLease(task, crons, now) {
+    if (task.leaseExpiresAt === void 0) {
+      return null;
+    }
+    const lease = Date.parse(task.leaseExpiresAt);
+    let pending = false;
+    let stopped = null;
+    for (const cron of crons) {
+      if (cron.agent !== task.claimedBy || !firesInTask(cron, task)) {
+        continue;
+      }
+      const at = cronStoppedAt(cron);
+      if (at === null) {
+        pending = true;
+      } else {
+        stopped = Math.max(stopped ?? 0, Date.parse(at));
+      }
+    }
+    const kept = pending ? lease - now.getTime() < this.leaseMs / 2 ? now.getTime() + this.leaseMs : lease : stopped === null ? lease : stopped + this.leaseMs;
+    return kept > lease ? new Date(kept).toISOString() : null;
+  }
+  /**
+   * The lease a holder keeps while the user's pause, or its CLI's limit, holds its turns in the
+   * task's project (`heldOn`), when later than the one it has, else null. It is renewed for a full
+   * lease once less than half is left, as for a pending cron, so it never lapses while the holder
+   * cannot take a turn there, and after the resume or the reset the holder has at least half a
+   * lease to come back to it.
+   */
+  async pausedLease(task, runners2, runner, now) {
+    if (task.claimedBy === void 0 || task.leaseExpiresAt === void 0) {
+      return null;
+    }
+    const holder = await this.readAgent(task.claimedBy).catch(() => null);
+    if (holder === null || !heldOn(runners2, runner, holder.cli, now)) {
+      return null;
+    }
+    const lease = Date.parse(task.leaseExpiresAt);
+    return lease - now.getTime() < this.leaseMs / 2 ? this.leaseEnd(now) : null;
+  }
   leaseExpired(task, now) {
     return task.leaseExpiresAt !== void 0 && new Date(task.leaseExpiresAt).getTime() <= now.getTime();
   }
@@ -8622,9 +8969,9 @@ ${charter.purpose}
       });
     }
     const verdict = outcome === "approved" ? "Approved" : "Rejected";
-    const why = reason === void 0 ? "" : ` Reason: ${reason}.`;
+    const why = reason === void 0 ? "" : ` Reason: ${asSentence(reason)}`;
     const result = provision === void 0 ? "" : ` Provisioned: ${Object.entries(provision).map(([key, value]) => `${key} ${plain(value)}`).join(", ")}.`;
-    const post = `${verdict}: ${describeCharter(proposal.kind, proposal.charter)}.${why}${result}`;
+    const post = `${verdict}: ${asSentence(describeCharter(proposal.kind, proposal.charter))}${why}${result}`;
     await this.appendThreadMessage(actor.name, thread.id, actor.name === SYSTEM_ACTOR.name ? withoutMentions(post) : post, { step: { action: outcome } });
     await this.endThreadOf(proposalId, actor.name, outcome);
     return decision;
@@ -8649,11 +8996,7 @@ ${charter.purpose}
         if (task.claimedBy === actor.name || task.createdBy === actor.name || task.stages.some((stage) => stage.agent === actor.name || stage.holders.includes(actor.name))) {
           return true;
         }
-        if (task.status !== "open" || task.completing) {
-          return false;
-        }
-        const agent = await this.readAgent(actor.name);
-        return agent.memberships.includes(task.project) && mayHoldStage(actor, task);
+        return await this.mayTakeStage(actor, task);
       }
       if (subject?.kind === "proposal") {
         const proposal = await this.readProposal(subject.id);
@@ -8667,6 +9010,34 @@ ${charter.purpose}
     }
     return false;
   }
+  /** Whether a task's current stage waits for a holder and the member may take it. */
+  async mayTakeStage(actor, task) {
+    if (task.status !== "open" || task.completing) {
+      return false;
+    }
+    const agent = await this.readAgent(actor.name);
+    return agent.memberships.includes(task.project) && mayHoldStage(actor, task);
+  }
+  /**
+   * Which of a thread's posts count toward a reader's heartbeat (see `unreadByConversation`). A
+   * thread, or a task, the board cannot find counts as an open topic's would.
+   */
+  async threadCount(actor, id) {
+    const found = await this.tryFindThread(id);
+    if (found?.thread.state === "closed") {
+      return "none";
+    }
+    const subject = found?.thread.subject;
+    const task = subject?.kind === "task" ? await this.findTask(subject.id).then((location) => location.task, () => null) : null;
+    if (task === null) {
+      return "every";
+    }
+    const stageIsTheirs = task.status === "claimed" ? task.claimedBy === actor.name : await this.mayTakeStage(actor, task);
+    if (stageIsTheirs) {
+      return "every";
+    }
+    return task.createdBy === actor.name ? "asks-user" : "asked";
+  }
   async threadScopes() {
     const projects = await listDirs(this.paths.projects());
     return [this.paths.societyThreads(), ...projects.map((slug) => this.paths.threads(slug))];
@@ -8771,6 +9142,15 @@ ${charter.purpose}
 };
 
 // packages/scheduler/dist/wake.js
+function heartbeatCause(input) {
+  if (input.digestSize > 0) {
+    return "unread";
+  }
+  if (input.claimsHeld > 0) {
+    return "held";
+  }
+  return input.waitingStages > 0 ? "waiting" : null;
+}
 function decideWake(input) {
   if (input.paused) {
     return { wake: false, reason: "society paused", priority: 0 };
@@ -8802,7 +9182,7 @@ function decideWake(input) {
     case "heartbeat":
       break;
   }
-  if (input.digestSize === 0 && input.claimsHeld === 0 && input.waitingStages === 0) {
+  if (heartbeatCause(input) === null) {
     return { wake: false, reason: "nothing to read, hold, or take", priority: 0 };
   }
   return {
@@ -8897,6 +9277,18 @@ var StateSchema = z17.object({
   lastHeartbeat: z17.record(z17.string(), z17.string()),
   /** Waiting stages already signalled, as `task:stage`, so each is logged once while it waits. */
   waitingSeen: z17.record(z17.string(), z17.string()).default({}),
+  /**
+   * The last pass at which each waiting stage was held by the user's pause of its runner, as
+   * `task:stage`; its wait counts from there, so a stage that waited through a pause is not
+   * signalled the moment the pause ends.
+   */
+  waitingHeld: z17.record(z17.string(), z17.string()).default({}),
+  /**
+   * The last operations pass at which each citizen was held by the user's pause of a runner it
+   * works on; its idle time counts from there, so a citizen held through a pause is not signalled
+   * idle the moment the pause ends.
+   */
+  idleHeld: z17.record(z17.string(), z17.string()).default({}),
   /** Queued dispatches survive a restart; the cursor has already moved past the events that made them. */
   pending: z17.record(z17.string(), PendingSchema).default({}),
   opsReported: z17.record(z17.string(), z17.string()).default({}),
@@ -9835,10 +10227,14 @@ var Scheduler = class {
    * A heartbeat per member and scope on the cadence, which then looks at every conversation of the
    * scope: the unread messages of its home, of each other channel, and of each thread, a stage the
    * member holds, and a stage of an unblocked task waiting that it may take, each in its task's
-   * thread. Each conversation with something wakes on its own, so a heartbeat never brings one
-   * task's business into another's turn.
+   * thread. A stage counts for neither while the member has a cron pending in its task's thread
+   * (`cronStoppedAt`: neither paused nor ended, and its latest fire's turn did not fail or was
+   * caught up since), whose fires are its checks there. Each conversation with something wakes on
+   * its own, so a heartbeat never brings one task's business into another's turn, and its trigger
+   * says what it woke for (`heartbeatCause`).
    */
   async checkHeartbeats(now) {
+    let pendingCrons;
     for (const agent of await this.board.listAgents()) {
       if (agent.status !== "active" || agent.cli === null) {
         continue;
@@ -9864,6 +10260,9 @@ var Scheduler = class {
         this.state.lastHeartbeat[cadence] = iso(now);
         unread ??= await this.board.unreadByConversation(actor);
         held ??= await this.board.heldClaims(agent.name);
+        pendingCrons ??= (await this.board.listCrons()).filter((cron) => cronStoppedAt(cron) === null);
+        const crons = pendingCrons;
+        const leftToCron = (task) => crons.some((cron) => cron.agent === agent.name && firesInTask(cron, task));
         const reasons = /* @__PURE__ */ new Map();
         const reasonsIn = (beside) => {
           const key = conversationKey2(agent.name, project, beside);
@@ -9882,13 +10281,13 @@ var Scheduler = class {
           }
         }
         for (const task of held) {
-          if (task.project === project) {
+          if (task.project === project && !leftToCron(task)) {
             reasonsIn({ thread: { id: task.id, task: true } }).claimsHeld += 1;
           }
         }
         if (project !== SOCIETY_SCOPE) {
           for (const task of await this.board.openTasks(project)) {
-            if (mayHoldStage(agent, task) && (await this.blockersInPlay(task.blockedBy)).length === 0) {
+            if (mayHoldStage(agent, task) && !leftToCron(task) && (await this.blockersInPlay(task.blockedBy)).length === 0) {
               reasonsIn({ thread: { id: task.id, task: true } }).waiting += 1;
             }
           }
@@ -9897,7 +10296,16 @@ var Scheduler = class {
           if (this.pending.has(key) || this.running.has(key)) {
             continue;
           }
-          const trigger = TriggerSchema.parse({ kind: "heartbeat", reason: "heartbeat" });
+          const cause = heartbeatCause({
+            digestSize: reason.digestSize,
+            claimsHeld: reason.claimsHeld,
+            waitingStages: reason.waiting
+          });
+          const trigger = TriggerSchema.parse({
+            kind: "heartbeat",
+            reason: "heartbeat",
+            ...cause === null ? {} : { heartbeat: cause }
+          });
           const decision = decideWake({
             trigger,
             digestSize: reason.digestSize,
@@ -10100,7 +10508,9 @@ var Scheduler = class {
    */
   async checkWaitingStages(now) {
     const stillWaiting = /* @__PURE__ */ new Set();
+    const runners2 = await this.board.listRunners();
     for (const project of await this.board.listProjects()) {
+      let members;
       for (const task of await this.board.openTasks(project.slug)) {
         const stage = currentStage(task);
         if (stage === void 0) {
@@ -10111,7 +10521,14 @@ var Scheduler = class {
         if (this.state.waitingSeen[key] !== void 0) {
           continue;
         }
-        const age = now - Date.parse(task.stageSince);
+        members ??= await this.board.projectMembers(project.slug);
+        const takers = members.filter((member) => member.cli !== null && mayHoldStage(member, task));
+        if (takers.length > 0 && takers.every((taker) => heldOn(runners2, project.runner, taker.cli, new Date(now)))) {
+          this.state.waitingHeld[key] = iso(now);
+          continue;
+        }
+        const held = this.state.waitingHeld[key];
+        const age = now - Math.max(Date.parse(task.stageSince), held === void 0 ? 0 : Date.parse(held));
         if (age < this.timings.waitingStageMs) {
           continue;
         }
@@ -10132,6 +10549,11 @@ var Scheduler = class {
         });
       }
     }
+    for (const key of Object.keys(this.state.waitingHeld)) {
+      if (!stillWaiting.has(key)) {
+        delete this.state.waitingHeld[key];
+      }
+    }
     for (const key of Object.keys(this.state.waitingSeen)) {
       if (!stillWaiting.has(key)) {
         delete this.state.waitingSeen[key];
@@ -10197,7 +10619,8 @@ var Scheduler = class {
     const roles = (await this.board.listRoles()).filter((role) => role.name !== USER_ROLE);
     const runners2 = await this.board.listRunners();
     const anywhere = new Set(runners2.filter((runner) => runner.status === "connected").flatMap((runner) => runner.capabilities));
-    for (const project of await this.board.listProjects()) {
+    const projects = await this.board.listProjects();
+    for (const project of projects) {
       const slug = project.slug;
       const tasks = await this.board.listTasks(slug);
       const home = runners2.find((runner) => runner.name === project.runner);
@@ -10289,7 +10712,13 @@ var Scheduler = class {
       }
     }
     const crons = (await this.board.listCrons()).filter((cron) => cron.ended === void 0);
-    for (const agent of await this.board.listAgents()) {
+    const agents = await this.board.listAgents();
+    for (const name of Object.keys(this.state.idleHeld)) {
+      if (!agents.some((agent) => agent.name === name && agent.status === "active")) {
+        delete this.state.idleHeld[name];
+      }
+    }
+    for (const agent of agents) {
       if (agent.status !== "active" || agent.cli === null) {
         continue;
       }
@@ -10301,7 +10730,13 @@ var Scheduler = class {
           last = Math.max(last, Date.parse(ended));
         }
       }
-      const idle = now - last;
+      const at = new Date(now);
+      const held = heldOn(runners2, agent.homeRunner, agent.cli, at) || projects.some((project) => agent.memberships.includes(project.slug) && heldOn(runners2, project.runner, agent.cli, at));
+      if (held) {
+        this.state.idleHeld[agent.name] = iso(now);
+      }
+      const heldAt = this.state.idleHeld[agent.name];
+      const idle = now - Math.max(last, heldAt === void 0 ? 0 : Date.parse(heldAt));
       if (idle >= this.timings.idleMemberMs) {
         signals.push({
           kind: "idle_member",
@@ -10654,20 +11089,21 @@ var Scheduler = class {
 import { randomUUID } from "node:crypto";
 
 // packages/turn-host/dist/render.js
+import { createHash as createHash3 } from "node:crypto";
 var TURN_CONTRACT = [
   "- Every turn belongs to one conversation, named at the top of your prompt: your home conversation in a project or the society, for its general channel and for work tied to no other channel and no thread; the conversation of one other channel of the place, a workstream such as a release; outside projects, the conversation of one project's channels, general and its workstreams together, for posts there that ask something of you while you are not a member; or the conversation of one thread you take part in, a task's, a proposal's, or a topic's. Each has its own session and its own turns, which may run while this one does. The prompt carries this conversation only: in a thread, its new messages, or the whole thread when the conversation is new, and in a task's thread the task and its stage; in a channel's, a project's, or at home, that channel's, that project's channels', or general's messages that concern you. Read anything else you need with get_task, search, and the board's files, and leave other channels', other threads', and other projects' work to their own turns.",
-  "- Act through the board tools (the `board` MCP server). Holding a stage is a lease; every turn that touches the task renews it.",
+  "- Act through the board tools (the `board` MCP server). Holding a stage is a lease; every turn that touches the task renews it, and so does the board while a cron of yours in the task's thread is pending.",
   "- 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. The branch is checked out in one worktree at a time and kept for the turns of whoever holds the task's stage, so a turn of anyone else there, or one that starts while another turn has the branch, works detached at its tip, which Your workspace then says; its commits go on the branch by a fast-forward when a turn in the task ends with the branch free, and the task's thread is told of commits that no longer build on its tip. 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 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. While you check your own stage's work on a schedule, such as a running job, CI, or a deploy, keep holding the stage: the cron sets when you check, and your turns in the task's thread renew its lease. Release a stage only to hand it on, or once its task's blocked_by names the tasks it waits on: the stage then wakes nobody until the last of them ends. Any other wait on someone else, such as the user or an outside party, is a stage of its own, not a held stage. The society's crons are under society/crons/ in the board projection.",
+  "- 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 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. While you check your own stage's work on a schedule, such as a running job, CI, or a deploy, keep holding the stage: the cron sets when you check, and while it is pending in the task's thread, neither ended nor paused, with its latest fire's turn not failed or a turn of yours there completed since, the board keeps your lease and the heartbeat leaves the stage to it, waking you there only for a post you have not read. Release a stage only to hand it on, or once its task's blocked_by names the tasks it waits on: the stage then wakes nobody until the last of them ends. Any other wait on someone else, such as the user or an outside party, is a stage of its own, not a held stage. 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. A name in a code span or a code block is no mention, so code keeps its @ as written. @user wakes nobody, since the user takes no turns; it is what puts a question before the user, so use it only when you need the user to answer or decide.",
-  "- A thread is a conversation off a channel that reaches only its participants and whoever is mentioned in it. Every task has one, opened with it under the task's id on the channel of its project it was filed in, general unless it was filed in another: talk about a task there, with post_message and its thread_id, and the notes you give advance_task and update_task are posted there as you. Its participants are the task's creator, its stage holders and assignees, whoever may take the stage that waits, and anyone who posted; it closes when the task ends. Every proposal has one too, in governance, opened with its pitch and closed by its decision. Open other threads with open_thread on a channel with a title, for any other topic; close_thread posts your summary to its channel.",
-  "- To show an image in a post, such as a screenshot or a chart, save it anywhere you can read it, such as a folder from `mktemp -d`, call upload_image with its path, and put the markdown it returns in the post, `![what it shows](image:<id>)`, with what the image shows as its alt text: the board keeps the image, so it shows in any conversation after the file is gone. It takes a PNG, JPEG, GIF, or WebP of at most 8 MB from your worktree, your home, or the system temp folder. An image committed on a task's branch, linked by its path in the task's worktree, still shows in place, and so does one at an https address. Never put an image or any other file into a message as base64 or a data: URL: the board does not show it, and every reader of the conversation gets it in full in their prompt.",
+  "- 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. In a task's thread, only the current stage's holder, or while nobody holds it whoever may take it, wakes for your post, and a post that asks the user also wakes the task's creator; mention anyone else you need, including the concierge for a plan change. Every proposal has one too, in governance, opened with its pitch and closed by its decision. Open other threads with open_thread on a channel with a title, for any other topic; close_thread posts your summary to its channel.",
+  "- To show an image in a post, such as a screenshot or a chart, save it anywhere you can read it, such as a folder from `mktemp -d`, call upload_image with its path, and put the markdown it returns in the post, `![what it shows](image:<id>)`, with what the image shows as its alt text: the board keeps the image, so it shows in any conversation after the file is gone. It takes a PNG, JPEG, GIF, or WebP of at most 8 MB from your worktree, your home, or the system temp folder. An image committed on a task's branch, linked by its path in the task's worktree, still shows in place, and so does one at an https address. Never put an image or any other file into a message as base64 or a data: URL: the board does not show it, and every reader of the conversation gets it in full in their prompt. To see an image a post, a brief, or a topic shows as `image:<id>`, call read_image with the id: it returns the path of a file of this turn's own that holds the image, removed when the turn ends, which you open with the tool that shows you an image, Read in Claude Code or view_image in Codex.",
   "- 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; how a codebase behaves (architecture, conventions, gotchas, how to build, test, and verify it) goes in its AGENTS.md or README, committed on a task's branch like any change to the code, or proposed in the task's thread or the project channel when it is outside the task at hand; a durable fact about a project as a place (runners, access, flow, where results live) goes through `write_knowledge` on that project; something the whole project should know now, post it to the project channel, and anything about one task, in the task's thread.",
   '- A procedure you have followed twice is a candidate for a skill, which it is when it makes a citizen better at a kind of work on any project: write it to skills/<name>/SKILL.md in your home, frontmatter with `name` and a one-line `description` and then the steps, and your skills index lists it from the next turn. Files the steps use, such as scripts/ and references/, go in the same folder, named in SKILL.md by paths relative to it. Propose it with kind "skill" when more than one citizen would use it and nothing in it is tied to one place; a skill only you use stays yours, however many projects you use it on.',
   "- To take a published skill for yourself, install it in a temporary folder and copy it into your home: in a folder from `mktemp -d`, `npx -y skills add <source> --skill <name> -a universal --copy -y` writes `.agents/skills/<name>/` and a lock file there, and you copy that skill folder to skills/<name>/ in your home, named in lowercase letters, digits, and hyphens. Never install one inside a worktree, where it would be committed into the project, or with -g, which writes to the runner's own home, shared by every citizen on it and listed in no skills index.",
-  "- Report memoryUpdated: true in the status object whenever you changed memory/core.md or a skill, so a warm session restarts with the new instructions.",
+  "- Report memoryUpdated: true in the status object whenever you changed memory/core.md or a skill. A change to your instructions reaches each of your conversations at its next turn, whose prompt then carries them whole, replacing what that conversation had; a turn already running keeps what it started with.",
   "- Other turns of yours may be running at the same time and share your home. Change a file there with your edit tool, which refuses a file changed since you read it, and never rewrite one whole from an earlier read, with a shell redirect or a script, or you erase what another of your turns wrote.",
   "- To ask the user something, mention @user where the question belongs: the task's thread for a task, the proposal's thread for a proposal, and for anything else a thread you open on your scope's general channel, titled with the question. The user answers in the same thread, and the answer comes back to that thread's conversation. A proposal waiting on the user is already in front of them and needs no mention.",
   "- End every turn with the status object: summary, claims held, what is blocked, and whether the user must decide. If you report that the user must decide, mentioned @user nowhere this turn, and proposed nothing for the user to decide, the runner asks in this turn's thread when it has one, and otherwise opens a thread on your scope's general channel with your summary as the question."
@@ -10676,9 +11112,9 @@ var PLANNING = [
   "- A task is a plan of stages between open and done. Hold the current stage with claim_task and finish it with advance_task; the next stage becomes current, and past the last one the task is done.",
   "- Name stages by what gets done. Plan the next few steps rather than everything, and reshape with plan_task as the work teaches you.",
   "- Assign a stage to a role when anyone in it could do it, to a citizen only when it must be them, and to nobody when anyone in the project could. A citizen named on a stage must be a member of the task's project; add them first. A stage wakes everyone it is open to when it comes up, so the narrower the assignee, the fewer turns it costs.",
-  "- Reshape rather than force: another round is an inserted stage, and a wait on something outside the society is a stage named for what it waits on. When a check finds work unfinished, the holder of the current stage sends the task back to an earlier stage with update_task, and so may the user, the steward, and the concierge; anyone else asks the concierge in the task's thread.",
+  "- Reshape rather than force: another round is an inserted stage, and a wait on something outside the society is a stage named for what it waits on. When a check finds work unfinished, the holder of the current stage sends the task back to an earlier stage with update_task, and so may the user, the steward, and the concierge; anyone else asks the concierge in the task's thread, with a mention.",
   "- A task that cannot start until other tasks finish names them with update_task blocked_by, and whoever holds its stage then releases it, since the heartbeat still wakes a holder. While any of them is in play, a stage nobody holds wakes nobody, neither when it comes up nor on a heartbeat; once the last has ended, done or abandoned, the stage wakes as if it had just come up, or wakes its holder. Nobody needs to clear the block or mention anyone when they end; change blocked_by only when the plan changes.",
-  "- A gated stage is an independent check: nobody who held an earlier stage of the task may hold it, and only the user, the steward, and the concierge may add, remove, move, reassign, or ungate it. Ask them in the task's thread when a gate should change.",
+  "- A gated stage is an independent check: nobody who held an earlier stage of the task may hold it, and only the user, the steward, and the concierge may add, remove, move, reassign, or ungate it. Ask them in the task's thread, with a mention, when a gate should change.",
   "- Commit your work on the task's branch before you advance, and say what you did in the advance note; it is the handover the next holder reads in the task's thread."
 ].join("\n");
 var GOVERNANCE = [
@@ -10737,6 +11173,10 @@ function renderInstructions(input) {
   return `${sections.join("\n")}
 `;
 }
+function instructionsHash(input) {
+  const { onboarding: _first, ...kept } = input;
+  return createHash3("sha256").update(renderInstructions(kept)).digest("hex");
+}
 
 // packages/turn-host/dist/prompt.js
 var REFLECTION_INTRO = "This turn is for your memory; take no new work, and answer unread messages only where a reply is needed. Read memory/core.md and your recent turn records, then:";
@@ -10749,6 +11189,7 @@ var REFLECTION_STEPS = [
 ];
 var SAVE_WHAT_IS_OPEN = "- This conversation's session ends with this turn, and the next turn here starts a new one that knows only your home's files and the board: write anything still open into memory/core.md, or the archive it points to, before you end.";
 var REFLECTION_REPORT = "- Report memoryUpdated: true in the status object when core.md or a skill changed.";
+var INSTRUCTIONS_CHANGED = "Your instructions changed since this conversation last received them. Between the tags below are the whole of them now: they replace the instructions this conversation began with and any earlier text like this, so where the two differ, follow these, and a rule missing from them no longer applies.";
 var MAX_BODY_CHARS = 1500;
 var MAX_PROFILE_CHARS = 200;
 function clip(text) {
@@ -10803,12 +11244,23 @@ function quotaPhrase(cli, quota, now) {
 }
 function runnerLine(runner, projects, now) {
   const living = projects.filter((project) => project.runner === runner.name).map((project) => project.slug);
-  const state = runner.status === "connected" ? "connected" : `away${runner.lastSeen === void 0 ? "" : ` since ${runner.lastSeen}`}`;
+  const state = [
+    runner.status === "connected" ? "connected" : `away${runner.lastSeen === void 0 ? "" : ` since ${runner.lastSeen}`}`,
+    ...runner.paused === void 0 ? [] : [`paused by the user since ${runner.paused.at}`]
+  ].join(", ");
+  const pauses = runner.clis.flatMap((cli) => {
+    const pause = runner.pausedClis?.[cli];
+    const hold = runnerLimitHold(runner, cli, now);
+    return [
+      ...pause === void 0 ? [] : [`${cli} paused by the user since ${pause.at}`],
+      ...hold === null ? [] : [`${cli} held by its limit until ${hold.until}`]
+    ];
+  });
   const quotas = runner.clis.flatMap((cli) => {
     const quota = runner.quotas?.[cli];
     return quota === void 0 ? [] : [quotaPhrase(cli, quota, now)];
   });
-  return `- ${runner.name}: ${state}; ${runner.os}; CLIs ${runner.clis.length === 0 ? "none" : runner.clis.join(", ")}; offers ${runner.capabilities.length === 0 ? "nothing beyond its CLIs" : runner.capabilities.join(", ")}; ${living.length === 0 ? "no projects" : `projects ${living.join(", ")}`}${quotas.length === 0 ? "" : `; quota ${quotas.join("; ")}`}`;
+  return `- ${runner.name}: ${state}; ${runner.os}; CLIs ${runner.clis.length === 0 ? "none" : runner.clis.join(", ")}; offers ${runner.capabilities.length === 0 ? "nothing beyond its CLIs" : runner.capabilities.join(", ")}; ${living.length === 0 ? "no projects" : `projects ${living.join(", ")}`}${pauses.map((pause) => `; ${pause}`).join("")}${quotas.length === 0 ? "" : `; quota ${quotas.join("; ")}`}`;
 }
 function profileLine(profile) {
   const line = profile.split("\n").map((entry) => entry.trim()).find((entry) => entry.length > 0 && !entry.startsWith("#"));
@@ -10845,7 +11297,7 @@ function messageLines(messages, threads) {
 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()}.`;
+  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.` : cron.paused !== void 0 ? ` ${cron.paused.by} has paused it since it fired, so it fires no more until resumed.` : 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}`,
     "",
@@ -10899,6 +11351,10 @@ function buildTurnPrompt(input) {
   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.");
   }
+  const changed = input.changedInstructions ?? null;
+  if (changed !== null) {
+    lines.push("", "## Your instructions changed", "", INSTRUCTIONS_CHANGED, "", "<instructions>", changed.trimEnd(), "</instructions>");
+  }
   const conversation = input.conversation ?? null;
   lines.push("", "## This conversation", "");
   if (conversation === null && dispatch.channel !== void 0) {
@@ -10947,6 +11403,11 @@ function buildTurnPrompt(input) {
       "Its CLI could not resume this conversation's session, so the session was dropped and this turn starts a new one: nothing of your earlier turns here carries over but what is on the board and in your home."
     ] : [], "The worktree may hold uncommitted changes. Run git status before doing anything else.");
   }
+  const failed = input.failedCrons ?? [];
+  if (failed.length > 0) {
+    const timeZone = input.clock?.timeZone ?? DEFAULT_TIME_ZONE;
+    lines.push("", "## Cron fires that did not finish", "", failed.length === 1 ? "The turn of this cron's latest fire here failed, so what its note asks may not be done:" : "The turns of these crons' latest fires here failed, so what their notes ask may not be done:", "", ...failed.flatMap((cron) => cronLines(cron, timeZone)));
+  }
   if (last?.trigger.kind === "reflection" && last.exitReason === "completed" && last.sessionDropped === true) {
     lines.push("", "## Your session started afresh", "", "Your last turn here was a reflection, and this conversation's session ended with it, so this turn starts a new one: what you kept is in memory/core.md and the archive it points to, and what your earlier turns did is on the board, in your posts and the threads and tasks you worked in, which search and the board's files reach.");
   }
@@ -10966,7 +11427,7 @@ function buildTurnPrompt(input) {
   }
   const machines = input.runners;
   if (machines !== void 0 && machines !== null) {
-    lines.push("", "## Runners", "", "The machines turns run on. A project lives on the runner that takes its first turn, one that offers every capability the project and that turn's task require, and moves only when the user moves it. A task's required_capabilities must name capabilities exactly as a runner below offers them; a task needing one its project's runner lacks waits. A runner's quota is what each CLI's login there last reported of its plan, in percent of each window; a CLI limited until a time fails its turns there until then.", "");
+    lines.push("", "## Runners", "", "The machines turns run on. A project lives on the runner that takes its first turn, one that offers every capability the project and that turn's task require, and moves only when the user moves it. A task's required_capabilities must name capabilities exactly as a runner below offers them; a task needing one its project's runner lacks waits. A runner's quota is what each CLI's login there last reported of its plan, in percent of each window. A runner, or a CLI on it, paused by the user starts none of the turns it would run until the user resumes it, and a CLI held by its limit starts none of its turns there until the limit lifts, at the reset the CLI gave or, with none given, half an hour after the report: they wait, and the stages their citizens hold keep their leases.", "");
     if (machines.runners.length === 0) {
       lines.push("None registered yet.");
     }
@@ -11211,7 +11672,7 @@ var TurnHost = class {
       worktree: PATH_TOKENS.worktree,
       otherChannels: (project?.channels ?? []).map((name) => channelRef(dispatch.project, name)).filter((ref) => !agent.subscriptions.includes(ref))
     } : null;
-    const instructions = renderInstructions({
+    const rendered = {
       agentName: agent.name,
       roleCharter: await this.board.readAgentRoleBody(agent.name),
       memoryCore: await this.board.readMemoryCore(agent.name),
@@ -11229,7 +11690,11 @@ var TurnHost = class {
         }))
       ],
       ...onboarding === null ? {} : { onboarding }
-    });
+    };
+    const instructions = renderInstructions(rendered);
+    const instructionsNow = instructionsHash(rendered);
+    const instructionsHeld = !newSession && lastTurn?.session === recorded ? lastTurn.sessionInstructionsHash : void 0;
+    const changedInstructions = !newSession && instructionsHeld !== instructionsNow;
     const societyView = charter.wakeTriggers.includes(USER_POST_TRIGGER2) ? {
       projects: (await this.board.listProjects()).filter((each) => each.archived === void 0),
       members: await this.board.listMembers()
@@ -11270,6 +11735,11 @@ var TurnHost = class {
         crons.push(cron);
       }
     }
+    const failedCrons = (await this.board.listCrons()).filter((cron) => cron.agent === agent.name && cron.scope === dispatch.project && conversationPart(cron) === part && cronFailure(cron) !== null && !(dispatch.crons ?? []).includes(cron.id));
+    const cronFailures = failedCrons.flatMap((cron) => {
+      const failure = cronFailure(cron);
+      return failure === null ? [] : [{ cron: cron.id, turnId: failure.turnId }];
+    });
     const prompt = buildTurnPrompt({
       dispatch,
       clock: { now: this.now(), timeZone: society.timezone },
@@ -11282,6 +11752,8 @@ var TurnHost = class {
       waitingStages: waiting,
       project,
       lastTurn,
+      failedCrons,
+      ...changedInstructions ? { changedInstructions: instructions } : {},
       onboarding,
       afreshAfterReflection,
       societyView,
@@ -11297,7 +11769,9 @@ var TurnHost = class {
       ...base,
       session: recorded ?? null,
       sessionCostUsd: costSoFarUsd,
-      ...usageSoFar === void 0 ? {} : { sessionUsage: usageSoFar }
+      ...usageSoFar === void 0 ? {} : { sessionUsage: usageSoFar },
+      ...instructionsHeld === void 0 ? {} : { sessionInstructionsHash: instructionsHeld },
+      ...cronFailures.length === 0 ? {} : { cronFailures }
     });
     if (record.id === void 0) {
       throw new Error("the board gave the turn no id");
@@ -11317,6 +11791,7 @@ var TurnHost = class {
       costSoFarUsd,
       ...usageSoFar === void 0 ? {} : { usageSoFar },
       instructions,
+      instructionsHash: instructionsNow,
       prompt,
       mcp: { url: this.mcpUrl, token },
       limits: { timeoutMs: this.turnTimeoutMs, maxTurns: this.maxTurns },
@@ -11340,6 +11815,7 @@ var TurnHost = class {
       stopRequestedBy: null,
       held: held.map((each) => each.id),
       costSoFarUsd,
+      instructionsNow,
       resumeRetries,
       configuredModel: agent.model ?? null,
       transcript: [],
@@ -11510,7 +11986,10 @@ var TurnHost = class {
     const resumeRetries = outcome.resumeFailed === "retry" ? turn.resumeRetries + 1 : void 0;
     const dropSession = job.session !== null && (outcome.resumeFailed === "lost" || (resumeRetries ?? 0) >= RESUME_RETRIES);
     const reflected = turn.afreshAfterReflection && turn.record.trigger.kind === "reflection" && outcome.exitReason === "completed";
-    const { sessionUsage: _started, ...begun } = turn.record;
+    const { sessionUsage: _started, sessionInstructionsHash: heldBefore, ...begun } = turn.record;
+    const promptDelivered = outcome.exitReason === "completed" || outcome.exitReason === "blocked" || outcome.exitReason === "stopped";
+    const instructionsTaken = outcome.exitReason === "stopped" ? outcome.contextTokens !== void 0 : promptDelivered;
+    const instructionsHeld = job.session === null ? outcome.session === null ? void 0 : turn.instructionsNow : instructionsTaken ? turn.instructionsNow : heldBefore;
     const finished = {
       ...begun,
       session: outcome.session,
@@ -11522,6 +12001,7 @@ var TurnHost = class {
       costUsd: outcome.costUsd,
       sessionCostUsd: outcome.sessionCostUsd ?? turn.costSoFarUsd,
       ...outcome.sessionUsage === void 0 ? {} : { sessionUsage: outcome.sessionUsage },
+      ...instructionsHeld === void 0 ? {} : { sessionInstructionsHash: instructionsHeld },
       ...outcome.contextTokens === void 0 ? {} : { contextTokens: outcome.contextTokens },
       toolCalls: turn.transcript.filter((entry) => entry.event.type === "tool_call").length,
       model: outcome.model ?? turn.configuredModel,
@@ -11556,7 +12036,7 @@ var TurnHost = class {
       } else if (outcome.session !== null && outcome.session !== job.session) {
         await this.board.writeSession(job.agent, job.scope, job.cli, outcome.session, turn.runner, part);
       }
-      if (outcome.exitReason === "completed" || outcome.exitReason === "blocked" || outcome.exitReason === "stopped") {
+      if (promptDelivered) {
         await this.board.setDigestCursor(job.agent, job.scope, turn.delivered, part);
         await this.renewLeases(turn.actor, turn.held);
         if (outcome.status?.needsUserDecision === true) {
@@ -11844,6 +12324,9 @@ var TurnHost = class {
 
 // packages/turn-host/dist/hub.js
 import { randomUUID as randomUUID2 } from "node:crypto";
+function receiptOverdue(seat) {
+  return [...seat.unacked.values()].some((each) => each.overdue);
+}
 var RunnerProtocolError = class extends Error {
 };
 var RunnerAwayError = class extends Error {
@@ -11888,6 +12371,13 @@ var RunnerHub = class {
   starting = /* @__PURE__ */ new Map();
   /** Moves started since the hub did, so a placement that a move overtook gives its turn back. */
   moveStarts = 0;
+  /** When each runner was last asked to read a CLI's quota for a limit with no reset, by `runner/cli`. */
+  limitReads = /* @__PURE__ */ new Map();
+  /**
+   * The turn let through once a limit with no reset had held its half hour, by `runner/cli`: the
+   * report it tries, which `observedAt` names, and whether the turn has ended.
+   */
+  limitTries = /* @__PURE__ */ new Map();
   constructor(options) {
     this.board = options.board;
     this.host = options.host;
@@ -11924,9 +12414,9 @@ var RunnerHub = class {
     if (hello.protocol !== RUNNER_PROTOCOL) {
       throw new RunnerProtocolError(`runner protocol ${hello.protocol} is not ${RUNNER_PROTOCOL}; upgrade the runner or the server`);
     }
-    const seat = this.seats.get(name);
+    let seat = this.seats.get(name);
     if (seat === void 0) {
-      this.seats.set(name, {
+      seat = {
         name,
         hello,
         send: null,
@@ -11934,19 +12424,18 @@ var RunnerHub = class {
         warm: /* @__PURE__ */ new Set(),
         disconnectedAt: null,
         grace: null,
-        unacked: /* @__PURE__ */ new Map(),
-        unconfirmed: false
-      });
+        unacked: /* @__PURE__ */ new Map()
+      };
+      this.seats.set(name, seat);
     } else {
       seat.hello = hello;
       seat.warm = /* @__PURE__ */ new Set();
     }
     const still = new Set(hello.turns);
-    const unacked = this.seats.get(name)?.unacked ?? /* @__PURE__ */ new Map();
     for (const turnId of this.host.turnsOn(name)) {
       if (still.has(turnId)) {
-        this.settle(unacked, turnId);
-      } else if (!unacked.has(turnId)) {
+        this.settle(seat, turnId);
+      } else if (!seat.unacked.has(turnId)) {
         await this.host.abortTurn(turnId, `runner ${name} restarted during the turn`);
       }
     }
@@ -11969,7 +12458,6 @@ var RunnerHub = class {
     }
     seat.send = send;
     seat.disconnectedAt = null;
-    seat.unconfirmed = false;
     if (seat.grace !== null) {
       clearTimeout(seat.grace);
       seat.grace = null;
@@ -12010,24 +12498,23 @@ var RunnerHub = class {
     }
     await Promise.allSettled(this.detaching);
   }
+  /** A turn's steps, which show its job arrived as its receipt would. */
   async turnEvents(runner, turnId, entries) {
     this.assertOwns(runner, turnId);
+    this.received(runner, turnId);
     await this.host.addEvents(turnId, entries);
   }
   /** A runner's word that a turn's job arrived, which also shows its stream delivers again. */
   received(runner, turnId) {
     const seat = this.seats.get(runner);
-    if (seat === void 0 || !seat.unacked.has(turnId)) {
-      return;
-    }
-    this.settle(seat.unacked, turnId);
-    if (seat.unconfirmed) {
-      seat.unconfirmed = false;
-      this.log.info({ runner }, "runner is taking jobs again");
+    if (seat !== void 0) {
+      this.settle(seat, turnId);
     }
   }
+  /** A turn's outcome, which shows its job arrived as its receipt would. */
   async turnOutcome(runner, turnId, outcome) {
     this.assertOwns(runner, turnId);
+    this.received(runner, turnId);
     const ack = await this.host.closeTurn(turnId, outcome);
     return ack ?? { dropWorkspace: false };
   }
@@ -12171,8 +12658,11 @@ var RunnerHub = class {
       return { refused: `${agent.name} has no CLI binding` };
     }
     const cli = agent.cli;
-    const free = (seat) => seat.send !== null && !seat.unconfirmed && seat.hello.clis.includes(cli) && (seat.hello.slots === null || seat.inUse < seat.hello.slots);
+    const runners2 = await this.board.listRunners();
+    const now = this.now();
+    const free = (seat) => seat.send !== null && !receiptOverdue(seat) && seat.hello.clis.includes(cli) && (seat.hello.slots === null || seat.inUse < seat.hello.slots) && !heldOn(runners2, seat.name, cli, now) && !this.tryRunning(runners2, seat.name, cli, now);
     let chosen;
+    let waitsOn = agent.homeRunner;
     if (dispatch.project === SOCIETY_SCOPE) {
       chosen = await this.pinnedSeat(agent.name, agent.homeRunner, cli, free);
     } else {
@@ -12201,8 +12691,12 @@ var RunnerHub = class {
       }
       const seat = this.seats.get(home);
       chosen = seat !== void 0 && free(seat) ? seat : void 0;
+      waitsOn = home;
     }
     if (chosen === void 0) {
+      if (waitsOn !== void 0) {
+        this.readAfterLimit(runners2, waitsOn, cli, now);
+      }
       return null;
     }
     if (dispatch.project !== SOCIETY_SCOPE && (this.moving.has(dispatch.project) || this.moveStarts !== starts)) {
@@ -12212,7 +12706,17 @@ var RunnerHub = class {
     if (dispatch.project !== SOCIETY_SCOPE) {
       this.starting.set(dispatch.project, (this.starting.get(dispatch.project) ?? 0) + 1);
     }
-    return { runner: chosen.name };
+    const runner = chosen.name;
+    const lapsed = runners2.find((each) => each.name === runner)?.quotas?.[cli];
+    const tried = this.limitTries.get(`${runner}/${cli}`);
+    if (lapsed !== void 0 && limitLapsed(lapsed, now) && tried?.observedAt !== lapsed.observedAt) {
+      this.limitTries.set(`${runner}/${cli}`, {
+        observedAt: lapsed.observedAt,
+        dispatch,
+        ended: false
+      });
+    }
+    return { runner };
   }
   async runTurn(dispatch, assignment) {
     if ("refused" in assignment) {
@@ -12249,10 +12753,15 @@ var RunnerHub = class {
       return await opened.ended;
     } finally {
       opening();
+      for (const tried of this.limitTries.values()) {
+        if (tried.dispatch === dispatch) {
+          tried.ended = true;
+        }
+      }
       if (seat !== void 0) {
         seat.inUse = Math.max(0, seat.inUse - 1);
         if (turnId !== null) {
-          this.settle(seat.unacked, turnId);
+          this.settle(seat, turnId);
         }
       }
     }
@@ -12428,11 +12937,7 @@ var RunnerHub = class {
       move.id = await this.board.openMoveRepo();
       const id = move.id;
       move.phase = "export";
-      const exported = ProjectExportedSchema.parse(await this.request(source, (request) => ({
-        type: "export",
-        request,
-        export: { move: id, repo }
-      })).catch((error) => {
+      const exported = ProjectExportedSchema.parse(await this.request(source, (request) => ({ type: "export", request, export: { move: id, repo } }), moveTransferMs(MOVE_PACK_LIMIT_BYTES) + this.requestTimeoutMs).catch((error) => {
         throw new BoardError("INVALID_STATE", `${from} could not send ${slug}: ${describe(error)}`);
       }));
       if (!exported.ok) {
@@ -12442,8 +12947,13 @@ var RunnerHub = class {
       const imported = ProjectImportedSchema.parse(await this.request(target, (request) => ({
         type: "import",
         request,
-        import: { move: id, repo, pullRequests: project.onDone === "ghpr" }
-      })).catch((error) => {
+        import: {
+          move: id,
+          repo,
+          pullRequests: project.onDone === "ghpr",
+          bytes: exported.bytes
+        }
+      }), moveTransferMs(exported.bytes) + this.requestTimeoutMs).catch((error) => {
         throw new BoardError("INVALID_STATE", `${to} could not take ${slug}: ${describe(error)}`);
       }));
       move.phase = "recording";
@@ -12570,18 +13080,8 @@ var RunnerHub = class {
    * back as a `BoardError` in the runner's words.
    */
   async readTurnImage(actor, file) {
-    const turn = this.host.runningTurns().find((each) => each.agent === actor.name && each.scope === actor.scope && each.thread === actor.thread && each.channel === actor.channel && each.place === actor.place);
-    if (turn === void 0) {
-      throw new BoardError("INVALID_STATE", `${actor.name} has no turn running in this conversation to read ${file} from`);
-    }
-    const seat = this.seats.get(turn.runner);
-    if (seat === void 0 || seat.send === null) {
-      throw new RunnerAwayError(`runner ${turn.runner}, where the turn runs, is not connected`);
-    }
-    if (!seat.hello.imageReads) {
-      throw new BoardError("INVALID_STATE", `runner ${seat.name}, where the turn runs, cannot read images yet; upgrade it`);
-    }
-    const image = TurnImageSchema.nullable().parse(await this.request(seat, (request) => ({ type: "image", request, read: { turnId: turn.turnId, path: file } }), FILE_TIMEOUT_MS));
+    const { turnId, seat } = this.turnSeat(actor, "imageReads", `read ${file} from`, "read images");
+    const image = TurnImageSchema.nullable().parse(await this.request(seat, (request) => ({ type: "image", request, read: { turnId, path: file } }), FILE_TIMEOUT_MS));
     if (image === null) {
       throw new BoardError("INVALID_STATE", `the turn is no longer running on runner ${seat.name}`);
     }
@@ -12590,6 +13090,28 @@ var RunnerHub = class {
     }
     return Buffer.from(image.content, "base64");
   }
+  /**
+   * Hands an image the board keeps to the runner a citizen's turn runs on, for `read_image`, which
+   * writes it to a folder of that turn's own in the system temp folder, removed when the turn
+   * ends, and answers the file's path there, with the same refusals as `readTurnImage`.
+   */
+  async writeTurnImage(actor, image) {
+    const { turnId, seat } = this.turnSeat(actor, "imageWrites", "open an image in", "open images");
+    const file = TurnImageFileSchema.nullable().parse(await this.request(seat, (request) => ({
+      type: "image_write",
+      request,
+      write: {
+        turnId,
+        id: image.id,
+        type: image.type,
+        content: Buffer.from(image.bytes).toString("base64")
+      }
+    }), FILE_TIMEOUT_MS));
+    if (file === null) {
+      throw new BoardError("INVALID_STATE", `the turn is no longer running on runner ${seat.name}`);
+    }
+    return file.path;
+  }
   /** The models a CLI offers, asked of a connected runner that has it; none when no runner has it. */
   /**
    * The connected runner a model list for `cli` comes from: the first of `prefer` that has the CLI,
@@ -12629,6 +13151,40 @@ var RunnerHub = class {
     await this.board.recordQuota(runner, cli, quota);
     return quota;
   }
+  /**
+   * Whether a turn let through to try a limit with no reset, once its hold ran out, is still running
+   * on the runner, so the CLI's other turns there wait for what it reports: a refusal records a newer
+   * limit, which holds them another half hour, and a turn that ends without one lets them go.
+   */
+  tryRunning(runners2, name, cli, now) {
+    const quota = runners2.find((each) => each.name === name)?.quotas?.[cli];
+    const tried = this.limitTries.get(`${name}/${cli}`);
+    return quota !== void 0 && tried !== void 0 && !tried.ended && tried.observedAt === quota.observedAt && limitLapsed(quota, now);
+  }
+  /**
+   * Asks a runner to read a CLI's quota again while a limit it gave no reset for holds a turn
+   * waiting for it there, at most once per `UNKNOWN_LIMIT_HOLD_MS` for each runner and CLI, so a
+   * reset the read names becomes the hold and a clear read lifts it. Not while the user's pause
+   * holds the CLI there too, nor on a runner from before quota reads; a read that fails changes
+   * nothing, and the hold runs out as it would have.
+   */
+  readAfterLimit(runners2, name, cli, now) {
+    const record = runners2.find((each) => each.name === name);
+    const seat = this.seats.get(name);
+    if (record === void 0 || seat === void 0 || seat.send === null || !seat.hello.quotaReads || !seat.hello.clis.includes(cli) || runnerPause(record, cli) !== void 0 || runnerLimitHold(record, cli, now)?.known !== false) {
+      return;
+    }
+    const key = `${name}/${cli}`;
+    const last = this.limitReads.get(key);
+    if (last !== void 0 && now.getTime() - last < UNKNOWN_LIMIT_HOLD_MS) {
+      return;
+    }
+    this.limitReads.set(key, now.getTime());
+    this.log.info({ runner: name, cli }, "reading a quota limited until an unknown time");
+    this.quota(name, cli).catch((error) => {
+      this.log.warn({ runner: name, cli, error: String(error) }, "could not read a limited quota");
+    });
+  }
   /** Calls `listener` whenever a runner registers, connects, or goes away. */
   onRunnerChange(listener) {
     this.runnerListeners.add(listener);
@@ -12642,29 +13198,41 @@ var RunnerHub = class {
   /**
    * Waits for a runner to acknowledge a job. One that does not in time may be behind a stream that
    * looks open but delivers nothing, as when its machine's network stops passing traffic, so no
-   * more turns go to it until it acknowledges or connects again; the turns it has carry on, since
-   * they report by posts.
+   * more turns go to it until the job is acknowledged, its turn ends, or the runner connects again;
+   * the turns it has carry on, since they report by posts.
    */
   expectAck(seat, job) {
     const previous = seat.unacked.get(job.turnId);
     if (previous !== void 0) {
       clearTimeout(previous.timer);
     }
-    const timer = setTimeout(() => {
-      if (!seat.unacked.has(job.turnId) || seat.unconfirmed || seat.send === null) {
-        return;
-      }
-      seat.unconfirmed = true;
-      this.log.warn({ runner: seat.name, turnId: job.turnId, waitedMs: this.ackTimeoutMs }, "runner has not acknowledged a job; no more turns go to it until it does or reconnects");
-    }, this.ackTimeoutMs);
-    timer.unref?.();
-    seat.unacked.set(job.turnId, { job, timer });
+    const entry = {
+      job,
+      timer: setTimeout(() => {
+        if (seat.unacked.get(job.turnId) !== entry || seat.send === null) {
+          return;
+        }
+        const wasHeld = receiptOverdue(seat);
+        entry.overdue = true;
+        if (!wasHeld) {
+          this.log.warn({ runner: seat.name, turnId: job.turnId, waitedMs: this.ackTimeoutMs }, "runner has not acknowledged a job; no more turns go to it until it does, the turn ends, or it reconnects");
+        }
+      }, this.ackTimeoutMs),
+      overdue: false
+    };
+    entry.timer.unref?.();
+    seat.unacked.set(job.turnId, entry);
   }
-  settle(unacked, turnId) {
-    const entry = unacked.get(turnId);
-    if (entry !== void 0) {
-      clearTimeout(entry.timer);
-      unacked.delete(turnId);
+  /** A job acknowledged, or its turn over: the hold it put on its runner, if any, goes with it. */
+  settle(seat, turnId) {
+    const entry = seat.unacked.get(turnId);
+    if (entry === void 0) {
+      return;
+    }
+    clearTimeout(entry.timer);
+    seat.unacked.delete(turnId);
+    if (entry.overdue && !receiptOverdue(seat)) {
+      this.log.info({ runner: seat.name }, "runner is taking jobs again");
     }
   }
   async detach(seat) {
@@ -12767,6 +13335,25 @@ var RunnerHub = class {
       repo: projectRepo(record)
     };
   }
+  /**
+   * The caller's turn in flight, found by its conversation, and the connected runner it runs on,
+   * which must say `able` in its hello: an image's way to and from the machine a turn runs on.
+   * `where` and `what` say what the caller asked for in a refusal.
+   */
+  turnSeat(actor, able, where, what) {
+    const turn = this.host.runningTurns().find((each) => each.agent === actor.name && each.scope === actor.scope && each.thread === actor.thread && each.channel === actor.channel && each.place === actor.place);
+    if (turn === void 0) {
+      throw new BoardError("INVALID_STATE", `${actor.name} has no turn running in this conversation to ${where}`);
+    }
+    const seat = this.seats.get(turn.runner);
+    if (seat === void 0 || seat.send === null) {
+      throw new RunnerAwayError(`runner ${turn.runner}, where the turn runs, is not connected`);
+    }
+    if (!seat.hello[able]) {
+      throw new BoardError("INVALID_STATE", `runner ${seat.name}, where the turn runs, cannot ${what} yet; upgrade it`);
+    }
+    return { turnId: turn.turnId, seat };
+  }
   assertOwns(runner, turnId) {
     const owner = this.host.runnerOf(turnId);
     if (owner !== void 0 && owner !== runner) {
@@ -12899,6 +13486,7 @@ import { bodyLimit } from "hono/body-limit";
 var ENROLL_BODY_LIMIT_BYTES = 16 * 1024;
 var APP_TOKEN_BODY_LIMIT_BYTES = 16 * 1024;
 var API_BODY_LIMIT_BYTES = 1024 * 1024;
+var IMAGE_BODY_LIMIT_BYTES = IMAGE_LIMIT_BYTES;
 var RUNNER_BODY_LIMIT_BYTES = 8 * 1024 * 1024;
 var RUNNER_ANSWER_LIMIT_BYTES = 16 * 1024 * 1024;
 function limitBody(maxSize) {
@@ -12915,7 +13503,7 @@ function limitBody(maxSize) {
 }
 
 // apps/server/dist/github-auth.js
-import { createHash as createHash3, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
 import { Hono } from "hono";
 import { z as z18 } from "zod";
 var SIGN_IN_TTL_MS = 30 * 24 * 36e5;
@@ -12968,7 +13556,7 @@ function prune(map, now) {
   }
 }
 function provesChallenge(verifier, challenge) {
-  const answer = Buffer.from(createHash3("sha256").update(verifier).digest("base64url"));
+  const answer = Buffer.from(createHash4("sha256").update(verifier).digest("base64url"));
   const expected = Buffer.from(challenge);
   return answer.length === expected.length && timingSafeEqual(answer, expected);
 }
@@ -13203,9 +13791,109 @@ import { Hono as Hono2 } from "hono";
 import { streamSSE } from "hono/streaming";
 
 // apps/server/dist/home-git.js
+import { once } from "node:events";
 import { execa as execa3 } from "execa";
+
+// apps/server/dist/serve.js
+import { serve } from "@hono/node-server";
+var REQUEST_TIMEOUT_MS = 3e5;
+var HEADERS_TIMEOUT_MS = 6e4;
+var deadlines = /* @__PURE__ */ new WeakMap();
+function serveBoard(options, listening) {
+  const timeoutMs = options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
+  return serve({
+    fetch: (request, env) => {
+      const { incoming, outgoing } = env;
+      if (!incoming.complete) {
+        const timer = setTimeout(() => {
+          if (!incoming.complete) {
+            incoming.socket.destroy();
+          }
+        }, timeoutMs);
+        timer.unref();
+        const lift = () => clearTimeout(timer);
+        deadlines.set(request, lift);
+        outgoing.once("close", lift);
+      }
+      return options.fetch(request, env);
+    },
+    port: options.port,
+    hostname: options.hostname,
+    serverOptions: {
+      requestTimeout: 0,
+      headersTimeout: options.headersTimeoutMs ?? HEADERS_TIMEOUT_MS,
+      ...options.connectionsCheckingIntervalMs === void 0 ? {} : { connectionsCheckingInterval: options.connectionsCheckingIntervalMs }
+    }
+  }, listening);
+}
+function liftDeadline(request) {
+  deadlines.get(request)?.();
+  deadlines.delete(request);
+}
+
+// apps/server/dist/home-git.js
 var SMART_PATHS = /* @__PURE__ */ new Set(["/info/refs", "/git-upload-pack", "/git-receive-pack"]);
 var MAX_BYTES = MOVE_PACK_LIMIT_BYTES;
+var IDLE_MS = 5 * 6e4;
+async function feed(body, stdin, limit2, idleMs) {
+  if (body === null) {
+    stdin.end();
+    return "done";
+  }
+  const reader = body.getReader();
+  const waits = new AbortController();
+  let ended = null;
+  const endedAs = () => ended;
+  const end = (why) => {
+    if (ended === null) {
+      ended = why;
+      waits.abort();
+      if (why === "idle" || why === "cut") {
+        reader.cancel().catch(() => void 0);
+      } else {
+        reader.releaseLock();
+      }
+    }
+    return ended;
+  };
+  const timer = setTimeout(() => end("idle"), idleMs);
+  const stopped = () => {
+    end("stopped");
+  };
+  stdin.on("error", stopped);
+  stdin.once("close", stopped);
+  let total = 0;
+  try {
+    for (; ; ) {
+      const next = await reader.read().catch(() => null);
+      const early = endedAs();
+      if (early !== null) {
+        return early;
+      }
+      if (next === null) {
+        return end("cut");
+      }
+      if (next.done) {
+        stdin.end();
+        return "done";
+      }
+      timer.refresh();
+      total += next.value.byteLength;
+      if (total > limit2) {
+        return end("too large");
+      }
+      if (!stdin.write(next.value)) {
+        const drained = await once(stdin, "drain", { signal: waits.signal }).then(() => true, () => false);
+        if (!drained) {
+          return end("stopped");
+        }
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+    stdin.off("close", stopped);
+  }
+}
 function parseCgi(output) {
   const crlf = output.indexOf("\r\n\r\n");
   const lf = output.indexOf("\n\n");
@@ -13233,6 +13921,7 @@ function parseCgi(output) {
 var HomeGit = class {
   pushes = /* @__PURE__ */ new Map();
   serve(input) {
+    liftDeadline(input.request);
     if (input.rest !== "/git-receive-pack") {
       return serveHomeGit(input);
     }
@@ -13247,10 +13936,13 @@ async function serveHomeGit(input) {
     return new Response("not a smart HTTP path", { status: 404 });
   }
   const { request } = input;
-  const body = Buffer.from(await request.arrayBuffer());
-  if (body.length > MAX_BYTES) {
+  const limit2 = input.limitBytes ?? MAX_BYTES;
+  const length = request.headers.get("content-length");
+  const declared = length !== null && /^\d+$/.test(length) ? length : null;
+  if (declared !== null && Number(declared) > limit2) {
     return new Response("pack too large for the board to take", { status: 413 });
   }
+  liftDeadline(request);
   const url = new URL(request.url);
   const env = {
     PATH: process.env["PATH"] ?? "/usr/bin:/bin",
@@ -13261,10 +13953,12 @@ async function serveHomeGit(input) {
     PATH_INFO: `/${input.repository}${input.rest}`,
     QUERY_STRING: url.search.replace(/^\?/, ""),
     CONTENT_TYPE: request.headers.get("content-type") ?? "",
-    CONTENT_LENGTH: String(body.length),
     REMOTE_USER: input.runner,
     REMOTE_ADDR: "127.0.0.1"
   };
+  if (declared !== null) {
+    env["CONTENT_LENGTH"] = declared;
+  }
   const encoding = request.headers.get("content-encoding");
   if (encoding !== null) {
     env["HTTP_CONTENT_ENCODING"] = encoding;
@@ -13273,10 +13967,9 @@ async function serveHomeGit(input) {
   if (protocol !== null) {
     env["HTTP_GIT_PROTOCOL"] = protocol;
   }
-  const result = await execa3("git", ["http-backend"], {
+  const backend = execa3("git", ["http-backend"], {
     env,
     extendEnv: false,
-    input: body,
     encoding: "buffer",
     // The blank line that ends the headers ends the whole answer when the body is empty, as for
     // the 4-byte probe git sends before a pack too large for one post; stripped, it reads as none.
@@ -13284,6 +13977,15 @@ async function serveHomeGit(input) {
     reject: false,
     maxBuffer: MAX_BYTES
   });
+  const fed = await feed(request.body, backend.stdin, limit2, input.idleMs ?? IDLE_MS);
+  if (fed !== "done" && fed !== "stopped") {
+    backend.kill();
+    await backend;
+    return fed === "too large" ? new Response("pack too large for the board to take", { status: 413 }) : new Response(fed === "idle" ? "the request stopped arriving" : "the request was cut", {
+      status: fed === "idle" ? 408 : 400
+    });
+  }
+  const result = await backend;
   if (result.exitCode !== 0 && result.stdout.length === 0) {
     return new Response(`git http-backend failed: ${Buffer.from(result.stderr).toString("utf8")}`, {
       status: 500
@@ -13566,6 +14268,14 @@ function createApp(deps) {
   };
   const api = new Hono3();
   api.use("*", authenticate);
+  api.post("/images", limitBody(IMAGE_BODY_LIMIT_BYTES), async (c) => {
+    if (c.get("actor").role !== USER_ROLE) {
+      throw new BoardError("FORBIDDEN", "only the user posts an image's bytes");
+    }
+    const name = ImageNameSchema.optional().parse(c.req.query("name"));
+    const bytes = new Uint8Array(await c.req.arrayBuffer());
+    return c.json(await board2.postImage(c.get("actor"), bytes, name));
+  });
   api.on(["POST", "PUT", "PATCH", "DELETE"], "*", limitBody(API_BODY_LIMIT_BYTES));
   api.get("/me", (c) => {
     const signIn = board2.signInOf(bearer2(c) ?? "");
@@ -13618,6 +14328,21 @@ function createApp(deps) {
     }
     return c.json(await quotas.read(runner, cli));
   });
+  for (const [verb, paused] of [
+    ["pause", true],
+    ["resume", false]
+  ]) {
+    for (const path12 of [`/runners/:name/${verb}`, `/runners/:name/${verb}/:cli`]) {
+      api.post(path12, async (c) => {
+        const name = NameSchema.parse(c.req.param("name"));
+        const cli = c.req.param("cli");
+        return c.json(await board2.setRunnerPaused(c.get("actor"), name, {
+          paused,
+          ...cli === void 0 ? {} : { cli: CliKindSchema.parse(cli) }
+        }));
+      });
+    }
+  }
   api.post("/runners", async (c) => {
     const body = RunnerBodySchema.parse(await c.req.json());
     return c.json(await board2.addRunner(c.get("actor"), body.name));
@@ -14194,6 +14919,7 @@ var host = new TurnHost({
 var runners = new RunnerHub({ board, host, version: VERSION, log });
 board.watchTurns(() => host.inFlight());
 board.readImagesWith((actor, file) => runners.readTurnImage(actor, file));
+board.openImagesWith((actor, image) => runners.writeTurnImage(actor, image));
 var concurrency = config.concurrency ?? Number.POSITIVE_INFINITY;
 var timings = parseTimings(JSON.parse(process.env["STELLARIS_TIMINGS"] ?? "{}"));
 var scheduler = new Scheduler({ board, runner: runners, log, concurrency, timings });
@@ -14227,7 +14953,7 @@ var app = createApp({
   trustedProxies: config.trustedProxies,
   log
 });
-var server = serve({ fetch: app.fetch, port: config.port, hostname: config.host }, (info) => {
+var server = serveBoard({ fetch: app.fetch, port: config.port, hostname: config.host }, (info) => {
   log.info({
     host: info.address,
     port: info.port,