@kubitnodes/stellaris 0.3.11 → 0.3.13

package/dist/server/index.js

@@ -59,7 +59,8 @@ var VERB_NAMES = [
   "archive_project",
   "remove_knowledge",
   "create_channel",
-  "archive_channel"
+  "archive_channel",
+  "update_dashboard"
 ];
 var VerbNameSchema = z2.enum(VERB_NAMES);
 var CharterTriggerSchema = z2.enum(["user_post", "ops_event", "heartbeat"]);
@@ -105,7 +106,8 @@ var MEMBER_VERBS = [
   "write_knowledge",
   "remove_knowledge",
   "plan_task",
-  "advance_task"
+  "advance_task",
+  "update_dashboard"
 ];
 var GOVERNANCE_VERBS = ["approve", "reject"];
 var FRONT_DESK_VERBS = ["create_project"];
@@ -185,7 +187,44 @@ var SocietySchema = z3.object({
   channels: z3.array(NameSchema),
   archivedChannels: z3.array(ArchivedChannelSchema).default([])
 });
-var CompletionEffectSchema = z3.enum(["none", "merge"]);
+var CompletionEffectSchema = z3.enum(["none", "merge", "ghpr"]);
+var GITHUB_REMOTE = [
+  /^https:\/\/github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/,
+  /^git@github\.com:([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?$/,
+  /^ssh:\/\/git@github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/
+];
+function githubRepository(remote) {
+  for (const pattern of GITHUB_REMOTE) {
+    const match = remote === null ? null : pattern.exec(remote);
+    if (match?.[1] !== void 0 && match[2] !== void 0) {
+      return { owner: match[1], name: match[2] };
+    }
+  }
+  return null;
+}
+var PULL_REQUEST_URL = /^https:\/\/github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+)\/pull\/([1-9]\d*)\/?$/;
+var PullRequestUrlSchema = z3.string().trim().regex(PULL_REQUEST_URL, "a pull request's address, https://github.com/<owner>/<repo>/pull/<number>");
+function parsePullRequestUrl(url) {
+  const match = PULL_REQUEST_URL.exec(url.trim());
+  return match?.[1] === void 0 || match[2] === void 0 || match[3] === void 0 ? null : { owner: match[1], name: match[2], number: Number(match[3]) };
+}
+function sameRepository(a, b) {
+  return a.owner.toLowerCase() === b.owner.toLowerCase() && a.name.toLowerCase() === b.name.toLowerCase();
+}
+var MergeSubjectSchema = z3.string().trim().min(1).max(300).regex(/^[^\n]+$/, "a merge commit's subject is one line");
+var PullRequestLinkSchema = z3.object({
+  url: PullRequestUrlSchema,
+  number: z3.number().int().positive(),
+  subject: MergeSubjectSchema.optional(),
+  body: z3.string().max(2e4).optional(),
+  linkedBy: NameSchema,
+  linkedAt: IsoDateTimeSchema,
+  /**
+   * Once its `ghpr` task was abandoned, how the board's closing of it on GitHub went: `ok` false
+   * leaves it open, for the reason `detail` gives.
+   */
+  closed: z3.object({ at: IsoDateTimeSchema, ok: z3.boolean(), detail: z3.string() }).optional()
+});
 var DefaultBranchSchema = z3.string().trim().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "a branch name is letters, digits, and . _ / -").refine((branch) => !branch.includes("..") && !branch.includes("//") && !branch.endsWith("/") && !branch.endsWith(".") && !branch.endsWith(".lock"), "not a branch name git takes").refine((branch) => !branch.startsWith("task/") && !branch.startsWith("agent/"), "task/ and agent/ hold the board's own branches");
 var StageIdSchema = z3.string().regex(/^s[1-9][0-9]*$/, "expected a stage id such as s1");
 var stageFields = {
@@ -300,6 +339,8 @@ var TaskFrontmatterSchema = z3.object({
   /** The highest stage number issued, so a removed stage's id is never reused. */
   stageSeq: z3.number().int().positive(),
   onDone: CompletionEffectSchema.default("none"),
+  /** The pull request a `ghpr` task lands through. */
+  pullRequest: PullRequestLinkSchema.optional(),
   /** The last stage is complete and the completion effect is running. */
   completing: z3.boolean().default(false),
   /** The latest send-back while its rework lasts: cleared once the task reaches that stage again. */
@@ -392,6 +433,8 @@ var RunnerSchema = z3.object({
   os: RunnerOsSchema,
   clis: z3.array(CliKindSchema),
   capabilities: z3.array(z3.string()),
+  /** The release the runner reported when it last registered; absent until it has. */
+  version: z3.string().optional(),
   status: z3.enum(["connected", "disconnected"]),
   lastSeen: IsoDateTimeSchema.optional()
 });
@@ -570,12 +613,27 @@ var RemovedKnowledgeSchema = z3.object({
   removedBy: NameSchema,
   removedAt: IsoDateTimeSchema
 });
+var DashboardSchema = z3.object({
+  project: NameSchema,
+  revision: z3.number().int().min(0),
+  /** Absent until someone updates the dashboard the project began with. */
+  updatedBy: NameSchema.optional(),
+  updatedAt: IsoDateTimeSchema.optional(),
+  body: z3.string()
+});
+var ProposalOriginSchema = z3.object({
+  scope: NameSchema,
+  thread: UlidSchema.optional(),
+  channel: NameSchema.optional()
+});
 var ProposalFrontmatterSchema = z3.object({
   id: UlidSchema,
   kind: ProposalKindSchema,
   proposedBy: NameSchema,
   status: ProposalStatusSchema,
   createdAt: IsoDateTimeSchema,
+  /** Absent for a proposal filed outside a turn, or before proposals recorded it. */
+  filedFrom: ProposalOriginSchema.optional(),
   decidedBy: NameSchema.optional(),
   decidedAt: IsoDateTimeSchema.optional(),
   reason: z3.string().optional(),
@@ -641,7 +699,16 @@ var VerbInputs = {
     status: z4.enum(["abandoned"]).optional(),
     /** Posted to the task's thread as the caller, marked with the step when the task moved. */
     note: z4.string().min(1).optional(),
-    blocked_by: z4.array(UlidSchema).optional()
+    blocked_by: z4.array(UlidSchema).optional(),
+    /**
+     * The pull request a `ghpr` task lands through, on its project's repository, with the merge
+     * commit's subject and body; null unlinks it.
+     */
+    pull_request: z4.object({
+      url: PullRequestUrlSchema,
+      merge_subject: MergeSubjectSchema.optional(),
+      merge_body: z4.string().max(2e4).optional()
+    }).nullable().optional()
   }),
   get_task: z4.object({ task_id: UlidSchema }),
   subscribe: z4.object({ channel: ChannelRefSchema }),
@@ -695,7 +762,14 @@ var VerbInputs = {
     name: NameSchema,
     purpose: z4.string().min(1)
   }),
-  archive_channel: z4.object({ channel: ChannelRefSchema, reason: z4.string().min(1) })
+  archive_channel: z4.object({ channel: ChannelRefSchema, reason: z4.string().min(1) }),
+  update_dashboard: z4.object({
+    project: NameSchema,
+    /** The whole dashboard as markdown; the board keeps its frontmatter. */
+    body: z4.string().min(1),
+    /** The `revision` in the frontmatter of the dashboard you read, 0 when it names none. */
+    revision: z4.number().int().min(0)
+  })
 };
 var VERB_DESCRIPTIONS = {
   post_message: "Post a markdown message to a channel, or into a thread when thread_id is given; a thread's message goes to the thread's channel.",
@@ -706,24 +780,25 @@ var VERB_DESCRIPTIONS = {
   create_task: "Create a task in a project with its plan: stages of {name, role or agent, gate}. Without stages it gets one stage, work, that anyone in the project may take. File it in a channel of the project, such as a release's, or general by default; its thread opens there with it, under the task's id, for everything said about the work.",
   claim_task: "Hold the task's current stage. Claims are leases renewed by every turn that touches the task.",
   release_task: "Let go of the stage you hold so someone else can take it.",
-  update_task: "Move a task back to an earlier stage, abandon it, or set what it is blocked by. A note is posted to the task's thread.",
+  update_task: "Move a task back to an earlier stage, abandon it, set what it is blocked by, or link its pull request (pull_request: url, with the merge commit's merge_subject and merge_body), which a ghpr task needs before its last stage completes. A note is posted to the task's thread.",
   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.",
   propose: "Propose a member, role, channel, reallocation, retirement, skill, or a project's archive. The charter shape per kind is in your instructions. Opens the proposal's thread in governance with your rationale; approval provisions it.",
   approve: "Approve a proposal; the board then provisions it, posts the decision in the proposal's thread, and closes it. User and steward only, never on your own proposal.",
   reject: "Reject a proposal with a reason, posted in the proposal's thread, which closes. User and steward only, never on your own proposal.",
-  create_project: "Create a project with its general channel: a slug, a display name, a git remote when one exists, and optionally a completion effect (none or merge).",
+  create_project: "Create a project with its general channel: a slug, a display name, a git remote when one exists, and optionally a completion effect (none, merge, or ghpr for a GitHub remote).",
   join_project: "Join a project, or add another citizen to one when your role allows it. Membership gives the pair a worktree and an onboarding turn, and follows the project's general; the result lists its other open channels, to subscribe to when the work needs them.",
   leave_project: "Leave a project, or remove another citizen from one when your role allows it.",
   write_knowledge: "Write or replace a knowledge topic: durable facts every member of a project should know, or with project null the society's shared knowledge (steward and user). Not a message; use post_message for those.",
   remove_knowledge: "Remove a knowledge topic that is wrong, superseded, or folded into another, so no turn or search finds it again. Whoever may write the topic may remove it; the board keeps its text aside for the user to restore.",
   plan_task: "Reshape a task's plan from the current stage onward, or after it while someone holds it: keep a stage by passing its id, drop it by leaving it out, add one without an id. Gated stages and on_done: user, steward, concierge.",
   advance_task: "Finish the stage you hold, with a note for the task's thread on what you did. The next stage becomes current; past the last one the task is done.",
-  configure_project: "Set a project's completion effect (none, or merge to land each finished task's branch on the default branch), its display name, or its default branch, any of them at once. The slug never changes.",
+  configure_project: "Set a project's completion effect (none; merge to land each finished task's branch on the default branch; ghpr, for a project on GitHub, to merge each finished task's linked pull request), its display name, or its default branch, any of them at once. Tasks already filed keep theirs. The slug never changes.",
   archive_project: "Archive a project whose work is finished or has moved: its members leave, its open threads close, and nothing more is posted, filed, or joined there, while its files and history stay. Refused while a task there is in play.",
   create_channel: "Open a channel in a project, or with project null in the society, for a workstream such as a release, whose tasks are filed there. You follow it; a notice in the place's general announces it, and members subscribe when it concerns them. User, steward, concierge.",
-  archive_channel: "Archive a channel whose workstream is done: its open threads close, its followers stop following it, and nothing more is posted or filed there, while its history stays readable. Refused while a task filed there is in play, and for the channels the board itself uses. User, steward, concierge."
+  archive_channel: "Archive a channel whose workstream is done: its open threads close, its followers stop following it, and nothing more is posted or filed there, while its history stays readable. Refused while a task filed there is in play, and for the channels the board itself uses. User, steward, concierge.",
+  update_dashboard: "Replace the dashboard of a project you are a member of, the status page the user reads on its view, with a whole markdown body. Pass the revision from the frontmatter of the dashboard you read; if it was updated since, the call is refused with the current text to merge yours into. dashboard.md in the board projection is a copy, so editing it changes nothing."
 };
 
 // packages/shared/dist/events.js
@@ -763,6 +838,7 @@ var BOARD_EVENT_TYPES = [
   "agent.left",
   "knowledge.written",
   "knowledge.removed",
+  "dashboard.updated",
   "skill.promoted",
   "runner.added",
   "user.signed_in",
@@ -779,6 +855,8 @@ var BOARD_EVENT_TYPES = [
   "turn.failed",
   "merge.completed",
   "merge.failed",
+  "pull_request.closed",
+  "pull_request.close_failed",
   "workspace.leftovers"
 ];
 var BoardEventTypeSchema = z5.enum(BOARD_EVENT_TYPES);
@@ -934,8 +1012,21 @@ var PendingEnrollmentSchema = z6.object({
 var ProjectRepoSchema = z6.object({
   slug: NameSchema,
   origin: z6.string().nullable(),
-  defaultBranch: z6.string().min(1)
+  defaultBranch: z6.string().min(1),
+  /**
+   * The board lands finished tasks on the default branch, itself or through their pull requests,
+   * so the runner lets nothing else move it.
+   */
+  boardLands: z6.boolean()
 });
+function projectRepo(project) {
+  return {
+    slug: project.slug,
+    origin: project.repo,
+    defaultBranch: project.defaultBranch,
+    boardLands: project.onDone !== "none"
+  };
+}
 var TurnWorkspaceSchema = z6.discriminatedUnion("kind", [
   z6.object({
     kind: z6.literal("home"),
@@ -1008,7 +1099,22 @@ var TurnOutcomeSchema = z6.object({
 var TurnAckSchema = z6.object({ dropWorkspace: z6.boolean() });
 var LandRequestSchema = z6.object({
   repo: ProjectRepoSchema,
-  branch: z6.string().min(1)
+  branch: z6.string().min(1),
+  /**
+   * For a `ghpr` task, the pull request to merge in place of the branch, which must hold the
+   * branch's files, and the merge commit's subject and body, the pull request's title and an
+   * empty body when left out.
+   */
+  pullRequest: z6.object({
+    url: z6.string().min(1),
+    subject: z6.string().min(1).optional(),
+    body: z6.string().optional()
+  }).optional()
+});
+var CloseRequestSchema = z6.object({
+  repo: ProjectRepoSchema,
+  url: z6.string().min(1),
+  comment: z6.string().min(1)
 });
 var MergeOutcomeSchema = z6.object({ ok: z6.boolean(), detail: z6.string() });
 var ModelListSchema = z6.array(ModelOptionSchema);
@@ -1083,6 +1189,8 @@ var TurnSteerSchema = z6.object({ id: z6.uuid(), text: z6.string().min(1) });
 var RunnerMessageSchema = z6.discriminatedUnion("type", [
   z6.object({ type: z6.literal("turn"), job: TurnJobSchema }),
   z6.object({ type: z6.literal("land"), request: z6.string().min(1), land: LandRequestSchema }),
+  /** Answered with a `MergeOutcome`. */
+  z6.object({ type: z6.literal("close"), request: z6.string().min(1), close: CloseRequestSchema }),
   z6.object({ type: z6.literal("models"), request: z6.string().min(1), cli: CliKindSchema }),
   /** Answered with a `BranchFile`, or null when the branch or the path does not exist. */
   z6.object({ type: z6.literal("file"), request: z6.string().min(1), read: BranchReadSchema }),
@@ -1485,7 +1593,7 @@ var RunnerConfigSchema = z10.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.11";
+var STELLARIS_VERSION = "0.3.13";
 
 // packages/board-core/dist/errors.js
 var BoardError = class extends Error {
@@ -2669,6 +2777,9 @@ var THREAD_CONVERSATIONS = "thread-conversations";
 var ASKS_CHANNEL_OPENED = "asks-channel-opened";
 var KNOWLEDGE_REMOVAL = "knowledge-removal-granted";
 var CHANNEL_CONVERSATIONS = "channel-conversations";
+var DASHBOARD_UPDATES = "dashboard-updates-granted";
+var OLD_DASHBOARD_LINE = "Agents may edit this file. It is rendered by the board UI.";
+var DASHBOARD_LINE = "The project's members keep this page current with update_dashboard.";
 var PLANNING_ROLES = [USER_ROLE, "steward", "concierge"];
 var REALLOCATING_ROLES = [USER_ROLE, "steward", "concierge"];
 var PROFILE_TEMPLATE = "# Profile\n\nOne short paragraph, kept current: what I do well, what I am working on, and what to send my way. The board projects this into the roster the front desk reads.\n";
@@ -2705,6 +2816,11 @@ function memberToAgentInput(member) {
     ...member.seedInstructions === void 0 ? {} : { seedInstructions: member.seedInstructions }
   };
 }
+function assertLandsByPullRequest(effect, repo, where) {
+  if (effect === "ghpr" && githubRepository(repo) === null) {
+    throw new BoardError("VALIDATION", `${where} has ${repo === null ? "no remote" : `its remote at ${repo}, not on GitHub`}, so its tasks cannot land through pull requests (ghpr)`);
+  }
+}
 function stageFrom(planned, id) {
   return {
     id,
@@ -2862,7 +2978,8 @@ var Board = class _Board {
       THREAD_CONVERSATIONS,
       ASKS_CHANNEL_OPENED,
       KNOWLEDGE_REMOVAL,
-      CHANNEL_CONVERSATIONS
+      CHANNEL_CONVERSATIONS,
+      DASHBOARD_UPDATES
     ].filter((name) => !applied.includes(name));
     if (pending.length === 0) {
       return;
@@ -2892,21 +3009,38 @@ var Board = class _Board {
       await this.openAsksChannel();
     }
     if (pending.includes(KNOWLEDGE_REMOVAL)) {
-      await this.grantKnowledgeRemoval();
+      await this.grantBesideKnowledge("remove_knowledge");
     }
     if (pending.includes(CHANNEL_CONVERSATIONS)) {
       await this.startChannelCursors();
     }
+    if (pending.includes(DASHBOARD_UPDATES)) {
+      await this.grantBesideKnowledge("update_dashboard");
+      await this.rewordDashboards();
+    }
     await writeJson(file, { applied: [...applied, ...pending] });
   }
   /**
-   * Whoever may write a scope's knowledge may remove it, so every charter granting
-   * `write_knowledge` is granted `remove_knowledge` once; seed roles have it from their seed.
+   * Grants `verb` once to every charter granting `write_knowledge`, the work roles' charters in
+   * practice; seed roles have it from their seed.
    */
-  async grantKnowledgeRemoval() {
+  async grantBesideKnowledge(verb) {
     for (const charter of await this.listRoles()) {
-      if (charter.verbs.includes("write_knowledge") && !charter.verbs.includes("remove_knowledge")) {
-        await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, "remove_knowledge"] }, { verbsAdded: ["remove_knowledge"] });
+      if (charter.verbs.includes("write_knowledge") && !charter.verbs.includes(verb)) {
+        await this.writeRoleUnlocked(USER_NAME, { ...charter, verbs: [...charter.verbs, verb] }, { verbsAdded: [verb] });
+      }
+    }
+  }
+  /** A dashboard still saying agents may edit its file says how it changes now. */
+  async rewordDashboards() {
+    for (const slug of await listDirs(this.paths.projects())) {
+      const file = this.paths.dashboard(slug);
+      if (!await exists(file)) {
+        continue;
+      }
+      const { data, body } = await readLooseMarkdown(file);
+      if (body.includes(OLD_DASHBOARD_LINE)) {
+        await writeMarkdown(file, data, body.replace(OLD_DASHBOARD_LINE, DASHBOARD_LINE));
       }
     }
   }
@@ -3668,6 +3802,7 @@ ${charter.purpose}
     if (await exists(file)) {
       throw new BoardError("ALREADY_EXISTS", `project ${input.slug} already exists`);
     }
+    assertLandsByPullRequest(input.onDone ?? "none", input.repo ?? null, `project ${input.slug}`);
     const project = ProjectSchema.parse({
       slug: input.slug,
       name: input.name ?? input.slug,
@@ -3688,9 +3823,9 @@ ${charter.purpose}
     await ensureDir(this.paths.tasks(project.slug));
     await ensureDir(this.paths.threads(project.slug));
     await ensureDir(this.paths.projectKnowledge(project.slug));
-    await writeMarkdown(this.paths.dashboard(project.slug), { project: project.slug, updatedAt: this.now().toISOString() }, `# ${project.name} dashboard
+    await writeMarkdown(this.paths.dashboard(project.slug), { project: project.slug, revision: 0, updatedAt: this.now().toISOString() }, `# ${project.name} dashboard
 
-Agents may edit this file. It is rendered by the board UI.
+${DASHBOARD_LINE}
 `);
     await this.updateAgent(USER_NAME, (user) => ({
       ...user,
@@ -3795,6 +3930,7 @@ Agents may edit this file. It is rendered by the board UI.
         ...patch.os === void 0 ? {} : { os: patch.os },
         ...patch.clis === void 0 ? {} : { clis: [...patch.clis] },
         ...patch.capabilities === void 0 ? {} : { capabilities: [...patch.capabilities] },
+        ...patch.version === void 0 ? {} : { version: patch.version },
         lastSeen: this.now().toISOString()
       });
       await writeMarkdown(file, next, doc.body);
@@ -4269,6 +4405,42 @@ ${task.body}`;
       throw new BoardError("FORBIDDEN", `${actor.name} is not a member of ${project}`);
     }
   }
+  /**
+   * Replaces a project's dashboard, by a member or the user. A turn reads the dashboard from the
+   * copy of the projection pulled when it started, so a revision other than the current one means
+   * someone updated it since; the refusal carries the current text, which that copy lacks.
+   */
+  async updateDashboard(actor, input) {
+    const args = VerbInputs.update_dashboard.parse(input);
+    await this.authorize(actor, "update_dashboard");
+    return this.mutex.run(async () => {
+      const project = await this.readActiveProject(args.project);
+      if (actor.role !== USER_ROLE && !project.members.includes(actor.name)) {
+        throw new BoardError("FORBIDDEN", `${actor.name} is not a member of ${args.project}`);
+      }
+      const current = await this.dashboardOf(args.project);
+      if (args.revision !== current.revision) {
+        const by = current.updatedBy === void 0 ? "" : `, updated by ${current.updatedBy} at ${current.updatedAt ?? "an unknown time"}`;
+        throw new BoardError("INVALID_STATE", `the dashboard of ${args.project} is at revision ${current.revision}${by}, not ${args.revision}. Merge your changes into its current text, below, and update again with revision ${current.revision}.
+
+${current.body}`);
+      }
+      const updated = DashboardSchema.parse({
+        project: args.project,
+        revision: current.revision + 1,
+        updatedBy: actor.name,
+        updatedAt: this.now().toISOString(),
+        body: args.body
+      });
+      const { body, ...frontmatter } = updated;
+      await writeMarkdown(this.paths.dashboard(args.project), frontmatter, body);
+      await this.events.append("dashboard.updated", actor.name, {
+        project: args.project,
+        revision: updated.revision
+      });
+      return updated;
+    });
+  }
   async openThread(actor, input) {
     const args = VerbInputs.open_thread.parse(input);
     await this.authorize(actor, "open_thread");
@@ -4650,6 +4822,9 @@ ${args.summary}`);
         completedAt: ts
       };
       const next = current.stages[index + 1];
+      if (next === void 0 && current.onDone === "ghpr" && current.pullRequest === void 0) {
+        throw new BoardError("INVALID_STATE", `task ${current.id} lands through its pull request: link it with update_task pull_request before the last stage completes, or have the user, the steward, or the concierge set the task's on_done to none`);
+      }
       if (next === void 0 && current.onDone === "none") {
         this.assertNoTurnCut(actor, `task ${current.id} cannot end`, (turn) => turn.thread === current.id);
       }
@@ -4766,6 +4941,7 @@ ${args.summary}`);
       const guarded = gateChanges(ahead, replanned);
       if (onDone !== current.onDone) {
         guarded.push("change the completion effect");
+        assertLandsByPullRequest(onDone, (await this.readProject(current.project)).repo, `project ${current.project}`);
       }
       if (guarded.length > 0) {
         this.assertMayGate(actor, guarded.join(", "));
@@ -4854,6 +5030,12 @@ ${args.summary}`);
         }
         next = { ...next, blockedBy: [...args.blocked_by] };
       }
+      if (args.pull_request !== void 0) {
+        next = {
+          ...next,
+          pullRequest: await this.pullRequestLink(actor, current, args.pull_request)
+        };
+      }
       if (args.note !== void 0) {
         const step = moved !== null ? { action: "returned", stage: moved.from, to: moved.to } : next.status === "abandoned" ? { action: "abandoned", stage: current.stage, to: null } : void 0;
         await this.postTaskNote(actor.name, current, args.note, step);
@@ -4879,12 +5061,46 @@ ${args.summary}`);
           project: location.project,
           from: current.status,
           to: task.status,
-          note: args.note ?? null
+          note: args.note ?? null,
+          ...args.pull_request === void 0 ? {} : { pullRequest: task.pullRequest?.url ?? null }
         });
       }
       return task;
     });
   }
+  /**
+   * The pull request a task is linked to, or none for `null`: one on the repository of its project,
+   * by a member of the project or a planner, while the task is in play and before it lands.
+   */
+  async pullRequestLink(actor, task, link) {
+    this.assertInPlay(task);
+    if (task.completing) {
+      throw new BoardError("INVALID_STATE", `task ${task.id} is landing, so its pull request no longer changes`);
+    }
+    if (!PLANNING_ROLES.includes(actor.role)) {
+      const agent = await this.readAgent(actor.name);
+      if (!agent.memberships.includes(task.project)) {
+        throw new BoardError("FORBIDDEN", `${actor.name} is not a member of ${task.project}`);
+      }
+    }
+    if (link === null) {
+      return void 0;
+    }
+    const project = await this.readProject(task.project);
+    const repository = githubRepository(project.repo);
+    const named = parsePullRequestUrl(link.url);
+    if (repository === null || named === null || !sameRepository(repository, named)) {
+      throw new BoardError("VALIDATION", `${link.url} is not a pull request of ${project.slug}'s repository${project.repo === null ? ", since it has no remote" : ` at ${project.repo}`}`);
+    }
+    return PullRequestLinkSchema.parse({
+      url: link.url,
+      number: named.number,
+      ...link.merge_subject === void 0 ? {} : { subject: link.merge_subject },
+      ...link.merge_body === void 0 ? {} : { body: link.merge_body },
+      linkedBy: actor.name,
+      linkedAt: this.now().toISOString()
+    });
+  }
   async getTask(actor, input) {
     const args = VerbInputs.get_task.parse(input);
     await this.authorize(actor, "get_task");
@@ -4942,6 +5158,13 @@ ${args.summary}`);
           proposedBy: actor.name,
           status: "proposed",
           createdAt: this.now().toISOString(),
+          ...actor.scope === void 0 ? {} : {
+            filedFrom: {
+              scope: actor.scope,
+              ...actor.thread === void 0 ? {} : { thread: actor.thread },
+              ...actor.channel === void 0 ? {} : { channel: actor.channel }
+            }
+          },
           charter: parsed.data
         }),
         body: args.rationale
@@ -4995,6 +5218,9 @@ ${rationale}`}`);
     }
     return this.mutex.run(async () => {
       const previous = await this.readActiveProject(args.project);
+      if (args.on_done !== void 0) {
+        assertLandsByPullRequest(args.on_done, previous.repo, `project ${previous.slug}`);
+      }
       const project = await this.updateProject(args.project, (current) => ({
         ...current,
         ...args.on_done === void 0 ? {} : { onDone: args.on_done },
@@ -5176,6 +5402,8 @@ ${rationale}`}`);
         return this.createChannel(actor, VerbInputs.create_channel.parse(input));
       case "archive_channel":
         return this.archiveChannel(actor, VerbInputs.archive_channel.parse(input));
+      case "update_dashboard":
+        return this.updateDashboard(actor, VerbInputs.update_dashboard.parse(input));
       default:
         throw new BoardError("VALIDATION", `unknown verb ${String(verb)}`);
     }
@@ -5437,6 +5665,29 @@ ${rationale}`}`);
       });
     });
   }
+  /**
+   * Records how closing an abandoned `ghpr` task's pull request on GitHub went, once: the task's
+   * link keeps it, so a restart does not try again.
+   */
+  async recordPullRequestClosed(actor, input) {
+    return this.mutex.run(async () => {
+      const location = await this.findTask(input.taskId);
+      const current = location.task;
+      const pull = current.pullRequest;
+      if (pull === void 0 || pull.closed !== void 0) {
+        return current;
+      }
+      const task = await this.writeTask(location.project, {
+        ...current,
+        pullRequest: {
+          ...pull,
+          closed: { at: this.now().toISOString(), ok: input.ok, detail: input.detail }
+        }
+      });
+      await this.events.append(input.ok ? "pull_request.closed" : "pull_request.close_failed", actor.name, { project: location.project, taskId: task.id, url: pull.url, detail: input.detail });
+      return task;
+    });
+  }
   /**
    * Records that a citizen's workspace in a conversation that has ended holds work on no branch, so
    * the scheduler gives the citizen a closing turn there to decide about it. False, recording
@@ -5480,8 +5731,8 @@ ${rationale}`}`);
   }
   /**
    * Records the outcome of a completing task's effect: done, or waiting again at its last stage so
-   * its participants can reshape the plan. A merge's outcome is posted to the task's thread, and a
-   * landed one announced in the project's general channel.
+   * its participants can reshape the plan. A landing's outcome, a merge's or a pull request's, is
+   * posted to the task's thread, and a landed one announced in the task's channel.
    */
   async finishCompletion(actor, input) {
     return this.mutex.run(async () => {
@@ -5491,8 +5742,8 @@ ${rationale}`}`);
         throw new BoardError("INVALID_STATE", `task ${current.id} is not completing`);
       }
       const ts = this.now().toISOString();
-      const merged = current.onDone === "merge";
-      if (merged) {
+      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 });
       }
       if (input.ok) {
@@ -5512,7 +5763,7 @@ ${rationale}`}`);
         for (const name of new Set(task2.stages.flatMap((stage) => stage.completedBy ?? []))) {
           await this.refreshMember(name);
         }
-        if (merged) {
+        if (landed) {
           await this.appendMessage(actor.name, channelRef(location.project, task2.channel), `Task ${task2.id} "${task2.title}" is done: ${sentence(input.detail)}.`);
         }
         return task2;
@@ -5542,15 +5793,31 @@ ${rationale}`}`);
   async writeState(name, value) {
     await this.mutex.run(() => writeJson(path6.join(this.paths.state(), `${name}.json`), value));
   }
-  /** The project's editable dashboard: frontmatter plus markdown body. Empty when none exists. */
+  /** The project's dashboard, empty at revision 0 when it has none. */
   async readDashboard(slug) {
     await this.readProject(slug);
+    return this.dashboardOf(slug);
+  }
+  /**
+   * Read loosely, since agents wrote dashboards by hand before they had a verb: a revision or an
+   * author that does not parse counts as none.
+   */
+  async dashboardOf(slug) {
     const file = this.paths.dashboard(slug);
     if (!await exists(file)) {
-      return { data: { project: slug }, body: "" };
+      return { project: slug, revision: 0, body: "" };
     }
     const { data, body } = await readLooseMarkdown(file);
-    return { data, body };
+    const revision = z12.number().int().min(0).safeParse(data["revision"]);
+    const updatedBy = NameSchema.safeParse(data["updatedBy"]);
+    const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
+    return {
+      project: slug,
+      revision: revision.success ? revision.data : 0,
+      ...updatedBy.success ? { updatedBy: updatedBy.data } : {},
+      ...updatedAt.success ? { updatedAt: updatedAt.data } : {},
+      body
+    };
   }
   async listRunners() {
     const runners2 = [];
@@ -6653,7 +6920,8 @@ ${charter.purpose}
         proposalId,
         outcome,
         kind: proposal.kind,
-        proposedBy: proposal.proposedBy
+        proposedBy: proposal.proposedBy,
+        ...proposal.filedFrom === void 0 ? {} : { filedFrom: proposal.filedFrom }
       });
       if (provision !== void 0) {
         await this.events.append("proposal.provisioned", actor.name, {
@@ -6934,6 +7202,9 @@ function stringArray(value) {
 function stringOf(value) {
   return typeof value === "string" ? value : null;
 }
+function awaitsClosing(task) {
+  return task.status === "abandoned" && task.onDone === "ghpr" && task.pullRequest !== void 0 && task.pullRequest.closed === void 0;
+}
 function inPlay(task) {
   return (task.status === "open" || task.status === "claimed") && !task.completing;
 }
@@ -6966,6 +7237,9 @@ var Scheduler = class {
   steering = /* @__PURE__ */ new Map();
   /** Tasks whose completion effect waits for the turn that finished their last stage to end. */
   completions = /* @__PURE__ */ new Map();
+  /** Abandoned `ghpr` tasks whose pull request waits to be closed, by task id, with its project. */
+  closings = /* @__PURE__ */ new Map();
+  /** Completions and closings under way. */
   completing = /* @__PURE__ */ new Set();
   /** Running turns that must run alone among their citizen's, by session key: see `heldBack`. */
   exclusive = /* @__PURE__ */ new Map();
@@ -7065,6 +7339,7 @@ var Scheduler = class {
       this.lastSweep = now;
     }
     this.runCompletions();
+    this.runClosings();
     if (!paused) {
       await this.dispatchReady(now);
     }
@@ -7092,6 +7367,9 @@ var Scheduler = class {
         if (task.completing) {
           this.completions.set(task.id, { project: project.slug, actor: USER_NAME });
         }
+        if (awaitsClosing(task)) {
+          this.closings.set(task.id, project.slug);
+        }
       }
     }
     this.loaded = true;
@@ -7200,6 +7478,7 @@ var Scheduler = class {
         const taskId = stringOf(payload["taskId"]);
         if (taskId !== null && payload["to"] === "abandoned") {
           delete this.state.releaseCounts[taskId];
+          await this.queueClosing(taskId);
         }
         if (taskId !== null) {
           await this.pruneStageWakes(taskId);
@@ -7539,13 +7818,16 @@ var Scheduler = class {
       reason: "a conversation you took part in has ended, and its workspace holds work on no branch"
     }, now, beside);
   }
-  /** A decided proposal wakes the citizen that made it, to carry on with what it enables. */
+  /**
+   * A decided proposal wakes the citizen that made it, to carry on with what it enables, in the
+   * conversation it was filed from, where that work waits on the decision.
+   */
   async wakeProposer(proposalId, proposer, event, now) {
     const agent = await this.tryReadAgent(proposer);
     if (agent === null) {
       return;
     }
-    const scope = this.scopeForProject(agent, null);
+    const { scope, beside } = await this.filedFrom(agent, event.payload["filedFrom"]);
     const kind = stringOf(event.payload["kind"]) ?? "";
     const outcome = stringOf(event.payload["outcome"]) ?? "decided";
     this.enqueue(agent.name, scope, {
@@ -7553,7 +7835,27 @@ var Scheduler = class {
       from: event.actor,
       fromUser: event.actor === USER_NAME,
       reason: `your ${kind} proposal ${proposalId} was ${outcome} by ${event.actor}`
-    }, now);
+    }, now, beside);
+  }
+  /**
+   * The conversation a proposal was filed from while it is still open; its scope's home once it
+   * has ended; and the home outside projects when the citizen has left that scope, or the proposal
+   * names none, filed outside a turn or before proposals recorded it.
+   */
+  async filedFrom(agent, recorded) {
+    const origin = ProposalOriginSchema.safeParse(recorded);
+    if (!origin.success || origin.data.scope !== SOCIETY_SCOPE && !agent.memberships.includes(origin.data.scope)) {
+      return { scope: this.scopeForProject(agent, null) };
+    }
+    const scope = origin.data.scope;
+    const conversation = workspaceConversationOf(origin.data);
+    if (conversation === null || await this.board.conversationEnded(conversation)) {
+      return { scope };
+    }
+    return {
+      scope,
+      beside: conversation.kind === "thread" ? { thread: await this.conversationOf(conversation.id, scope) } : { channel: conversation.name }
+    };
   }
   /**
    * A thread's conversation for a turn in `scope`, and whether it is a task's in that scope, whose
@@ -8203,6 +8505,40 @@ var Scheduler = class {
     }
     return others.some((other) => this.exclusive.get(other) === "reflection");
   }
+  /** Queues closing an abandoned task's pull request, when it is a `ghpr` task with one open. */
+  async queueClosing(taskId) {
+    if (this.runner.closePullRequest === void 0) {
+      return;
+    }
+    try {
+      const { task } = await this.board.findTask(taskId);
+      if (awaitsClosing(task)) {
+        this.closings.set(taskId, task.project);
+      }
+    } catch {
+    }
+  }
+  /** Starts closing each queued pull request; one whose runner is away waits in the queue. */
+  runClosings() {
+    const close = this.runner.closePullRequest?.bind(this.runner);
+    if (close === void 0) {
+      return;
+    }
+    for (const [taskId, project] of this.closings) {
+      this.closings.delete(taskId);
+      const promise = close(project, taskId).then((outcome) => {
+        if (outcome === "deferred" && !this.closings.has(taskId)) {
+          this.closings.set(taskId, project);
+        }
+        return void 0;
+      }).catch((error) => {
+        this.log.error({ project, taskId, error: String(error) }, "closing a pull request failed");
+      }).finally(() => {
+        this.completing.delete(promise);
+      });
+      this.completing.add(promise);
+    }
+  }
   /** Starts each queued completion once the turn that finished the task's last stage has ended. */
   runCompletions() {
     for (const [taskId, item] of this.completions) {
@@ -8305,7 +8641,7 @@ function renderInstructions(input) {
   if (norms.length > 0) {
     sections.push("", "## Society norms", "", norms);
   }
-  sections.push("", "## Core memory", "", memory.length === 0 ? "(empty)" : memory, "", "## Skills", "", ...renderSkillsIndex(input.skills ?? []), "", "## Where things are", "", `- Your home directory: ${input.homeDir}. memory/core.md is loaded every turn; memory/<topic>.md is your archive; skills/<name>/SKILL.md are your skills; projects/<slug>/notes.md are your notes. You may read and write all of it, and the board's search covers your archive and skills for you alone. The runner keeps it in git and shares it with the board after every turn, so whatever machine your next turn runs on has it; leave git there to the runner. Files over ${HOME_FILE_LIMIT_BYTES / (1024 * 1024)} MB are not kept.`, `- ${HOME_SCRATCH}/ in your home is your working folder in turns outside any project, and a thread's or a channel's conversation there works in a folder of its own inside it, which goes when the thread closes or the channel is archived: none of it is kept or shared, so put downloads, environments, and other working files there, and keep the rest of your home for what you mean to remember.`, `- The board projection: ${input.boardDir} (read-only markdown: society and project channels, tasks, threads; shared knowledge under projects/<slug>/knowledge/ and society/knowledge/; the society's skills under society/skills/). Search it with your file tools; act through the board tools.`, "", "## Turn contract", "", TURN_CONTRACT, "", "## Planning", "", PLANNING, "", "## Governance", "", GOVERNANCE);
+  sections.push("", "## Core memory", "", memory.length === 0 ? "(empty)" : memory, "", "## Skills", "", ...renderSkillsIndex(input.skills ?? []), "", "## Where things are", "", `- Your home directory: ${input.homeDir}. memory/core.md is loaded every turn; memory/<topic>.md is your archive; skills/<name>/SKILL.md are your skills; projects/<slug>/notes.md are your notes. You may read and write all of it, and the board's search covers your archive and skills for you alone. The runner keeps it in git and shares it with the board after every turn, so whatever machine your next turn runs on has it; leave git there to the runner. Files over ${HOME_FILE_LIMIT_BYTES / (1024 * 1024)} MB are not kept.`, `- ${HOME_SCRATCH}/ in your home is your working folder in turns outside any project, and a thread's or a channel's conversation there works in a folder of its own inside it, which goes when the thread closes or the channel is archived: none of it is kept or shared, so put downloads, environments, and other working files there, and keep the rest of your home for what you mean to remember.`, `- The board projection: ${input.boardDir} (read-only markdown: society and project channels, tasks, threads; shared knowledge under projects/<slug>/knowledge/ and society/knowledge/; the society's skills under society/skills/; each project's dashboard, the status page the user reads on its view, at projects/<slug>/dashboard.md, which its members change with update_dashboard). Search it with your file tools; act through the board tools.`, "", "## Turn contract", "", TURN_CONTRACT, "", "## Planning", "", PLANNING, "", "## Governance", "", GOVERNANCE);
   if (input.onboarding !== void 0) {
     sections.push("", "## First turn", "", renderOnboardingPreamble(input.onboarding));
   }
@@ -8352,7 +8688,7 @@ function planLine(task, whose) {
   const index = stageIndex(task, task.stage);
   const stage = task.stages[index];
   const rest = task.stages.slice(index + 1).map((next) => `${next.name} (${next.gate ? "gate, " : ""}${assignee(next)})`);
-  const then = rest.length === 0 ? `then ${task.onDone === "merge" ? "the board merges it" : "done"}` : `next: ${rest.join(", ")}`;
+  const then = rest.length === 0 ? `then ${task.onDone === "merge" ? "the board merges it" : task.onDone === "ghpr" ? "the board merges its pull request" : "done"}` : `next: ${rest.join(", ")}`;
   const gated = stage?.gate === true ? ", gated" : "";
   return `- ${task.id} "${task.title}": ${stage?.name ?? task.stage} (${whose}, ${index + 1} of ${task.stages.length}${gated}); ${then}`;
 }
@@ -8435,7 +8771,7 @@ function buildTurnPrompt(input) {
     lines.push("A task you created is done. Tell whoever asked for it, if anyone did.");
   }
   if (dispatch.trigger.kind === "proposal_decided") {
-    lines.push("A proposal you made was decided; the decision is the last post in its thread. Carry on with what an approval enables or a rejection asks, and stay silent if nothing follows.");
+    lines.push("A proposal you made was decided; the decision is the last post in the proposal's thread. A decision wakes you in the conversation you filed the proposal from, or at home once that has ended. Carry on with what an approval enables or a rejection asks, and stay silent if nothing follows.");
   }
   if (dispatch.trigger.kind === "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.");
@@ -8450,7 +8786,8 @@ function buildTurnPrompt(input) {
   } else {
     const { thread, task } = conversation;
     const about = thread.subject === void 0 ? "a topic" : `${thread.subject.kind} ${thread.subject.id}`;
-    lines.push(`This turn is in the thread "${thread.title}" on ${thread.channel}, about ${about}. Only this conversation is below: read anything else you need with get_task, search, or the board's files, and leave other tasks and threads to their own turns. Talk here with post_message and thread_id ${thread.id}.`);
+    const talk = thread.state === "closed" ? `This thread is closed, so posts to it are refused: if something still needs saying, post it in ${conversation.replyIn ?? thread.channel}.` : `Talk here with post_message and thread_id ${thread.id}.`;
+    lines.push(`This turn is in the thread "${thread.title}" on ${thread.channel}, about ${about}. Only this conversation is below: read anything else you need with get_task, search, or the board's files, and leave other tasks and threads to their own turns. ${talk}`);
     if (task !== null) {
       lines.push("", `Task ${task.id} "${task.title}", ${task.status}:`, planLine(task, "now"));
       if (task.body.trim() !== "") {
@@ -8514,8 +8851,13 @@ function buildTurnPrompt(input) {
     }
   }
   const project = input.project;
-  if (project !== void 0 && project !== null && project.onDone === "merge") {
-    lines.push("", `## Project ${project.slug}`, "", `A finished task lands by the board merging its branch task/<id> into ${project.defaultBranch}. Never merge or fast-forward ${project.defaultBranch} yourself.`);
+  const landing = conversation?.task?.onDone ?? project?.onDone;
+  if (project !== void 0 && project !== null && landing === "merge") {
+    lines.push("", `## Project ${project.slug}`, "", `A finished task lands by the board merging its branch task/<id> into ${project.defaultBranch}. Never merge or fast-forward ${project.defaultBranch} yourself, or push other work to it on the remote; the runner refuses both.`);
+  }
+  if (project !== void 0 && project !== null && landing === "ghpr") {
+    const base = project.defaultBranch;
+    lines.push("", `## Project ${project.slug}`, "", `A finished task lands by the board merging its pull request on GitHub into ${base}. Open the pull request yourself, from a branch named for what it does that holds the same files as task/<id>, as \`git push origin task/<id>:<branch>\` gives, and link it to the task with update_task pull_request before its last stage completes, with the merge commit's merge_subject and merge_body, which you may change by linking again until it lands. Never merge the pull request or ${base} yourself, nor push other work to ${base}: the board merges once the task's stages are done, and the runner refuses the pushes. Abandoning the task closes its linked pull request and deletes its branch.`);
   }
   if (conflicts.length > 0) {
     lines.push("", "## Edits to reconcile in your home", "", "Two of your turns changed these files at once on different runners. The file in place kept the other turn's version; yours is the copy named here, beside it. Merge what still holds into the file, then delete the copy.", "", ...conflicts.map((conflict) => `- ${conflict.path}, beside ${conflict.file}, since ${conflict.since}`));
@@ -8719,7 +9061,12 @@ var TurnHost = class {
       }
     }
     const threadRecord = thread === void 0 ? void 0 : threads.get(thread.id) ?? await this.board.readThread(thread.id).catch(() => void 0);
-    const conversation = threadRecord === void 0 ? null : { thread: threadRecord, task, fresh: threadSoFar !== null };
+    const conversation = threadRecord === void 0 ? null : {
+      thread: threadRecord,
+      task,
+      fresh: threadSoFar !== null,
+      ...threadRecord.state === "closed" ? { replyIn: await this.replyIn(threadRecord) } : {}
+    };
     const ending = dispatch.trigger.kind === "closing" ? await this.endingOf(dispatch.project, threadRecord, task, channel) : null;
     const prompt = buildTurnPrompt({
       dispatch,
@@ -9122,11 +9469,7 @@ var TurnHost = class {
     if (project === null) {
       return { kind: "home", ...own };
     }
-    const repo = {
-      slug: project.slug,
-      origin: project.repo,
-      defaultBranch: project.defaultBranch
-    };
+    const repo = projectRepo(project);
     if (thread?.task === true) {
       return { kind: "task", repo, taskId: thread.id };
     }
@@ -9141,6 +9484,10 @@ var TurnHost = class {
     const conversation = workspaceConversationOf(job);
     return conversation !== null && await this.board.conversationEnded(conversation);
   }
+  /** Where a closed thread's citizens say what still needs saying: its channel, else its place's general. */
+  async replyIn(thread) {
+    return await this.board.channelOpen(thread.channel) ? thread.channel : channelRef(parseChannelRef(thread.channel).project, "general");
+  }
   /**
    * How a closing turn's conversation ended, and where its citizen asks someone else to take over
    * work that is not its own: the thread's channel while it is open, else the place's general.
@@ -9149,11 +9496,7 @@ var TurnHost = class {
     const place = scope === SOCIETY_SCOPE ? null : scope;
     if (thread !== void 0) {
       const closed = `the thread "${thread.title}" on ${thread.channel} was closed${thread.closedBy === void 0 ? "" : ` by ${thread.closedBy}`}${task === null ? "" : `, its task ${task.status}`}`;
-      const open = await this.board.channelOpen(thread.channel);
-      return {
-        how: closed,
-        askIn: open ? thread.channel : channelRef(parseChannelRef(thread.channel).project, "general")
-      };
+      return { how: closed, askIn: await this.replyIn(thread) };
     }
     if (channel === void 0) {
       return null;
@@ -9246,12 +9589,14 @@ var DEFAULT_REQUEST_TIMEOUT_MS = 10 * 6e4;
 var CONTROL_TIMEOUT_MS = 15e3;
 var FILE_TIMEOUT_MS = 6e4;
 var SWEEP_TIMEOUT_MS = 2 * 6e4;
+var DEFAULT_ACK_TIMEOUT_MS = 3e4;
 var RunnerHub = class {
   board;
   host;
   version;
   graceMs;
   requestTimeoutMs;
+  ackTimeoutMs;
   now;
   log;
   seats = /* @__PURE__ */ new Map();
@@ -9267,6 +9612,7 @@ var RunnerHub = class {
     this.version = options.version;
     this.graceMs = options.graceMs ?? DEFAULT_GRACE_MS;
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.ackTimeoutMs = options.ackTimeoutMs ?? DEFAULT_ACK_TIMEOUT_MS;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.log = options.log ?? SILENT2;
     this.startedAt = this.now().getTime();
@@ -9282,9 +9628,15 @@ var RunnerHub = class {
   // -------------------------------------------------------------------------------------------
   // The protocol, as the server's routes call it
   // -------------------------------------------------------------------------------------------
+  /** The jobs sent to a runner that it has not acknowledged yet. */
+  unacknowledged(runner) {
+    return [...this.seats.get(runner)?.unacked.keys() ?? []];
+  }
   /**
-   * A runner registers, first or again. Its turns in flight that it no longer runs, because it
-   * restarted, end as failed.
+   * A runner registers, first or again. A turn in flight it still runs, or whose job it never
+   * acknowledged, carries on, the latter sent again once its stream opens, since a job written
+   * into a stream that had stopped delivering never arrived; one it took and no longer runs,
+   * because it restarted, ends as failed.
    */
   async register(name, hello) {
     if (hello.protocol !== RUNNER_PROTOCOL) {
@@ -9299,25 +9651,31 @@ var RunnerHub = class {
         inUse: 0,
         warm: /* @__PURE__ */ new Set(),
         disconnectedAt: null,
-        grace: null
+        grace: null,
+        unacked: /* @__PURE__ */ new Map(),
+        unconfirmed: false
       });
     } 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)) {
+      if (still.has(turnId)) {
+        this.settle(unacked, turnId);
+      } else if (!unacked.has(turnId)) {
         await this.host.abortTurn(turnId, `runner ${name} restarted during the turn`);
       }
     }
     await this.board.markRunner(name, {
       os: hello.os,
       clis: hello.clis,
-      capabilities: hello.capabilities
+      capabilities: hello.capabilities,
+      version: hello.version
     });
     this.runnerChanged(name);
-    this.log.info({ runner: name, clis: hello.clis, slots: hello.slots }, "runner registered");
+    this.log.info({ runner: name, version: hello.version, clis: hello.clis, slots: hello.slots }, "runner registered");
     return { name, version: this.version };
   }
   /** A registered runner's stream opened. Returns what to call when it closes. */
@@ -9328,10 +9686,17 @@ var RunnerHub = class {
     }
     seat.send = send;
     seat.disconnectedAt = null;
+    seat.unconfirmed = false;
     if (seat.grace !== null) {
       clearTimeout(seat.grace);
       seat.grace = null;
     }
+    for (const { job } of seat.unacked.values()) {
+      if (send({ type: "turn", job })) {
+        this.expectAck(seat, job);
+        this.log.info({ runner: name, turnId: job.turnId }, "sent again a job the runner never took");
+      }
+    }
     await this.board.markRunner(name, { status: "connected" });
     this.runnerChanged(name);
     return async () => {
@@ -9356,6 +9721,9 @@ var RunnerHub = class {
         clearTimeout(seat.grace);
         seat.grace = null;
       }
+      for (const { timer } of seat.unacked.values()) {
+        clearTimeout(timer);
+      }
     }
     await Promise.allSettled(this.detaching);
   }
@@ -9363,6 +9731,18 @@ var RunnerHub = class {
     this.assertOwns(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");
+    }
+  }
   async turnOutcome(runner, turnId, outcome) {
     this.assertOwns(runner, turnId);
     const ack = await this.host.closeTurn(turnId, outcome);
@@ -9506,7 +9886,7 @@ var RunnerHub = class {
       return { refused: `${agent.name} has no CLI binding` };
     }
     const cli = agent.cli;
-    const free = (seat) => seat.send !== null && seat.hello.clis.includes(cli) && (seat.hello.slots === null || seat.inUse < seat.hello.slots);
+    const free = (seat) => seat.send !== null && !seat.unconfirmed && seat.hello.clis.includes(cli) && (seat.hello.slots === null || seat.inUse < seat.hello.slots);
     let chosen;
     if (dispatch.project === SOCIETY_SCOPE) {
       chosen = await this.pinnedSeat(agent.name, agent.homeRunner, cli, free);
@@ -9545,6 +9925,7 @@ var RunnerHub = class {
       return this.host.refuseTurn(dispatch, "none", assignment.refused);
     }
     const seat = this.seats.get(assignment.runner);
+    let turnId = null;
     try {
       if (seat === void 0) {
         return await this.host.refuseTurn(dispatch, assignment.runner, "the runner is gone");
@@ -9555,11 +9936,17 @@ var RunnerHub = class {
       }
       if (seat.send === null || !seat.send({ type: "turn", job: opened.job })) {
         await this.host.abortTurn(opened.job.turnId, `runner ${seat.name} went away before the turn`);
+      } else {
+        this.expectAck(seat, opened.job);
       }
+      turnId = opened.job.turnId;
       return await opened.ended;
     } finally {
       if (seat !== void 0) {
         seat.inUse = Math.max(0, seat.inUse - 1);
+        if (turnId !== null) {
+          this.settle(seat.unacked, turnId);
+        }
       }
     }
   }
@@ -9568,7 +9955,7 @@ var RunnerHub = class {
     if (!task.completing) {
       return "done";
     }
-    if (task.onDone !== "merge") {
+    if (task.onDone === "none") {
       await this.board.finishCompletion(SYSTEM_ACTOR, {
         taskId,
         ok: true,
@@ -9578,6 +9965,15 @@ var RunnerHub = class {
     }
     const record = await this.board.readProject(project);
     const branch = `task/${taskId}`;
+    const pull = task.onDone === "ghpr" ? task.pullRequest : void 0;
+    if (task.onDone === "ghpr" && pull === void 0) {
+      await this.board.finishCompletion(SYSTEM_ACTOR, {
+        taskId,
+        ok: false,
+        detail: "no pull request is linked to the task"
+      });
+      return "done";
+    }
     let outcome = { ok: true, detail: "nothing to land, since the task left no branch" };
     if (record.runner !== void 0) {
       const seat = this.seats.get(record.runner);
@@ -9589,8 +9985,15 @@ var RunnerHub = class {
           type: "land",
           request,
           land: {
-            repo: { slug: record.slug, origin: record.repo, defaultBranch: record.defaultBranch },
-            branch
+            repo: projectRepo(record),
+            branch,
+            ...pull === void 0 ? {} : {
+              pullRequest: {
+                url: pull.url,
+                ...pull.subject === void 0 ? {} : { subject: pull.subject },
+                ...pull.body === void 0 ? {} : { body: pull.body }
+              }
+            }
           }
         })));
       } catch (error) {
@@ -9612,6 +10015,49 @@ var RunnerHub = class {
     });
     return "done";
   }
+  /**
+   * Closes the pull request of a `ghpr` task abandoned with one linked, on the runner its project
+   * lives on, whose `gh` login reaches GitHub, and records how it went on the task; `deferred`
+   * while that runner is away.
+   */
+  async closePullRequest(project, taskId) {
+    const { task } = await this.board.findTask(taskId);
+    const pull = task.pullRequest;
+    if (task.status !== "abandoned" || task.onDone !== "ghpr" || pull === void 0 || pull.closed !== void 0) {
+      return "done";
+    }
+    const record = await this.board.readProject(project);
+    let outcome = {
+      ok: false,
+      detail: `${project} lives on no runner yet, so none could close ${pull.url}`
+    };
+    if (record.runner !== void 0) {
+      const seat = this.seats.get(record.runner);
+      if (seat === void 0 || seat.send === null) {
+        return "deferred";
+      }
+      try {
+        outcome = MergeOutcomeSchema.parse(await this.request(seat, (request) => ({
+          type: "close",
+          request,
+          close: {
+            repo: projectRepo(record),
+            url: pull.url,
+            comment: `Closed by Stellaris: the task this pull request was opened for, "${task.title}", was abandoned.`
+          }
+        })));
+      } catch (error) {
+        this.log.warn({ project, taskId, error: String(error) }, "closing a pull request deferred");
+        return "deferred";
+      }
+    }
+    await this.board.recordPullRequestClosed(SYSTEM_ACTOR, {
+      taskId,
+      ok: outcome.ok,
+      detail: outcome.detail
+    });
+    return "done";
+  }
   /**
    * One path on a branch of a project's repository, read on the runner the project lives on.
    * NOT_FOUND when the project has no runner yet or the branch or the path does not exist, and
@@ -9666,6 +10112,34 @@ 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.
+   */
+  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 });
+  }
+  settle(unacked, turnId) {
+    const entry = unacked.get(turnId);
+    if (entry !== void 0) {
+      clearTimeout(entry.timer);
+      unacked.delete(turnId);
+    }
+  }
   async detach(seat) {
     seat.send = null;
     this.runnerChanged(seat.name);
@@ -9686,7 +10160,7 @@ var RunnerHub = class {
         return;
       }
       for (const turnId of this.host.turnsOn(seat.name)) {
-        void this.host.abortTurn(turnId, `runner ${seat.name} went away during the turn`);
+        void this.host.abortTurn(turnId, seat.unacked.has(turnId) ? `the turn never reached runner ${seat.name}, which went away` : `runner ${seat.name} went away during the turn`);
       }
     }, this.graceMs);
     seat.grace.unref?.();
@@ -9763,7 +10237,7 @@ var RunnerHub = class {
     }
     return {
       seat,
-      repo: { slug: record.slug, origin: record.repo, defaultBranch: record.defaultBranch }
+      repo: projectRepo(record)
     };
   }
   assertOwns(runner, turnId) {
@@ -10228,6 +10702,10 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
     await hub.turnEvents(c.get("runner"), UlidSchema.parse(c.req.param("id")), entries);
     return c.json({ ok: true });
   });
+  routes.post("/turns/:id/received", (c) => {
+    hub.received(c.get("runner"), UlidSchema.parse(c.req.param("id")));
+    return c.json({ ok: true });
+  });
   routes.post("/turns/:id/outcome", async (c) => c.json(await hub.turnOutcome(c.get("runner"), UlidSchema.parse(c.req.param("id")), TurnOutcomeSchema.parse(await c.req.json()))));
   routes.post("/requests/:id", async (c) => {
     hub.answer(c.get("runner"), c.req.param("id"), RunnerAnswerSchema.parse(await c.req.json()));
@@ -10402,6 +10880,7 @@ function createApp(deps) {
   });
   api.delete("/sign-in", async (c) => c.json({ signedOut: await board2.signOut(bearer2(c) ?? "") }));
   api.get("/society", async (c) => c.json(await board2.society()));
+  api.get("/version", (c) => c.json({ version }));
   api.get("/agents", async (c) => c.json((await board2.listAgents()).map(({ tokenHash: _hash, ...agent }) => agent)));
   api.get("/members", async (c) => c.json(await board2.listMembers()));
   api.get("/agents/:name/turns", async (c) => c.json(await board2.listTurns(c.req.param("name"), Number(c.req.query("limit") ?? "50"))));