@kubitnodes/stellaris 0.3.11 → 0.3.13

package/dist/cli/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)
+  })
 };
 
 // packages/shared/dist/events.js
@@ -735,6 +809,7 @@ var BOARD_EVENT_TYPES = [
   "agent.left",
   "knowledge.written",
   "knowledge.removed",
+  "dashboard.updated",
   "skill.promoted",
   "runner.added",
   "user.signed_in",
@@ -751,6 +826,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);
@@ -898,7 +975,12 @@ 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()
 });
 var TurnWorkspaceSchema = z6.discriminatedUnion("kind", [
   z6.object({
@@ -972,7 +1054,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);
@@ -1041,6 +1138,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 }),
@@ -1385,7 +1484,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 {
@@ -2566,6 +2665,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";
@@ -2602,6 +2704,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,
@@ -2759,7 +2866,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;
@@ -2789,21 +2897,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));
       }
     }
   }
@@ -3565,6 +3690,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 project2 = ProjectSchema.parse({
       slug: input.slug,
       name: input.name ?? input.slug,
@@ -3585,9 +3711,9 @@ ${charter.purpose}
     await ensureDir(this.paths.tasks(project2.slug));
     await ensureDir(this.paths.threads(project2.slug));
     await ensureDir(this.paths.projectKnowledge(project2.slug));
-    await writeMarkdown(this.paths.dashboard(project2.slug), { project: project2.slug, updatedAt: this.now().toISOString() }, `# ${project2.name} dashboard
+    await writeMarkdown(this.paths.dashboard(project2.slug), { project: project2.slug, revision: 0, updatedAt: this.now().toISOString() }, `# ${project2.name} dashboard
 
-Agents may edit this file. It is rendered by the board UI.
+${DASHBOARD_LINE}
 `);
     await this.updateAgent(USER_NAME, (user2) => ({
       ...user2,
@@ -3692,6 +3818,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);
@@ -4166,6 +4293,42 @@ ${task2.body}`;
       throw new BoardError("FORBIDDEN", `${actor.name} is not a member of ${project2}`);
     }
   }
+  /**
+   * 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 project2 = await this.readActiveProject(args.project);
+      if (actor.role !== USER_ROLE && !project2.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");
@@ -4547,6 +4710,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`, (turn2) => turn2.thread === current.id);
       }
@@ -4663,6 +4829,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(", "));
@@ -4751,6 +4918,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);
@@ -4776,12 +4949,46 @@ ${args.summary}`);
           project: location.project,
           from: current.status,
           to: task2.status,
-          note: args.note ?? null
+          note: args.note ?? null,
+          ...args.pull_request === void 0 ? {} : { pullRequest: task2.pullRequest?.url ?? null }
         });
       }
       return task2;
     });
   }
+  /**
+   * 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, task2, link) {
+    this.assertInPlay(task2);
+    if (task2.completing) {
+      throw new BoardError("INVALID_STATE", `task ${task2.id} is landing, so its pull request no longer changes`);
+    }
+    if (!PLANNING_ROLES.includes(actor.role)) {
+      const agent2 = await this.readAgent(actor.name);
+      if (!agent2.memberships.includes(task2.project)) {
+        throw new BoardError("FORBIDDEN", `${actor.name} is not a member of ${task2.project}`);
+      }
+    }
+    if (link === null) {
+      return void 0;
+    }
+    const project2 = await this.readProject(task2.project);
+    const repository = githubRepository(project2.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 ${project2.slug}'s repository${project2.repo === null ? ", since it has no remote" : ` at ${project2.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");
@@ -4839,6 +5046,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
@@ -4892,6 +5106,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 project2 = await this.updateProject(args.project, (current) => ({
         ...current,
         ...args.on_done === void 0 ? {} : { onDone: args.on_done },
@@ -5073,6 +5290,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)}`);
     }
@@ -5334,6 +5553,29 @@ ${rationale}`}`);
       });
     });
   }
+  /**
+   * Records how closing an abandoned `ghpr` task's pull request on GitHub went, once: the task's
+   * link keeps it, so a restart does not try again.
+   */
+  async recordPullRequestClosed(actor, input) {
+    return this.mutex.run(async () => {
+      const location = await this.findTask(input.taskId);
+      const current = location.task;
+      const pull = current.pullRequest;
+      if (pull === void 0 || pull.closed !== void 0) {
+        return current;
+      }
+      const task2 = await this.writeTask(location.project, {
+        ...current,
+        pullRequest: {
+          ...pull,
+          closed: { at: this.now().toISOString(), ok: input.ok, detail: input.detail }
+        }
+      });
+      await this.events.append(input.ok ? "pull_request.closed" : "pull_request.close_failed", actor.name, { project: location.project, taskId: task2.id, url: pull.url, detail: input.detail });
+      return task2;
+    });
+  }
   /**
    * Records that a citizen's workspace in a conversation that has ended holds work on no branch, so
    * the scheduler gives the citizen a closing turn there to decide about it. False, recording
@@ -5377,8 +5619,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 () => {
@@ -5388,8 +5630,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) {
@@ -5409,7 +5651,7 @@ ${rationale}`}`);
         for (const name of new Set(task3.stages.flatMap((stage) => stage.completedBy ?? []))) {
           await this.refreshMember(name);
         }
-        if (merged) {
+        if (landed) {
           await this.appendMessage(actor.name, channelRef(location.project, task3.channel), `Task ${task3.id} "${task3.title}" is done: ${sentence(input.detail)}.`);
         }
         return task3;
@@ -5439,15 +5681,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 runners = [];
@@ -6550,7 +6808,8 @@ ${charter.purpose}
         proposalId,
         outcome,
         kind: proposal2.kind,
-        proposedBy: proposal2.proposedBy
+        proposedBy: proposal2.proposedBy,
+        ...proposal2.filedFrom === void 0 ? {} : { filedFrom: proposal2.filedFrom }
       });
       if (provision !== void 0) {
         await this.events.append("proposal.provisioned", actor.name, {
@@ -6794,7 +7053,7 @@ 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 open();
   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.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.os}${each.version === void 0 ? "" : `  v${each.version}`}  ${each.clis.join(",") || "no CLIs yet"}${each.capabilities.length === 0 ? "" : `  ${each.capabilities.join(",")}`}`).join("\n"));
 });
 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) => {