@kubitnodes/stellaris 0.3.26 → 0.4.0

package/dist/cli/index.js

@@ -2,12 +2,12 @@
 
 // apps/cli/dist/index.js
 import { readFile as readFile5 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 import { Command } from "commander";
 
 // packages/board-core/dist/board.js
-import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir4, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
-import path7 from "node:path";
+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";
+import path8 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
 import { z as z16 } from "zod";
 
@@ -65,7 +65,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 +96,7 @@ var USER_NAME = "user";
 var MEMBER_VERBS = [
   "post_message",
   "upload_image",
+  "read_image",
   "read_inbox",
   "search",
   "open_thread",
@@ -225,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,
@@ -272,6 +279,16 @@ function shortestGapMs(schedule, societyZone, after) {
   }
   return shortest;
 }
+function firesInTask(cron2, task2) {
+  return cron2.scope === task2.project && cron2.thread === task2.id;
+}
+function cronFailure(cron2) {
+  return cron2.lastRun?.outcome === "failed" && cron2.lastRun.caughtUp === void 0 ? cron2.lastRun : null;
+}
+function cronStoppedAt(cron2) {
+  const times = [cron2.paused?.at, cron2.ended?.at, cronFailure(cron2)?.at].filter((at) => at !== void 0);
+  return times.reduce((first, at) => first === null || Date.parse(at) < Date.parse(first) ? at : first, null);
+}
 function nextFire(cron2, societyZone, floorMs = CRON_FLOOR_MS) {
   if (cron2.ended !== void 0 || cron2.paused !== void 0) {
     return null;
@@ -651,6 +668,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,
@@ -669,8 +687,25 @@ 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(runner2, cli) {
+  return runner2.paused ?? runner2.pausedClis?.[cli];
+}
+function heldOn(runners, runner2, cli) {
+  if (runner2 === void 0 || cli === null) {
+    return false;
+  }
+  const record = runners.find((each) => each.name === runner2);
+  return record !== void 0 && runnerPause(record, cli) !== void 0;
+}
 var ProposalKindSchema = z5.enum([
   "role",
   "member",
@@ -1014,7 +1049,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,
@@ -1179,6 +1228,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
   })
 };
 
@@ -1190,6 +1243,7 @@ var BOARD_EVENT_TYPES = [
   "project.configured",
   "project.archived",
   "project.placed",
+  "project.moved",
   "agent.added",
   "agent.configured",
   "agent.placed",
@@ -1229,6 +1283,8 @@ var BOARD_EVENT_TYPES = [
   "user.token_rotated",
   "runner.changed",
   "runner.quota",
+  "runner.paused",
+  "runner.resumed",
   "ops.signal",
   "paused.changed",
   "wake.requested",
@@ -1370,6 +1426,16 @@ 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.
+   */
+  projectMoves: z9.boolean().default(false),
   capabilities: z9.array(z9.string()).default([]),
   /**
    * What the runner's account lacks of the git identity citizens' own commits carry, checked
@@ -1471,8 +1537,19 @@ var TurnJobSchema = z9.object({
   session: z9.string().min(1).nullable(),
   /** The running total the session reported after its last turn, which a resumed session starts from. */
   costSoFarUsd: z9.number().nonnegative(),
+  /**
+   * The session's running usage after its last turn, which a resumed session's own usage is
+   * measured from. Absent when the board holds none for the session, and from a server from before.
+   */
+  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({
@@ -1499,6 +1576,17 @@ var TurnOutcomeSchema = z9.object({
   costUsd: z9.number().nonnegative(),
   /** The session's running total after this turn, for CLIs that report one. */
   sessionCostUsd: z9.number().nonnegative().optional(),
+  /**
+   * The session's running usage after this turn, for CLIs that report one, else the job's
+   * `usageSoFar`. A runner from before never sends it.
+   */
+  sessionUsage: UsageSchema.optional(),
+  /**
+   * The whole input of the turn's latest model call in the session's own thread, cached or not:
+   * how large the session had grown. Sub-agents' calls are left out. A turn that made no call,
+   * and a runner from before, never send it.
+   */
+  contextTokens: z9.number().int().nonnegative().optional(),
   /**
    * The session the CLI used, which differs from the job's for CLIs that assign their own ids. A
    * turn whose CLI never started, because it failed or was stopped first, reports the job's own,
@@ -1646,6 +1734,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 }),
@@ -1658,6 +1753,46 @@ 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;
+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({
+  agent: NameSchema,
+  conversation: WorkspaceConversationSchema.nullable(),
+  uncommitted: z9.number().int().nonnegative(),
+  onNoBranch: z9.number().int().nonnegative()
+});
+var ProjectExportedSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    refs: RepoRefsSchema,
+    bytes: z9.number().int().nonnegative()
+  }),
+  z9.object({
+    ok: z9.literal(false),
+    held: z9.array(HeldWorkSchema),
+    bytes: z9.number().int().nonnegative()
+  })
+]);
+var ProjectImportSchema = z9.object({
+  move: UlidSchema,
+  repo: ProjectRepoSchema,
+  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 });
+var ProjectReleasedSchema = z9.object({
+  worktrees: z9.number().int().nonnegative(),
+  clone: z9.boolean()
+});
+var ProjectMovedSchema = z9.object({
+  project: ProjectSchema,
+  carried: z9.number().int().nonnegative().nullable(),
+  released: z9.object({ ok: z9.boolean(), detail: z9.string() }).nullable()
+});
 var TurnSteerSchema = z9.object({ id: z9.uuid(), text: z9.string().min(1) });
 var RunnerMessageSchema = z9.discriminatedUnion("type", [
   z9.object({ type: z9.literal("turn"), job: TurnJobSchema }),
@@ -1685,6 +1820,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"),
@@ -1694,6 +1838,19 @@ var RunnerMessageSchema = z9.discriminatedUnion("type", [
   }),
   /** Answered with whether the turn was there to stop; it ends `stopped`. */
   z9.object({ type: z9.literal("stop"), request: z9.string().min(1), turnId: UlidSchema }),
+  /**
+   * Answered with a `ProjectExported`. Sent only to runners whose hello says `projectMoves`, as are
+   * the import and the release.
+   */
+  z9.object({ type: z9.literal("export"), request: z9.string().min(1), export: ProjectExportSchema }),
+  /** Answered with a `ProjectImported`. */
+  z9.object({ type: z9.literal("import"), request: z9.string().min(1), import: ProjectImportSchema }),
+  /** Answered with a `ProjectReleased`. */
+  z9.object({
+    type: z9.literal("release"),
+    request: z9.string().min(1),
+    release: ProjectReleaseSchema
+  }),
   /**
    * A conversation ended: the runner removes every citizen's workspace for it but those a turn
    * still uses, and answers with a `SweepResult` naming those it kept for holding work on no branch.
@@ -1737,6 +1894,7 @@ var TriggerKindSchema = z10.enum([
   "closing",
   "cron"
 ]);
+var HeartbeatCauseSchema = z10.enum(["unread", "held", "waiting"]);
 var TriggerSchema = z10.object({
   kind: TriggerKindSchema,
   from: NameSchema.optional(),
@@ -1747,7 +1905,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({
@@ -1808,6 +1968,22 @@ var TurnRecordSchema = z10.object({
    * resumed session starts from it, so the next turn's own cost is measured from here.
    */
   sessionCostUsd: z10.number().nonnegative().optional(),
+  /**
+   * The running usage the CLI reported for the session after this turn, when the runner reports
+   * 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.
+   */
+  contextTokens: z10.number().int().nonnegative().optional(),
   toolCalls: z10.number().int().nonnegative().default(0),
   /** The model the CLI reported for this turn, else the model configured for the agent, else null. */
   model: z10.string().nullable().default(null),
@@ -1821,10 +1997,19 @@ var TurnRecordSchema = z10.object({
   transient: z10.boolean().optional(),
   /** How many turns in a row, this one included, could not resume the session for a `retry`. */
   resumeRetries: z10.number().int().positive().optional(),
-  /** Whether the server dropped the conversation's session after this turn, which the next starts anew. */
+  /**
+   * Whether the server dropped the conversation's session after this turn, which the next starts
+   * anew: one its CLI could not resume, or a society role's home after a reflection completed.
+   */
   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,
@@ -1866,6 +2051,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. */
@@ -1936,7 +2123,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);
@@ -1950,12 +2137,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(),
@@ -2034,11 +2228,17 @@ var TokenUseSchema = z12.object({
 // packages/shared/dist/config.js
 import { z as z13 } from "zod";
 var LogLevelSchema = z13.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
+var AppleAppIdSchema = z13.string().regex(/^[A-Z0-9]{10}\.[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*$/, "not <team id>.<bundle id>");
 var GithubSignInSchema = z13.object({
   clientId: z13.string().min(1),
   clientSecret: z13.string().min(1),
   /** Logins, lowercased; GitHub logins are case-insensitive. */
-  users: z13.array(z13.string().min(1)).min(1)
+  users: z13.array(z13.string().min(1)).min(1),
+  /**
+   * The iOS app that may sign in, which Apple's association file names so that only it can take the
+   * board's `https` landing; null when no app signs in.
+   */
+  appleAppId: AppleAppIdSchema.nullable()
 });
 var ServerConfigSchema = z13.object({
   dataDir: z13.string().min(1),
@@ -2084,7 +2284,7 @@ var RunnerConfigSchema = z13.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.26";
+var STELLARIS_VERSION = "0.4.0";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -2776,6 +2976,41 @@ function filesOf(lines, status) {
   return [...files.values()];
 }
 
+// packages/board-core/dist/moves.js
+import { mkdir as mkdir4, rm as rm2 } from "node:fs/promises";
+import path5 from "node:path";
+import { execa as execa2 } from "execa";
+var MoveRepos = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  /** Makes the move's empty repository, which checks every object a push brings, and answers its path. */
+  async open(dir) {
+    await mkdir4(this.root, { recursive: true });
+    await git2(["init", "--quiet", "--bare", dir], this.root);
+    await git2(["config", "receive.fsckObjects", "true"], dir);
+    return dir;
+  }
+  async drop(dir) {
+    await rm2(path5.resolve(this.root, dir), { recursive: true, force: true });
+  }
+  /** Removes every move's repository, as the server starts: a move never survives a restart. */
+  async clear() {
+    await rm2(this.root, { recursive: true, force: true });
+  }
+};
+async function git2(args, cwd) {
+  const result = await execa2("git", args, {
+    cwd,
+    reject: false,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`git ${args[0] ?? ""} failed: ${result.stderr.trim()}`);
+  }
+}
+
 // packages/board-core/dist/mentions.js
 import vm from "node:vm";
 var MENTION_PARSE_MS = 500;
@@ -2810,7 +3045,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(),
@@ -2910,13 +3146,12 @@ function computeMetrics(input) {
         const nothing = actions === 0 ? 1 : 0;
         turns += 1;
         idle += nothing;
-        for (const [rows, key] of [
-          [turnRows, turn2.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 } = turn2.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": {
@@ -3072,7 +3307,10 @@ function computeMetrics(input) {
       turns,
       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(([agent2, row]) => ({ agent: agent2, role: citizens.get(agent2)?.role ?? null, ...row })).toSorted((a, b) => b.idle - a.idle || b.turns - a.turns)
     },
     sentBack: {
@@ -3132,6 +3370,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(),
@@ -3189,121 +3429,121 @@ var Mutex = class {
 };
 
 // packages/board-core/dist/paths.js
-import path5 from "node:path";
+import path6 from "node:path";
 var BoardPaths = class {
   dataDir;
   constructor(dataDir) {
-    this.dataDir = path5.resolve(dataDir);
+    this.dataDir = path6.resolve(dataDir);
   }
   // Board projection, also the storage of record; only the core library writes it.
   get board() {
-    return path5.join(this.dataDir, "board");
+    return path6.join(this.dataDir, "board");
   }
   get society() {
-    return path5.join(this.board, "society");
+    return path6.join(this.board, "society");
   }
   societyFile() {
-    return path5.join(this.society, "society.md");
+    return path6.join(this.society, "society.md");
   }
   societyChannels() {
-    return path5.join(this.society, "channels");
+    return path6.join(this.society, "channels");
   }
   societyChannel(name) {
-    return path5.join(this.societyChannels(), name);
+    return path6.join(this.societyChannels(), name);
   }
   /** Threads whose channel is a society channel; project channels' threads live under the project. */
   societyThreads() {
-    return path5.join(this.society, "threads");
+    return path6.join(this.society, "threads");
   }
   societyKnowledge() {
-    return path5.join(this.society, "knowledge");
+    return path6.join(this.society, "knowledge");
   }
   societyKnowledgeFile(topic) {
-    return path5.join(this.societyKnowledge(), `${topic}.md`);
+    return path6.join(this.societyKnowledge(), `${topic}.md`);
   }
   /** Skills promoted to the society, one directory per skill holding SKILL.md. */
   societySkills() {
-    return path5.join(this.society, "skills");
+    return path6.join(this.society, "skills");
   }
   societySkill(name) {
-    return path5.join(this.societySkills(), name);
+    return path6.join(this.societySkills(), name);
   }
   societySkillFile(name) {
-    return path5.join(this.societySkill(name), "SKILL.md");
+    return path6.join(this.societySkill(name), "SKILL.md");
   }
   roles() {
-    return path5.join(this.society, "roles");
+    return path6.join(this.society, "roles");
   }
   role(name) {
-    return path5.join(this.roles(), `${name}.md`);
+    return path6.join(this.roles(), `${name}.md`);
   }
   proposals() {
-    return path5.join(this.society, "proposals");
+    return path6.join(this.society, "proposals");
   }
   proposal(id) {
-    return path5.join(this.proposals(), `${id}.md`);
+    return path6.join(this.proposals(), `${id}.md`);
   }
   /** A skill proposal's folder, as the board took it from its proposer's home. */
   proposalFiles(id) {
-    return path5.join(this.proposals(), id);
+    return path6.join(this.proposals(), id);
   }
   decisions() {
-    return path5.join(this.society, "decisions");
+    return path6.join(this.society, "decisions");
   }
   decision(id) {
-    return path5.join(this.decisions(), `${id}.md`);
+    return path6.join(this.decisions(), `${id}.md`);
   }
   runners() {
-    return path5.join(this.society, "runners");
+    return path6.join(this.society, "runners");
   }
   runner(name) {
-    return path5.join(this.runners(), `${name}.md`);
+    return path6.join(this.runners(), `${name}.md`);
   }
   members() {
-    return path5.join(this.society, "members");
+    return path6.join(this.society, "members");
   }
   /** Crons, one file each with its note as the body; ended ones stay. */
   crons() {
-    return path5.join(this.society, "crons");
+    return path6.join(this.society, "crons");
   }
   cron(id) {
-    return path5.join(this.crons(), `${id}.md`);
+    return path6.join(this.crons(), `${id}.md`);
   }
   member(name) {
-    return path5.join(this.members(), `${name}.md`);
+    return path6.join(this.members(), `${name}.md`);
   }
   projects() {
-    return path5.join(this.board, "projects");
+    return path6.join(this.board, "projects");
   }
   project(slug) {
-    return path5.join(this.projects(), slug);
+    return path6.join(this.projects(), slug);
   }
   projectFile(slug) {
-    return path5.join(this.project(slug), "project.md");
+    return path6.join(this.project(slug), "project.md");
   }
   projectChannels(slug) {
-    return path5.join(this.project(slug), "channels");
+    return path6.join(this.project(slug), "channels");
   }
   projectChannel(slug, name) {
-    return path5.join(this.projectChannels(slug), name);
+    return path6.join(this.projectChannels(slug), name);
   }
   threads(slug) {
-    return path5.join(this.project(slug), "threads");
+    return path6.join(this.project(slug), "threads");
   }
   tasks(slug) {
-    return path5.join(this.project(slug), "tasks");
+    return path6.join(this.project(slug), "tasks");
   }
   task(slug, id) {
-    return path5.join(this.tasks(slug), `${id}.md`);
+    return path6.join(this.tasks(slug), `${id}.md`);
   }
   projectKnowledge(slug) {
-    return path5.join(this.project(slug), "knowledge");
+    return path6.join(this.project(slug), "knowledge");
   }
   projectKnowledgeFile(slug, topic) {
-    return path5.join(this.projectKnowledge(slug), `${topic}.md`);
+    return path6.join(this.projectKnowledge(slug), `${topic}.md`);
   }
   dashboard(slug) {
-    return path5.join(this.project(slug), "dashboard.md");
+    return path6.join(this.project(slug), "dashboard.md");
   }
   channelDir(ref) {
     const parsed = parseChannelRef(ref);
@@ -3316,57 +3556,57 @@ var BoardPaths = class {
   }
   /** A thread's record, `<id>.md`, beside the directory of its messages, `<id>/`. */
   threadFile(threads, id) {
-    return path5.join(threads, `${id}.md`);
+    return path6.join(threads, `${id}.md`);
   }
   threadMessages(threads, id) {
-    return path5.join(threads, id);
+    return path6.join(threads, id);
   }
   messageFile(dir, id, author) {
-    return path5.join(dir, `${id}-${author}.md`);
+    return path6.join(dir, `${id}-${author}.md`);
   }
   // Agent homes: authored by the agent, source of truth on the board server.
   agents() {
-    return path5.join(this.dataDir, "agents");
+    return path6.join(this.dataDir, "agents");
   }
   agent(name) {
-    return path5.join(this.agents(), name);
+    return path6.join(this.agents(), name);
   }
   agentFile(name) {
-    return path5.join(this.agent(name), "agent.json");
+    return path6.join(this.agent(name), "agent.json");
   }
   agentRole(name) {
-    return path5.join(this.agent(name), "role.md");
+    return path6.join(this.agent(name), "role.md");
   }
   agentProfile(name) {
-    return path5.join(this.agent(name), "profile.md");
+    return path6.join(this.agent(name), "profile.md");
   }
   agentMemory(name) {
-    return path5.join(this.agent(name), "memory");
+    return path6.join(this.agent(name), "memory");
   }
   agentMemoryCore(name) {
-    return path5.join(this.agentMemory(name), "core.md");
+    return path6.join(this.agentMemory(name), "core.md");
   }
   /** Transcripts of the agent's finished turns, one JSON line per step. */
   agentTurns(name) {
-    return path5.join(this.agent(name), "turns");
+    return path6.join(this.agent(name), "turns");
   }
   agentTranscript(name, turnId) {
-    return path5.join(this.agentTurns(name), `${turnId}.jsonl`);
+    return path6.join(this.agentTurns(name), `${turnId}.jsonl`);
   }
   agentSkills(name) {
-    return path5.join(this.agent(name), "skills");
+    return path6.join(this.agent(name), "skills");
   }
   agentSkill(name, skill2) {
-    return path5.join(this.agentSkills(name), skill2);
+    return path6.join(this.agentSkills(name), skill2);
   }
   agentSkillFile(name, skill2) {
-    return path5.join(this.agentSkill(name, skill2), "SKILL.md");
+    return path6.join(this.agentSkill(name, skill2), "SKILL.md");
   }
   agentProjects(name) {
-    return path5.join(this.agent(name), "projects");
+    return path6.join(this.agent(name), "projects");
   }
   agentProject(name, slug) {
-    return path5.join(this.agentProjects(name), slug);
+    return path6.join(this.agentProjects(name), slug);
   }
   /**
    * A thread's, a channel's, or, in the society scope, a project's conversation's session and last
@@ -3374,46 +3614,56 @@ var BoardPaths = class {
    */
   agentConversation(name, slug, part) {
     if (part.startsWith("#")) {
-      return path5.join(this.agentProject(name, slug), "channels", part.slice(1));
+      return path6.join(this.agentProject(name, slug), "channels", part.slice(1));
     }
-    return part.startsWith("~") ? path5.join(this.agentProject(name, slug), "places", part.slice(1)) : path5.join(this.agentProject(name, slug), "threads", part);
+    return part.startsWith("~") ? path6.join(this.agentProject(name, slug), "places", part.slice(1)) : path6.join(this.agentProject(name, slug), "threads", part);
   }
   agentCursors(name) {
-    return path5.join(this.agent(name), "cursors.json");
+    return path6.join(this.agent(name), "cursors.json");
   }
   events() {
-    return path5.join(this.dataDir, "events");
+    return path6.join(this.dataDir, "events");
   }
   eventLog() {
-    return path5.join(this.events(), "log.jsonl");
+    return path6.join(this.events(), "log.jsonl");
   }
   /** Images citizens uploaded, by id: outside the projection, which every runner mirrors. */
   images() {
-    return path5.join(this.dataDir, "images");
+    return path6.join(this.dataDir, "images");
   }
   image(id) {
-    return path5.join(this.images(), id);
+    return path6.join(this.images(), id);
+  }
+  /**
+   * The repositories projects travel through between runners, one per move while it runs:
+   * outside the projection, which every runner mirrors, and served only to the move's runners.
+   */
+  moves() {
+    return path6.join(this.dataDir, "moves");
+  }
+  move(id) {
+    return path6.join(this.moves(), `${id}.git`);
   }
   state() {
-    return path5.join(this.dataDir, "state");
+    return path6.join(this.dataDir, "state");
   }
   pausedFile() {
-    return path5.join(this.state(), "paused.json");
+    return path6.join(this.state(), "paused.json");
   }
   /** Removed knowledge topics, set aside outside the projection, by scope. */
   removedKnowledge(scope) {
-    return path5.join(this.state(), "removed-knowledge", scope);
+    return path6.join(this.state(), "removed-knowledge", scope);
   }
   /** Skills removed from the society, set aside outside the projection, one directory per removal. */
   removedSkills() {
-    return path5.join(this.state(), "removed-skills");
+    return path6.join(this.state(), "removed-skills");
   }
 };
 
 // packages/board-core/dist/skill-folder.js
 import { constants } from "node:fs";
 import { lstat, open as open2, readdir as readdir3, readlink, realpath } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 var SKILL_TEXT_LIMIT_CHARS = 1e5;
 var SKILL_TEXT_LIMIT_BYTES = SKILL_TEXT_LIMIT_CHARS * 4;
 function skillFileText(bytes) {
@@ -3424,8 +3674,8 @@ function skillFileText(bytes) {
   };
 }
 function inside(root, file) {
-  const relative = path6.relative(root, file);
-  return relative !== ".." && !relative.startsWith(`..${path6.sep}`) && !path6.isAbsolute(relative);
+  const relative = path7.relative(root, file);
+  return relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
 }
 async function handleInside(root, handle) {
   if (process.platform !== "linux") {
@@ -3435,7 +3685,7 @@ async function handleInside(root, handle) {
   return file !== null && inside(root, file);
 }
 async function walk(root, prefix, found) {
-  const entries = await readdir3(path6.join(root, ...prefix === "" ? [] : prefix.split("/")), {
+  const entries = await readdir3(path7.join(root, ...prefix === "" ? [] : prefix.split("/")), {
     withFileTypes: true
   }).catch(() => []);
   for (const entry of entries.toSorted((a, b) => a.name < b.name ? -1 : 1)) {
@@ -3456,7 +3706,7 @@ async function walk(root, prefix, found) {
 async function readEntry(root, relative) {
   let real;
   try {
-    real = await realpath(path6.join(root, ...relative.split("/")));
+    real = await realpath(path7.join(root, ...relative.split("/")));
   } catch {
     return null;
   }
@@ -3547,7 +3797,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({}),
@@ -3619,6 +3872,9 @@ function skillFolderOf(proposal2) {
 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$/, "");
 }
@@ -3758,6 +4014,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();
@@ -3772,9 +4029,11 @@ var Board = class _Board {
   signIns = /* @__PURE__ */ new Map();
   files = new FileTree();
   homes;
+  moves;
   constructor(dataDir, options) {
     this.paths = new BoardPaths(dataDir);
-    this.homes = new HomeRepos(path7.join(this.paths.state(), "home-hooks"));
+    this.homes = new HomeRepos(path8.join(this.paths.state(), "home-hooks"));
+    this.moves = new MoveRepos(this.paths.moves());
     this.leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.events = new EventLog(this.paths.eventLog(), () => this.newId(), this.now);
@@ -3800,16 +4059,20 @@ var Board = class _Board {
     await board.loadRunnerTokens();
     await board.loadSignIns();
     await board.homes.installHooks();
+    await board.moves.clear();
     return 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 file = path7.join(this.paths.state(), "alignments.json");
+    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));
     if (pending.length === 0) {
@@ -3820,6 +4083,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());
@@ -4017,7 +4291,7 @@ ${charter.purpose}
     });
   }
   signInsFile() {
-    return path7.join(this.paths.state(), "sign-ins.json");
+    return path8.join(this.paths.state(), "sign-ins.json");
   }
   async readSignIns() {
     const file = this.signInsFile();
@@ -4114,7 +4388,7 @@ ${charter.purpose}
     const files = await listFiles(this.paths.tasks(project2));
     const tasks = [];
     for (const file of files) {
-      const doc = await readMarkdown(path7.join(this.paths.tasks(project2), file), TaskFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(this.paths.tasks(project2), file), TaskFrontmatterSchema);
       tasks.push({ ...doc.data, body: doc.body });
     }
     return tasks;
@@ -4133,7 +4407,7 @@ ${charter.purpose}
     const files = await listFiles(this.paths.proposals());
     const proposals = [];
     for (const file of files) {
-      const doc = await readMarkdown(path7.join(this.paths.proposals(), file), ProposalFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(this.paths.proposals(), file), ProposalFrontmatterSchema);
       proposals.push({ ...doc.data, body: doc.body });
     }
     return proposals;
@@ -4160,7 +4434,7 @@ ${charter.purpose}
   async listMembers() {
     const members = [];
     for (const file of await listFiles(this.paths.members())) {
-      const doc = await readMarkdown(path7.join(this.paths.members(), file), MemberSchema);
+      const doc = await readMarkdown(path8.join(this.paths.members(), file), MemberSchema);
       members.push({ ...doc.data, profile: doc.body });
     }
     return members;
@@ -4179,7 +4453,7 @@ ${charter.purpose}
     const dir = project2 === null ? this.paths.societyKnowledge() : this.paths.projectKnowledge(project2);
     const topics = [];
     for (const file of await listFiles(dir)) {
-      topics.push(await this.knowledgeAt(path7.join(dir, file), project2, file.replace(/\.md$/, "")));
+      topics.push(await this.knowledgeAt(path8.join(dir, file), project2, file.replace(/\.md$/, "")));
     }
     return topics;
   }
@@ -4209,7 +4483,7 @@ ${charter.purpose}
     const aside = this.paths.removedKnowledge(project2 ?? SOCIETY_SCOPE);
     let highest = 0;
     for (const file of (await listFiles(aside)).filter((name) => name.startsWith(`${topic}.`))) {
-      const copy = await this.knowledgeAt(path7.join(aside, file), project2, topic);
+      const copy = await this.knowledgeAt(path8.join(aside, file), project2, topic);
       highest = Math.max(highest, copy.revision);
     }
     return highest;
@@ -4225,7 +4499,7 @@ ${charter.purpose}
   async listSkillsIn(dir, scope) {
     const skills = [];
     for (const entry of await listDirs(dir)) {
-      const file = path7.join(dir, entry, "SKILL.md");
+      const file = path8.join(dir, entry, "SKILL.md");
       if (!await exists(file)) {
         continue;
       }
@@ -4315,7 +4589,7 @@ ${charter.purpose}
         if (!wanted.delete(file.slice(0, 26))) {
           continue;
         }
-        const { data } = await readMarkdown(path7.join(dir, file), MessageFrontmatterSchema);
+        const { data } = await readMarkdown(path8.join(dir, file), MessageFrontmatterSchema);
         found.push(MessageRefSchema.parse(data));
       }
       if (wanted.size === 0) {
@@ -4347,7 +4621,7 @@ ${charter.purpose}
         if (!file.endsWith(".md")) {
           continue;
         }
-        const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
+        const doc = await readMarkdown(path8.join(threads, file), ThreadFrontmatterSchema);
         if (doc.data.state !== "open") {
           continue;
         }
@@ -4374,7 +4648,7 @@ ${charter.purpose}
     const all = [];
     for (const threads of await this.threadScopes()) {
       for (const file of await listFiles(threads)) {
-        const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
+        const doc = await readMarkdown(path8.join(threads, file), ThreadFrontmatterSchema);
         const messages = await listFiles(this.paths.threadMessages(threads, doc.data.id));
         const last = messages.at(-1);
         all.push({
@@ -4587,6 +4861,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
@@ -4621,8 +4935,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") {
@@ -4630,17 +4945,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, ...turn2 } = parsed.data;
+        const start = turn2.turnId === void 0 ? void 0 : starts.get(turn2.turnId);
+        if (turn2.turnId !== void 0) {
+          starts.delete(turn2.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 }
+          ...turn2,
+          ...heartbeat === void 0 ? {} : { heartbeat },
+          ...start === void 0 ? {} : { startedAt: start.ts }
         });
       }
     }
@@ -4670,14 +4987,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 runners;
       for (const project2 of await listDirs(this.paths.projects())) {
+        let place;
         for (const task2 of await this.listTasks(project2)) {
-          if (task2.status === "claimed" && this.leaseExpired(task2, now)) {
+          if (task2.status !== "claimed") {
+            continue;
+          }
+          crons ??= await this.listCrons();
+          runners ??= await this.listRunners();
+          place ??= await this.readProject(project2);
+          const kept = latestLease(this.keptLease(task2, crons, now), await this.pausedLease(task2, runners, place.runner, now));
+          if (kept !== null) {
+            await this.writeTask(project2, { ...task2, leaseExpiresAt: kept });
+            continue;
+          }
+          if (this.leaseExpired(task2, now)) {
             const released = await this.writeTask(project2, {
               ...task2,
               status: "open",
@@ -4746,20 +5080,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;
@@ -4768,12 +5106,13 @@ ${DASHBOARD_LINE}
       }
       const thread2 = threadOfPart(part);
       if (thread2 !== void 0) {
-        let ended = closed.get(thread2);
-        if (ended === void 0) {
-          ended = (await this.tryFindThread(thread2))?.thread.state === "closed";
-          closed.set(thread2, ended);
+        let counted = threadCounts.get(thread2);
+        if (counted === void 0) {
+          counted = await this.threadCount(actor, thread2);
+          threadCounts.set(thread2, counted);
         }
-        if (ended) {
+        const forReader = counted === "every" || counted !== "none" && asked === true || counted === "asks-user" && message.mentions.includes(USER_NAME);
+        if (!forReader) {
           continue;
         }
       }
@@ -4926,7 +5265,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);
@@ -4969,7 +5308,7 @@ ${task2.body}`;
         }
       }
       for (const file of await listFiles(this.paths.projectKnowledge(project2))) {
-        const content = await readFile4(path7.join(this.paths.projectKnowledge(project2), file), "utf8");
+        const content = await readFile4(path8.join(this.paths.projectKnowledge(project2), file), "utf8");
         if (content.toLowerCase().includes(needle)) {
           hits.push({
             kind: "knowledge",
@@ -4990,7 +5329,7 @@ ${task2.body}`;
       shared.push({
         kind: "knowledge",
         ref: `society/knowledge/${file}`,
-        file: path7.join(this.paths.societyKnowledge(), file)
+        file: path8.join(this.paths.societyKnowledge(), file)
       });
     }
     for (const skill2 of await this.listSocietySkills()) {
@@ -5003,7 +5342,7 @@ ${task2.body}`;
       shared.push({
         kind: "memory",
         ref: `memory/${file}`,
-        file: path7.join(this.paths.agentMemory(actor.name), file)
+        file: path8.join(this.paths.agentMemory(actor.name), file)
       });
     }
     for (const entry of shared) {
@@ -5092,8 +5431,8 @@ ${current.body}`);
         removedAt: this.now().toISOString()
       });
       const aside = this.paths.removedKnowledge(args.project ?? SOCIETY_SCOPE);
-      await mkdir4(aside, { recursive: true });
-      await rename3(file, path7.join(aside, `${args.topic}.${removed.removedAt.replaceAll(":", "-")}.md`));
+      await mkdir5(aside, { recursive: true });
+      await rename3(file, path8.join(aside, `${args.topic}.${removed.removedAt.replaceAll(":", "-")}.md`));
       await this.events.append("knowledge.removed", actor.name, {
         topic: args.topic,
         project: args.project
@@ -5140,8 +5479,8 @@ ${current.body}`);
         removedAt: this.now().toISOString()
       });
       const aside = this.paths.removedSkills();
-      await mkdir4(aside, { recursive: true });
-      await rename3(this.paths.societySkill(args.name), path7.join(aside, `${args.name}.${removed.removedAt.replaceAll(":", "-")}`));
+      await mkdir5(aside, { recursive: true });
+      await rename3(this.paths.societySkill(args.name), path8.join(aside, `${args.name}.${removed.removedAt.replaceAll(":", "-")}`));
       await this.events.append("skill.removed", actor.name, {
         name: args.name,
         reason: args.reason
@@ -5203,12 +5542,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();
@@ -5218,15 +5575,37 @@ ${current.body}`);
         type,
         size: bytes.byteLength
       });
-      const name = path7.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));
@@ -5244,7 +5623,7 @@ ${current.body}`);
   async listCrons() {
     const crons = [];
     for (const file of await listFiles(this.paths.crons())) {
-      crons.push(await this.readCronFile(path7.join(this.paths.crons(), file)));
+      crons.push(await this.readCronFile(path8.join(this.paths.crons(), file)));
     }
     return crons;
   }
@@ -5572,6 +5951,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
@@ -5591,7 +5977,7 @@ ${current.body}`);
   async openThreadIds(dir, keep) {
     const ids = /* @__PURE__ */ new Set();
     for (const file of await listFiles(dir)) {
-      const doc = await readMarkdown(path7.join(dir, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(dir, file), ThreadFrontmatterSchema);
       if (doc.data.state === "open" && keep({ ...doc.data, body: doc.body })) {
         ids.add(doc.data.id);
       }
@@ -5599,12 +5985,12 @@ ${current.body}`);
     return ids;
   }
   /**
-   * Refuses to archive a project while a turn runs in it, in a citizen's conversation of its
-   * channels in the society scope, or in a thread its archive closes.
+   * Refuses to archive or move a project while a turn runs in it, in a citizen's conversation of
+   * its channels in the society scope, or in one of its open threads.
    */
-  async assertProjectQuiet(actor, slug) {
+  async assertProjectQuiet(actor, slug, what = `project ${slug} cannot be archived`) {
     const threads = await this.openThreadIds(this.paths.threads(slug), () => true);
-    this.assertNoTurnCut(actor, `project ${slug} cannot be archived`, (turn2) => turn2.scope === slug || turn2.place === slug || turn2.thread !== void 0 && threads.has(turn2.thread));
+    this.assertNoTurnCut(actor, what, (turn2) => turn2.scope === slug || turn2.place === slug || turn2.thread !== void 0 && threads.has(turn2.thread));
   }
   async closeThread(actor, input) {
     const args = VerbInputs.close_thread.parse(input);
@@ -6407,6 +6793,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)}`);
     }
@@ -6571,7 +6959,7 @@ ${rationale}`}`);
     return part === void 0 ? this.paths.agentProject(agent2, scope) : this.paths.agentConversation(agent2, scope, part);
   }
   async readSessions(agent2, project2, part) {
-    const file = path7.join(this.sessionDir(agent2, project2, part), "sessions.json");
+    const file = path8.join(this.sessionDir(agent2, project2, part), "sessions.json");
     return await exists(file) ? readJson(file, SessionsFileSchema) : {};
   }
   /**
@@ -6582,7 +6970,7 @@ ${rationale}`}`);
     await this.mutex.run(async () => {
       const dir = this.sessionDir(agent2, project2, part);
       await ensureDir(dir);
-      const file = path7.join(dir, "sessions.json");
+      const file = path8.join(dir, "sessions.json");
       const current = await exists(file) ? await readJson(file, SessionsFileSchema) : {};
       const kept = current.runner === void 0 || current.runner === runner2 ? current : {};
       await writeJson(file, { ...kept, [cli]: sessionId, runner: runner2 });
@@ -6594,7 +6982,7 @@ ${rationale}`}`);
    */
   async dropSession(agent2, project2, cli, sessionId, part) {
     return this.mutex.run(async () => {
-      const file = path7.join(this.sessionDir(agent2, project2, part), "sessions.json");
+      const file = path8.join(this.sessionDir(agent2, project2, part), "sessions.json");
       if (!await exists(file)) {
         return false;
       }
@@ -6609,7 +6997,7 @@ ${rationale}`}`);
   }
   /** The last turn of one conversation: the scope's home, a channel's, a project's, or a thread's. */
   async readLastTurn(agent2, project2, part) {
-    const file = path7.join(this.sessionDir(agent2, project2, part), "last-turn.json");
+    const file = path8.join(this.sessionDir(agent2, project2, part), "last-turn.json");
     return await exists(file) ? readJson(file, TurnRecordSchema) : null;
   }
   /** The latest turn a citizen took in a scope, in any of its conversations there. */
@@ -6617,9 +7005,9 @@ ${rationale}`}`);
     let latest = await this.readLastTurn(agent2, project2);
     const place = this.paths.agentProject(agent2, project2);
     const parts = [
-      ...await listDirs(path7.join(place, "threads")),
-      ...(await listDirs(path7.join(place, "channels"))).map((name) => `#${name}`),
-      ...(await listDirs(path7.join(place, "places"))).map((name) => `~${name}`)
+      ...await listDirs(path8.join(place, "threads")),
+      ...(await listDirs(path8.join(place, "channels"))).map((name) => `#${name}`),
+      ...(await listDirs(path8.join(place, "places"))).map((name) => `~${name}`)
     ];
     for (const part of parts) {
       const turn2 = await this.readLastTurn(agent2, project2, part);
@@ -6642,6 +7030,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
       });
@@ -6664,6 +7053,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 },
@@ -6681,10 +7075,12 @@ ${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,
         ...parsed.usage === null ? {} : { usage: parsed.usage },
+        ...parsed.contextTokens === void 0 ? {} : { contextTokens: parsed.contextTokens },
         toolCalls: parsed.toolCalls,
         model: parsed.model,
         summary: parsed.status?.summary ?? null,
@@ -6803,6 +7199,27 @@ ${rationale}`}`);
       failures: outcome === "failed" ? cron2.failures + 1 : outcome === "completed" ? 0 : cron2.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 cron2 = await this.readCron(shown.cron);
+    const failure = cronFailure(cron2);
+    if (failure === null || failure.turnId !== shown.turnId) {
+      return;
+    }
+    await this.writeCron({
+      ...cron2,
+      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
@@ -6885,11 +7302,11 @@ ${rationale}`}`);
   }
   /** Small named state files under data/state, for cursors the scheduler must keep across restarts. */
   async readState(name, schema, fallback) {
-    const file = path7.join(this.paths.state(), `${name}.json`);
+    const file = path8.join(this.paths.state(), `${name}.json`);
     return await exists(file) ? readJson(file, schema) : fallback;
   }
   async writeState(name, value) {
-    await this.mutex.run(() => writeJson(path7.join(this.paths.state(), `${name}.json`), value));
+    await this.mutex.run(() => writeJson(path8.join(this.paths.state(), `${name}.json`), value));
   }
   /** The project's dashboard, empty at revision 0 when it has none. */
   async readDashboard(slug) {
@@ -6920,7 +7337,7 @@ ${rationale}`}`);
   async listRunners() {
     const runners = [];
     for (const file of await listFiles(this.paths.runners())) {
-      runners.push((await readMarkdown(path7.join(this.paths.runners(), file), RunnerSchema)).data);
+      runners.push((await readMarkdown(path8.join(this.paths.runners(), file), RunnerSchema)).data);
     }
     return runners;
   }
@@ -6972,7 +7389,7 @@ ${rationale}`}`);
     return this.runnerTokens.get(hashToken(token)) ?? null;
   }
   runnerTokensFile() {
-    return path7.join(this.paths.state(), "runners.json");
+    return path8.join(this.paths.state(), "runners.json");
   }
   async readRunnerTokens() {
     const file = this.runnerTokensFile();
@@ -6986,7 +7403,8 @@ ${rationale}`}`);
   }
   /**
    * Places a project on the runner that will hold its repository, unless it already lives on one,
-   * and returns where it lives. Placement is once: every later turn of the project goes there.
+   * and returns where it lives. Placement is once: every later turn of the project goes there,
+   * until the user moves the project (`recordProjectMove`).
    */
   async placeProject(slug, runner2) {
     return this.mutex.run(async () => {
@@ -7028,12 +7446,12 @@ ${rationale}`}`);
         }
         const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
         if (entry.isDirectory()) {
-          await walk2(path7.join(dir, entry.name), relative);
+          await walk2(path8.join(dir, entry.name), relative);
           continue;
         }
         const file = entry.isFile() ? conflictCopyOf(relative) : null;
         if (file !== null) {
-          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path7.join(home, relative)).catch(() => null))?.mtime.toISOString();
+          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path8.join(home, relative)).catch(() => null))?.mtime.toISOString();
           if (since !== void 0) {
             found.push({ path: relative, file, since });
           }
@@ -7107,6 +7525,74 @@ ${rationale}`}`);
       return next;
     });
   }
+  /**
+   * The board's half of moving a project to another runner, which only the user does, checked
+   * before anything travels and while the hub holds the project's turns: the project is active and
+   * lives on a runner other than `to`, which the board knows; no task there is landing, since its
+   * landing runs on the old runner; and no turn runs in the project. Tasks in play move with their
+   * branches, so the answer lists them for the capabilities the new runner must offer.
+   */
+  async prepareProjectMove(actor, slug, to) {
+    this.assertUser(actor, "only the user may move a project to another runner");
+    const runner2 = NameSchema.parse(to);
+    return this.mutex.run(async () => {
+      const project2 = await this.readActiveProject(slug);
+      const from = project2.runner;
+      if (from === void 0) {
+        throw new BoardError("INVALID_STATE", `project ${slug} lives on no runner yet; its first turn places it`);
+      }
+      if (from === runner2) {
+        throw new BoardError("INVALID_STATE", `project ${slug} already lives on ${runner2}`);
+      }
+      await this.readRunner(runner2);
+      const inPlay = (await this.listTasks(slug)).filter((task2) => task2.status === "open" || task2.status === "claimed");
+      const landing = inPlay.filter((task2) => task2.completing);
+      if (landing.length > 0) {
+        throw new BoardError("INVALID_STATE", `project ${slug} cannot be moved while ${landing.length} task(s) land on ${from} (${landing.map((task2) => task2.id).join(", ")}); move it once they have landed`);
+      }
+      await this.assertProjectQuiet(actor, slug, `project ${slug} cannot be moved`);
+      return { project: { ...project2, runner: from }, inPlay };
+    });
+  }
+  /**
+   * Records that a project moved, once its new runner holds every branch its old one had, or with
+   * nothing carried when the user moved it while the old runner was away: every later turn of
+   * the project goes to `to`. Refused when the project was archived or moved meanwhile.
+   */
+  async recordProjectMove(actor, move) {
+    this.assertUser(actor, "only the user may move a project to another runner");
+    return this.mutex.run(async () => {
+      const current = await this.readActiveProject(move.slug);
+      if (current.runner !== move.from) {
+        throw new BoardError("INVALID_STATE", `project ${move.slug} no longer lives on ${move.from}, so this move no longer applies`);
+      }
+      await this.readRunner(move.to);
+      const project2 = await this.updateProject(move.slug, (each) => ({ ...each, runner: move.to }));
+      await this.events.append("project.moved", actor.name, {
+        slug: move.slug,
+        from: move.from,
+        to: move.to,
+        carried: move.carried
+      });
+      return project2;
+    });
+  }
+  /**
+   * Makes the repository a move carries a project through, for the server's git route to serve,
+   * and answers the move's id, which names it; `dropMoveRepo` removes it when the move ends.
+   */
+  async openMoveRepo() {
+    const id = this.newId();
+    await this.moves.open(this.paths.move(id));
+    return id;
+  }
+  async dropMoveRepo(id) {
+    await this.moves.drop(this.paths.move(UlidSchema.parse(id)));
+  }
+  /** Where the moves' repositories live, which the server's git route serves from. */
+  get moveRepos() {
+    return this.paths.moves();
+  }
   /** The projection a runner mirrors for its agents to read, by relative path, with hashes. */
   async boardManifest() {
     return this.files.manifest(this.paths.board, () => true);
@@ -7117,7 +7603,7 @@ ${rationale}`}`);
   async writeTurnRecord(record) {
     const dir = this.sessionDir(record.agent, record.project, conversationPart(record));
     await ensureDir(dir);
-    await writeJson(path7.join(dir, "last-turn.json"), record);
+    await writeJson(path8.join(dir, "last-turn.json"), record);
   }
   // ---------------------------------------------------------------------------------------------
   // Internals
@@ -7236,8 +7722,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
   async ensureAgentProject(name, slug) {
     const dir = this.paths.agentProject(name, slug);
     await ensureDir(dir);
-    if (!await exists(path7.join(dir, "sessions.json"))) {
-      await writeJson(path7.join(dir, "sessions.json"), {});
+    if (!await exists(path8.join(dir, "sessions.json"))) {
+      await writeJson(path8.join(dir, "sessions.json"), {});
     }
   }
   /**
@@ -7479,11 +7965,11 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const file = this.paths.societySkillFile(skill2.name);
     const replaced = await exists(file);
     const taken = proposal2.skillFiles;
-    const staged = path7.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
+    const staged = path8.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
     if (taken === void 0 || !await exists(staged)) {
       throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} holds no skill files`);
     }
-    await rm2(dir, { recursive: true, force: true });
+    await rm3(dir, { recursive: true, force: true });
     await cp(this.paths.proposalFiles(proposal2.id), dir, { recursive: true });
     const { body } = await readLooseMarkdown(file);
     await writeMarkdown(file, {
@@ -7536,10 +8022,10 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       return `the frontmatter of ${folder}/SKILL.md in ${proposal2.proposedBy}'s home does not parse (${manual.error})`;
     }
     const dir = this.paths.proposalFiles(proposal2.id);
-    await rm2(dir, { recursive: true, force: true });
+    await rm3(dir, { recursive: true, force: true });
     for (const entry of taken.files) {
-      const target = path7.join(dir, ...entry.path.split("/"));
-      await ensureDir(path7.dirname(target));
+      const target = path8.join(dir, ...entry.path.split("/"));
+      await ensureDir(path8.dirname(target));
       await writeFile4(target, contents.get(entry.path) ?? Buffer.alloc(0));
       await chmod2(target, entry.executable ? 493 : 420);
     }
@@ -7630,7 +8116,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       if (!isSafeRelativePath(entry.path)) {
         continue;
       }
-      const bytes = await readFile4(path7.join(dir, ...entry.path.split("/"))).catch(() => null);
+      const bytes = await readFile4(path8.join(dir, ...entry.path.split("/"))).catch(() => null);
       files.push({
         ...entry,
         ...bytes === null ? { text: null, truncated: false } : skillFileText(bytes)
@@ -7779,7 +8265,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     this.assertNoTurnCut(actor, `${ref} cannot be archived`, (turn2) => turn2.channel === channel && turn2.scope === scope || turn2.thread !== void 0 && closing.has(turn2.thread));
     const threadsClosed = [];
     for (const file of await listFiles(threads)) {
-      const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(threads, file), ThreadFrontmatterSchema);
       if (doc.data.channel !== ref || doc.data.state !== "open") {
         continue;
       }
@@ -7911,7 +8397,7 @@ ${charter.purpose}
     const threads = this.paths.threads(slug);
     const threadsClosed = [];
     for (const file of await listFiles(threads)) {
-      const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(threads, file), ThreadFrontmatterSchema);
       if (doc.data.state !== "open") {
         continue;
       }
@@ -7986,10 +8472,10 @@ ${charter.purpose}
         ...project2,
         members: project2.members.filter((member) => member !== name)
       }));
-      const sessions = path7.join(this.paths.agentProject(name, slug), "sessions.json");
+      const sessions = path8.join(this.paths.agentProject(name, slug), "sessions.json");
       if (await exists(sessions)) {
         const archived = `sessions.archived.${ts.replace(/[:.]/g, "-")}.json`;
-        await rename3(sessions, path7.join(this.paths.agentProject(name, slug), archived));
+        await rename3(sessions, path8.join(this.paths.agentProject(name, slug), archived));
       }
     }
     this.tokenIndex.delete(current.tokenHash);
@@ -8103,7 +8589,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. */
@@ -8145,6 +8631,51 @@ ${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(task2, crons, now) {
+    if (task2.leaseExpiresAt === void 0) {
+      return null;
+    }
+    const lease = Date.parse(task2.leaseExpiresAt);
+    let pending = false;
+    let stopped = null;
+    for (const cron2 of crons) {
+      if (cron2.agent !== task2.claimedBy || !firesInTask(cron2, task2)) {
+        continue;
+      }
+      const at = cronStoppedAt(cron2);
+      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 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 the holder has at least half a lease to come back to it.
+   */
+  async pausedLease(task2, runners, runner2, now) {
+    if (task2.claimedBy === void 0 || task2.leaseExpiresAt === void 0) {
+      return null;
+    }
+    const holder = await this.readAgent(task2.claimedBy).catch(() => null);
+    if (holder === null || !heldOn(runners, runner2, holder.cli)) {
+      return null;
+    }
+    const lease = Date.parse(task2.leaseExpiresAt);
+    return lease - now.getTime() < this.leaseMs / 2 ? this.leaseEnd(now) : null;
+  }
   leaseExpired(task2, now) {
     return task2.leaseExpiresAt !== void 0 && new Date(task2.leaseExpiresAt).getTime() <= now.getTime();
   }
@@ -8257,11 +8788,7 @@ ${charter.purpose}
         if (task2.claimedBy === actor.name || task2.createdBy === actor.name || task2.stages.some((stage) => stage.agent === actor.name || stage.holders.includes(actor.name))) {
           return true;
         }
-        if (task2.status !== "open" || task2.completing) {
-          return false;
-        }
-        const agent2 = await this.readAgent(actor.name);
-        return agent2.memberships.includes(task2.project) && mayHoldStage(actor, task2);
+        return await this.mayTakeStage(actor, task2);
       }
       if (subject?.kind === "proposal") {
         const proposal2 = await this.readProposal(subject.id);
@@ -8275,6 +8802,34 @@ ${charter.purpose}
     }
     return false;
   }
+  /** Whether a task's current stage waits for a holder and the member may take it. */
+  async mayTakeStage(actor, task2) {
+    if (task2.status !== "open" || task2.completing) {
+      return false;
+    }
+    const agent2 = await this.readAgent(actor.name);
+    return agent2.memberships.includes(task2.project) && mayHoldStage(actor, task2);
+  }
+  /**
+   * 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 task2 = subject?.kind === "task" ? await this.findTask(subject.id).then((location) => location.task, () => null) : null;
+    if (task2 === null) {
+      return "every";
+    }
+    const stageIsTheirs = task2.status === "claimed" ? task2.claimedBy === actor.name : await this.mayTakeStage(actor, task2);
+    if (stageIsTheirs) {
+      return "every";
+    }
+    return task2.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))];
@@ -8330,7 +8885,7 @@ ${charter.purpose}
       if (since !== null && id <= since || upto !== void 0 && id > upto) {
         continue;
       }
-      const doc = await readMarkdown(path7.join(dir, file), MessageFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(dir, file), MessageFrontmatterSchema);
       messages.push({ ...doc.data, body: doc.body });
     }
     return messages;
@@ -8485,8 +9040,21 @@ runner.command("add <name>").description("Register a runner and print its token
 runner.command("list").description("List runners and what they offer").action(async () => {
   const board = await open3();
   const runners = await board.listRunners();
-  print(runners, () => runners.length === 0 ? "No runners yet; add one with `runner add <name>`." : runners.map((each) => `${each.name}  ${each.status}  ${each.os}${each.version === void 0 ? "" : `  v${each.version}`}  ${each.clis.join(",") || "no CLIs yet"}${each.capabilities.length === 0 ? "" : `  ${each.capabilities.join(",")}`}`).join("\n"));
+  print(runners, () => runners.length === 0 ? "No runners yet; add one with `runner add <name>`." : runners.map((each) => `${each.name}  ${each.status}${each.paused === void 0 ? "" : "  paused"}  ${each.os}${each.version === void 0 ? "" : `  v${each.version}`}  ${each.clis.join(",") || "no CLIs yet"}${each.capabilities.length === 0 ? "" : `  ${each.capabilities.join(",")}`}${Object.keys(each.pausedClis ?? {}).map((cli) => `  ${cli} paused`).join("")}`).join("\n"));
 });
+for (const [verb, paused] of [
+  ["pause", true],
+  ["resume", false]
+]) {
+  runner.command(`${verb} <name> [cli]`).description(paused ? "Start no more turns on a runner, or with one of its CLIs, until resumed; turns in flight finish" : "Let a paused runner, or a paused CLI on it, take turns again").action(async (name, cli) => {
+    const board = await open3();
+    const updated = await board.setRunnerPaused(board.userActor(), name, {
+      paused,
+      ...cli === void 0 ? {} : { cli: CliKindSchema.parse(cli) }
+    });
+    print(updated, () => `${cli === void 0 ? name : `${cli} on ${name}`} ${verb}d`);
+  });
+}
 var agent = program.command("agent").description("Manage agents");
 agent.command("add <name>").description("Add an agent and print its board token once").requiredOption("--role <role>", "role charter name").option("--cli <cli>", "claude or codex").option("--model <model>", "model to run the CLI with; the CLI's own default otherwise").option("--runner <name>", "runner preferred for its turns; any with its CLI otherwise").option("-p, --project <slug...>", "project memberships").action(async (name, opts) => {
   const board = await open3();
@@ -8852,7 +9420,7 @@ knowledge.command("show <topic>").description("Print a knowledge topic").option(
 });
 knowledge.command("write <topic>").description("Write a knowledge topic as the user, from a file or standard input").requiredOption("--revision <n>", "the revision it replaces, as knowledge list shows it; 0 for a new topic").option("--project <slug>", "the project's topic instead of the society's").option("--file <path>", "read the body from this file instead of standard input").option("--as <agent>", "act as this agent instead of the user").action(async (topic, opts) => {
   const board = await open3();
-  const body = opts.file === void 0 ? await readStdin() : await readFile5(path8.resolve(opts.file), "utf8");
+  const body = opts.file === void 0 ? await readStdin() : await readFile5(path9.resolve(opts.file), "utf8");
   const written = await board.writeKnowledge(await actorFor(board, opts.as), {
     project: opts.project ?? null,
     topic,