@kubitnodes/stellaris 0.3.10 → 0.3.12

package/dist/cli/index.js

@@ -57,7 +57,10 @@ var VERB_NAMES = [
   "advance_task",
   "configure_project",
   "archive_project",
-  "remove_knowledge"
+  "remove_knowledge",
+  "create_channel",
+  "archive_channel",
+  "update_dashboard"
 ];
 var VerbNameSchema = z2.enum(VERB_NAMES);
 var CharterTriggerSchema = z2.enum(["user_post", "ops_event", "heartbeat"]);
@@ -103,11 +106,16 @@ 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"];
-var PLANNING_VERBS = ["configure_project"];
+var PLANNING_VERBS = [
+  "configure_project",
+  "create_channel",
+  "archive_channel"
+];
 var ARCHIVE_VERBS = ["archive_project"];
 var SEED_ROLES = [
   {
@@ -129,7 +137,7 @@ var SEED_ROLES = [
   },
   {
     name: "steward",
-    purpose: "Watches the operations signals and the task board for capacity, skill, and capability gaps, and turns signals into proposals: a member when a project's plans need a role nobody fills or a backlog persists, a role when a project's work needs one no existing role covers, a retirement when a member has been idle for a long time, a channel when a topic needs one. Owns how work is shaped over time: answers stages waiting too long, stages assigned to roles nobody fills, and work sent back again and again by replanning with plan_task, adjusting gates, or proposing the role a plan needs; sets each project's completion effect with configure_project; turns recurring plan shapes into society skills and planning norms into the society's norms. Prefers scaling an existing role over inventing a new one. Never approves its own proposals; hiring, roles, and retirements are decided by the user, and channels, reallocations, and skills the steward may decide. Curates society knowledge and skills.",
+    purpose: "Watches the operations signals and the task board for capacity, skill, and capability gaps, and turns signals into proposals: a member when a project's plans need a role nobody fills or a backlog persists, a role when a project's work needs one no existing role covers, a retirement when a member has been idle for a long time. Opens a channel with create_channel when a topic or a workstream needs one, and archives it once its work is done. Owns how work is shaped over time: answers stages waiting too long, stages assigned to roles nobody fills, and work sent back again and again by replanning with plan_task, adjusting gates, or proposing the role a plan needs; sets each project's completion effect with configure_project; turns recurring plan shapes into society skills and planning norms into the society's norms. Prefers scaling an existing role over inventing a new one. Never approves its own proposals; hiring, roles, and retirements are decided by the user, and channels, reallocations, and skills the steward may decide. Curates society knowledge and skills.",
     verbs: [...MEMBER_VERBS, ...GOVERNANCE_VERBS, ...PLANNING_VERBS],
     wakeTriggers: ["ops_event", "heartbeat"],
     maxReplicas: 1,
@@ -140,7 +148,7 @@ var SEED_ROLES = [
   },
   {
     name: "concierge",
-    purpose: "The society's front desk. Wakes on every post the user makes and routes it: a question gets an answer where it was asked, in its thread when it came in one; work in an area an existing project covers gets a task there, planned when it is created, since a project is a lasting area of work and not one request; work in a new area gets a project, created on the spot, and the member or role proposals it needs for the user to approve. Reorganizes projects when the user asks: creates or picks the project the work belongs in, adds the citizens it needs, files a task there to bring over what the old projects hold (their task branches and their knowledge), and once that task is done proposes archiving each old project for the user to approve. Plans every task it routes: names stages by the work, assigns each to a role or a citizen, and gates where a second pair of eyes is worth it: before anything lands in a shared deliverable, so always before a merge; before effects outside the society; and before results are presented as findings. When a task it created is done, tells the user. Reads the roster in every digest to choose citizens by role, reach, availability, and profile, and adds a citizen to a project when the work needs it. Mentions a citizen with @ only to hand it work outside a plan, since a mention wakes it and costs a turn; lists and describes citizens by plain name. Stays silent when the user already addressed a citizen and nothing else is needed. Never does the work itself and never decides hiring.",
+    purpose: "The society's front desk. Wakes on every post the user makes and routes it: a question gets an answer where it was asked, in its thread when it came in one; work in an area an existing project covers gets a task there, planned when it is created and filed in the channel of its workstream when it belongs to one, such as a release, which the concierge opens with create_channel and archives once the workstream is done, since a project is a lasting area of work and not one request; work in a new area gets a project, created on the spot, and the member or role proposals it needs for the user to approve. Reorganizes projects when the user asks: creates or picks the project the work belongs in, adds the citizens it needs, files a task there to bring over what the old projects hold (their task branches and their knowledge), and once that task is done proposes archiving each old project for the user to approve. Plans every task it routes: names stages by the work, assigns each to a role or a citizen, and gates where a second pair of eyes is worth it: before anything lands in a shared deliverable, so always before a merge; before effects outside the society; and before results are presented as findings. When a task it created is done, tells the user. Reads the roster in every digest to choose citizens by role, reach, availability, and profile, and adds a citizen to a project when the work needs it. Mentions a citizen with @ only to hand it work outside a plan, since a mention wakes it and costs a turn; lists and describes citizens by plain name. Stays silent when the user already addressed a citizen and nothing else is needed. Never does the work itself and never decides hiring.",
     verbs: [...MEMBER_VERBS, ...FRONT_DESK_VERBS, ...PLANNING_VERBS],
     wakeTriggers: ["user_post", "heartbeat"],
     maxReplicas: 1,
@@ -156,18 +164,62 @@ import { z as z3 } from "zod";
 var ASK_CHANNEL = "asks";
 var SOCIETY_CHANNELS = ["general", "governance", ASK_CHANNEL];
 var PROJECT_DEFAULT_CHANNELS = ["general"];
+function isBoardChannel(project2, name) {
+  const used = project2 === null ? SOCIETY_CHANNELS : PROJECT_DEFAULT_CHANNELS;
+  return used.includes(name);
+}
 var SOCIETY_SCOPE = "society";
 function wakeScope(member, project2) {
   return project2 !== null && member.memberships.includes(project2) ? project2 : SOCIETY_SCOPE;
 }
 var CliKindSchema = z3.enum(["claude", "codex"]);
+var ArchivedChannelSchema = z3.object({
+  name: NameSchema,
+  at: IsoDateTimeSchema,
+  by: NameSchema,
+  reason: z3.string().min(1)
+});
 var SocietySchema = z3.object({
   name: z3.string().min(1),
   version: z3.literal(1),
   createdAt: IsoDateTimeSchema,
-  channels: z3.array(NameSchema)
+  /** The channels that take posts; an archived one moves to `archivedChannels`. */
+  channels: z3.array(NameSchema),
+  archivedChannels: z3.array(ArchivedChannelSchema).default([])
+});
+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
 });
-var CompletionEffectSchema = z3.enum(["none", "merge"]);
 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 = {
@@ -189,7 +241,9 @@ var ProjectSchema = z3.object({
   name: z3.string().min(1),
   repo: z3.string().nullable(),
   defaultBranch: z3.string().min(1),
+  /** The channels that take posts; an archived one moves to `archivedChannels`. */
   channels: z3.array(NameSchema),
+  archivedChannels: z3.array(ArchivedChannelSchema).default([]),
   members: z3.array(NameSchema),
   approvers: z3.array(NameSchema),
   requiredCapabilities: z3.array(z3.string()),
@@ -260,6 +314,8 @@ var TaskReturnSchema = z3.object({
 var TaskFrontmatterSchema = z3.object({
   id: UlidSchema,
   project: NameSchema,
+  /** The channel of the project the task is filed in, where its thread hangs. */
+  channel: NameSchema.default("general"),
   title: z3.string().min(1),
   status: TaskStatusSchema,
   createdBy: NameSchema,
@@ -278,6 +334,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. */
@@ -370,6 +428,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()
 });
@@ -548,6 +608,14 @@ 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 ProposalFrontmatterSchema = z3.object({
   id: UlidSchema,
   kind: ProposalKindSchema,
@@ -606,7 +674,9 @@ var VerbInputs = {
     parent_id: UlidSchema.optional(),
     required_capabilities: z4.array(z4.string()).default([]),
     /** The plan; without it the task gets one stage, work, that anyone in the project may take. */
-    stages: z4.array(PlanStageSchema).min(1).optional()
+    stages: z4.array(PlanStageSchema).min(1).optional(),
+    /** A channel of the project the task belongs to, such as a release's; its thread opens there. */
+    channel: NameSchema.default("general")
   }),
   claim_task: z4.object({ task_id: UlidSchema }),
   release_task: z4.object({ task_id: UlidSchema }),
@@ -617,7 +687,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 }),
@@ -664,7 +743,21 @@ var VerbInputs = {
     /** The branch tasks start from and land on from now; tasks in play keep their branches. */
     default_branch: DefaultBranchSchema.optional()
   }),
-  archive_project: z4.object({ project: NameSchema, reason: z4.string().min(1) })
+  archive_project: z4.object({ project: NameSchema, reason: z4.string().min(1) }),
+  create_channel: z4.object({
+    /** A project, or null for a channel of the society. */
+    project: NameSchema.nullable().default(null),
+    name: NameSchema,
+    purpose: 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
@@ -697,12 +790,14 @@ var BOARD_EVENT_TYPES = [
   "proposal.decided",
   "proposal.provisioned",
   "channel.added",
+  "channel.archived",
   "role.added",
   "agent.retired",
   "agent.joined",
   "agent.left",
   "knowledge.written",
   "knowledge.removed",
+  "dashboard.updated",
   "skill.promoted",
   "runner.added",
   "user.signed_in",
@@ -718,7 +813,8 @@ var BOARD_EVENT_TYPES = [
   "turn.completed",
   "turn.failed",
   "merge.completed",
-  "merge.failed"
+  "merge.failed",
+  "workspace.leftovers"
 ];
 var BoardEventTypeSchema = z5.enum(BOARD_EVENT_TYPES);
 var BoardEventSchema = z5.object({
@@ -798,6 +894,8 @@ var LiveTurnEventSchema = z5.object({
   project: NameSchema,
   /** The thread whose conversation the turn is in; absent for the home conversation. */
   thread: UlidSchema.optional(),
+  /** The channel, never general, whose conversation the turn is in. */
+  channel: NameSchema.optional(),
   event: AgentEventSchema
 });
 
@@ -863,15 +961,25 @@ 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({ kind: z6.literal("home"), thread: UlidSchema.optional() }),
+  z6.object({
+    kind: z6.literal("home"),
+    thread: UlidSchema.optional(),
+    channel: NameSchema.optional()
+  }),
   z6.object({
     kind: z6.literal("project"),
     repo: ProjectRepoSchema,
     branches: z6.array(z6.string().min(1)),
-    thread: UlidSchema.optional()
+    thread: UlidSchema.optional(),
+    channel: NameSchema.optional()
   }),
   z6.object({ kind: z6.literal("task"), repo: ProjectRepoSchema, taskId: UlidSchema })
 ]);
@@ -887,6 +995,8 @@ var TurnJobSchema = z6.object({
   scope: NameSchema,
   /** The thread whose conversation the turn is in; absent for the home conversation. */
   thread: UlidSchema.optional(),
+  /** The channel, never general, whose conversation the turn is in. */
+  channel: NameSchema.optional(),
   /**
    * The session to resume, or null to start one: the CLI's adapter picks a fresh session's id, and
    * the outcome reports it.
@@ -920,12 +1030,27 @@ var TurnOutcomeSchema = z6.object({
   session: z6.string().min(1),
   /** The model the CLI reported, when it reported one. */
   model: z6.string().nullable(),
-  work: TurnWorkSchema.nullable()
+  work: TurnWorkSchema.nullable(),
+  /**
+   * Whether the turn's own workspace, a thread's, a channel's, or a task's, holds work on no
+   * branch after the hand-back: uncommitted changes, or commits no branch contains.
+   */
+  leftovers: z6.boolean().default(false)
 });
 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 MergeOutcomeSchema = z6.object({ ok: z6.boolean(), detail: z6.string() });
 var ModelListSchema = z6.array(ModelOptionSchema);
@@ -979,6 +1104,17 @@ var BranchChangesSchema = z6.object({
   files: z6.array(BranchFileChangeSchema),
   total: z6.number().int().nonnegative()
 });
+var WorkspaceConversationSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("thread"), id: UlidSchema }),
+  z6.object({ kind: z6.literal("channel"), scope: NameSchema, name: NameSchema })
+]);
+var HeldWorkspaceSchema = z6.object({
+  agent: NameSchema,
+  scope: NameSchema,
+  conversation: WorkspaceConversationSchema
+});
+var HeldWorkspacesSchema = z6.object({ workspaces: z6.array(HeldWorkspaceSchema) });
+var SweepResultSchema = z6.object({ kept: z6.array(HeldWorkspaceSchema) });
 var TurnSteerSchema = z6.object({ id: z6.uuid(), text: z6.string().min(1) });
 var RunnerMessageSchema = z6.discriminatedUnion("type", [
   z6.object({ type: z6.literal("turn"), job: TurnJobSchema }),
@@ -1000,7 +1136,16 @@ var RunnerMessageSchema = z6.discriminatedUnion("type", [
     steer: TurnSteerSchema
   }),
   /** Answered with whether the turn was there to stop; it ends `stopped`. */
-  z6.object({ type: z6.literal("stop"), request: z6.string().min(1), turnId: UlidSchema })
+  z6.object({ type: z6.literal("stop"), request: z6.string().min(1), turnId: UlidSchema }),
+  /**
+   * A conversation ended: the runner removes every citizen's workspace for it but those a turn
+   * still uses, and answers with a `SweepResult` naming those it kept for holding work on no branch.
+   */
+  z6.object({
+    type: z6.literal("sweep"),
+    request: z6.string().min(1),
+    conversation: WorkspaceConversationSchema
+  })
 ]);
 var RunnerAnswerSchema = z6.discriminatedUnion("ok", [
   z6.object({ ok: z6.literal(true), value: z6.unknown() }),
@@ -1028,7 +1173,8 @@ var TriggerKindSchema = z7.enum([
   "onboarding",
   "manual",
   "ops_event",
-  "user_post"
+  "user_post",
+  "closing"
 ]);
 var TriggerSchema = z7.object({
   kind: TriggerKindSchema,
@@ -1045,10 +1191,20 @@ var TurnDispatchSchema = z7.object({
   agent: NameSchema,
   project: NameSchema,
   thread: TurnThreadSchema.optional(),
+  channel: NameSchema.optional(),
   trigger: TriggerSchema,
   priority: z7.number().int().min(0).max(2),
   onboarding: z7.boolean().default(false)
 });
+function conversationPart(conversation) {
+  return conversation.thread ?? (conversation.channel === void 0 ? void 0 : `#${conversation.channel}`);
+}
+function channelConversation(scope, channel) {
+  const at = channel.indexOf("/");
+  const place = at < 0 ? SOCIETY_SCOPE : channel.slice(0, at);
+  const name = at < 0 ? channel : channel.slice(at + 1);
+  return place === scope && name !== "general" ? name : void 0;
+}
 var TurnRecordSchema = z7.object({
   /** Assigned by the board when the turn begins; the turn's transcript is filed under it. */
   id: UlidSchema.optional(),
@@ -1056,6 +1212,8 @@ var TurnRecordSchema = z7.object({
   project: NameSchema,
   /** The thread whose conversation the turn was in; absent for the home conversation. */
   thread: UlidSchema.optional(),
+  /** The channel, never general, whose conversation the turn was in. */
+  channel: NameSchema.optional(),
   runner: NameSchema,
   cli: CliKindSchema.nullable(),
   session: z7.string().nullable(),
@@ -1085,8 +1243,9 @@ var RunningTurnSchema = z7.object({
   agent: NameSchema,
   scope: NameSchema,
   thread: UlidSchema.optional(),
+  channel: NameSchema.optional(),
   cli: CliKindSchema,
-  channel: ChannelRefSchema.optional(),
+  askedIn: ChannelRefSchema.optional(),
   steerable: z7.boolean(),
   stoppable: z7.boolean()
 });
@@ -1113,6 +1272,8 @@ var TurnHistoryEntrySchema = z7.object({
   project: NameSchema,
   /** The thread whose conversation the turn was in; absent for the home conversation. */
   thread: UlidSchema.optional(),
+  /** The channel, never general, whose conversation the turn was in. */
+  channel: NameSchema.optional(),
   trigger: z7.string(),
   exitReason: z7.string().nullable(),
   costUsd: z7.number(),
@@ -1139,7 +1300,8 @@ var OPS_SIGNAL_KINDS = [
   "turn_cost",
   "scaled",
   "runner",
-  "home_conflict"
+  "home_conflict",
+  "stuck_workspace"
 ];
 var OpsSignalKindSchema = z8.enum(OPS_SIGNAL_KINDS);
 var OpsSignalSchema = z8.object({
@@ -1301,7 +1463,7 @@ var RunnerConfigSchema = z10.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.10";
+var STELLARIS_VERSION = "0.3.12";
 
 // packages/board-core/dist/errors.js
 var BoardError = class extends Error {
@@ -1572,6 +1734,7 @@ var HOME_GITIGNORE = [
   "/projects/*/sessions*.json",
   "/projects/*/last-turn.json",
   "/projects/*/threads/",
+  "/projects/*/channels/",
   `/${HOME_SCRATCH}/`,
   "*.tmp",
   "node_modules/",
@@ -1589,7 +1752,7 @@ var HOME_GITIGNORE = [
 var IGNORE_FILE = `${HOME_GITIGNORE.join("\n")}
 `;
 var PRE_RECEIVE = `#!/bin/sh
-forbidden='^(agent\\.json|cursors\\.json|role\\.md|turns/|\\.claude/|\\.codex/|projects/[^/]+/(sessions[^/]*\\.json|last-turn\\.json|threads/))'
+forbidden='^(agent\\.json|cursors\\.json|role\\.md|turns/|\\.claude/|\\.codex/|projects/[^/]+/(sessions[^/]*\\.json|last-turn\\.json|threads/|channels/))'
 while read old new ref; do
   if [ "$ref" != "refs/heads/main" ]; then
     echo "a home takes pushes to main only" >&2
@@ -1850,6 +2013,7 @@ var TurnPayload = z11.object({
   turnId: z11.string().optional(),
   project: z11.string(),
   thread: z11.string().optional(),
+  channel: z11.string().optional(),
   trigger: z11.string()
 });
 var TaskPayload = z11.object({
@@ -1892,7 +2056,14 @@ function answers(mention, turn2) {
   if (turn2.thread !== null) {
     return mention.thread === turn2.thread;
   }
-  return mention.scopes.includes(turn2.project) && (mention.thread === null || turn2.trigger === "mention");
+  if (!mention.scopes.includes(turn2.project)) {
+    return false;
+  }
+  const own = mention.thread === null ? channelConversation(turn2.project, mention.channel) : void 0;
+  if (turn2.channel !== null) {
+    return mention.thread === null && own === turn2.channel;
+  }
+  return mention.thread === null && own === void 0 || turn2.trigger === "mention";
 }
 function computeMetrics(input) {
   const { events, now, window } = input;
@@ -1957,6 +2128,7 @@ function computeMetrics(input) {
           agent: event.actor,
           at,
           thread: turn2.data.thread ?? null,
+          channel: turn2.data.channel ?? null,
           project: turn2.data.project,
           trigger: turn2.data.trigger
         };
@@ -2053,6 +2225,7 @@ function computeMetrics(input) {
             at: Date.parse(event.ts),
             message: message.data.id ?? null,
             thread: thread2,
+            channel: message.data.channel,
             scopes: [project2, wakeScope(citizen, project2)].filter((scope) => scope !== null)
           });
         }
@@ -2328,9 +2501,12 @@ var BoardPaths = class {
   agentProject(name, slug) {
     return path5.join(this.agentProjects(name), slug);
   }
-  /** A thread conversation's session and last turn, beside the scope's home conversation. */
-  agentThread(name, slug, thread2) {
-    return path5.join(this.agentProject(name, slug), "threads", thread2);
+  /**
+   * A thread's or a channel's conversation's session and last turn, beside the scope's home
+   * conversation; `part` is a thread's id or `#channel`.
+   */
+  agentConversation(name, slug, part) {
+    return part.startsWith("#") ? path5.join(this.agentProject(name, slug), "channels", part.slice(1)) : path5.join(this.agentProject(name, slug), "threads", part);
   }
   agentCursors(name) {
     return path5.join(this.agent(name), "cursors.json");
@@ -2364,6 +2540,13 @@ function hashToken(token) {
 
 // packages/board-core/dist/board.js
 var SYSTEM_ACTOR = { name: "board", role: USER_ROLE };
+var CLOSING_ATTEMPTS = 3;
+function ownTurn(actor, turn2) {
+  return turn2.agent === actor.name && turn2.scope === actor.scope && turn2.thread === actor.thread && turn2.channel === actor.channel;
+}
+function namesList(names) {
+  return names.length <= 1 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names.at(-1) ?? ""}`;
+}
 var SKIPPED_IN_HOME = /* @__PURE__ */ new Set([".git", "turns", ".claude", ".codex"]);
 var RunnerTokensSchema = z12.object({
   runners: z12.record(z12.string(), z12.object({ tokenHash: z12.string().min(1) }))
@@ -2381,6 +2564,7 @@ var SignInsSchema = z12.object({
 var TurnHistoryPayloadSchema = z12.object({
   project: NameSchema,
   thread: UlidSchema.optional(),
+  channel: NameSchema.optional(),
   trigger: z12.string().default("manual"),
   exitReason: z12.string().nullable().default(null),
   costUsd: z12.number().default(0),
@@ -2396,12 +2580,23 @@ var CursorsSchema = z12.object({
   digest: z12.string().nullable(),
   scopes: z12.record(z12.string(), z12.string()).default({}),
   threadsFrom: z12.record(z12.string(), z12.string().nullable()).default({}),
+  channelsFrom: z12.record(z12.string(), z12.string().nullable()).default({}),
   /** How far a work role has read news, which goes to whichever of its general conversations reads first. */
   news: z12.string().optional()
 });
-var NO_CURSORS = { digest: null, scopes: {}, threadsFrom: {} };
-function conversationKey(scope, thread2) {
-  return thread2 === null ? scope : `${scope}/${thread2}`;
+var NO_CURSORS = { digest: null, scopes: {}, threadsFrom: {}, channelsFrom: {} };
+function conversationKey(scope, part) {
+  return part === null ? scope : `${scope}/${part}`;
+}
+function channelOfPart(part) {
+  return part?.startsWith("#") === true ? part.slice(1) : void 0;
+}
+function threadOfPart(part) {
+  return part === null || part === void 0 || part.startsWith("#") ? void 0 : part;
+}
+function channelStart(cursors, scope) {
+  const from = cursors.channelsFrom[scope];
+  return from === void 0 ? cursors.digest : from;
 }
 function threadStart(cursors, scope) {
   const from = cursors.threadsFrom[scope];
@@ -2414,11 +2609,11 @@ function newsStart(cursors) {
   const homes = Object.entries(cursors.scopes).filter(([key]) => !key.includes("/")).map(([, id]) => id).toSorted();
   return homes.at(-1) ?? cursors.digest;
 }
-function cursorOf(cursors, scope, thread2 = null) {
-  if (thread2 === null) {
+function cursorOf(cursors, scope, part = null) {
+  if (part === null) {
     return cursors.scopes[scope] ?? cursors.digest;
   }
-  return cursors.scopes[conversationKey(scope, thread2)] ?? threadStart(cursors, scope);
+  return cursors.scopes[conversationKey(scope, part)] ?? (part.startsWith("#") ? channelStart(cursors, scope) : threadStart(cursors, scope));
 }
 function byId(a, b) {
   return a.message.id < b.message.id ? -1 : a.message.id > b.message.id ? 1 : 0;
@@ -2429,6 +2624,9 @@ function turnTime(record) {
 var PausedSchema = z12.object({ paused: z12.boolean() });
 var DEFAULT_LEASE_MS = 30 * 60 * 1e3;
 var MENTION_PATTERN = /(^|[^\w@])@([a-z0-9][a-z0-9-]{0,31})(?![\w-])/g;
+function withoutMentions(text) {
+  return text.replaceAll(MENTION_PATTERN, "$1$2");
+}
 var CURATING_ROLES = [USER_ROLE, "steward"];
 var SEED_INSTRUCTIONS_HEADING = "## Seed instructions";
 var OPS_WAKE_TRIGGER = "ops_event";
@@ -2445,6 +2643,10 @@ var DECISIONS_CHANNEL_RETIRED = "decisions-channel-retired";
 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";
@@ -2481,6 +2683,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,
@@ -2575,6 +2782,8 @@ function snippetAround(text, query, radius = 80) {
 var Board = class _Board {
   paths;
   mutex = new Mutex();
+  /** The turns in flight, which the server hosting them supplies; none until it does. */
+  turnsInFlight = () => [];
   newId = monotonicFactory();
   events;
   actionCounts = /* @__PURE__ */ new Map();
@@ -2635,7 +2844,9 @@ var Board = class _Board {
       DECISIONS_CHANNEL_RETIRED,
       THREAD_CONVERSATIONS,
       ASKS_CHANNEL_OPENED,
-      KNOWLEDGE_REMOVAL
+      KNOWLEDGE_REMOVAL,
+      CHANNEL_CONVERSATIONS,
+      DASHBOARD_UPDATES
     ].filter((name) => !applied.includes(name));
     if (pending.length === 0) {
       return;
@@ -2665,18 +2876,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));
       }
     }
   }
@@ -2841,6 +3072,27 @@ var Board = class _Board {
       }
     }
   }
+  /**
+   * Every channel of a scope was once read in its home conversation, so a member had read each up
+   * to its scope's cursor. Each channel beside general starts from that cursor now, as each takes a
+   * conversation of its own.
+   */
+  async startChannelCursors() {
+    for (const agent2 of await this.listAgents()) {
+      const file = this.paths.agentCursors(agent2.name);
+      if (!await exists(file)) {
+        continue;
+      }
+      const cursors = await readJson(file, CursorsSchema);
+      const scopes = /* @__PURE__ */ new Set([
+        ...Object.keys(cursors.scopes).filter((key) => !key.includes("/")),
+        ...agent2.memberships,
+        SOCIETY_SCOPE
+      ]);
+      const channelsFrom = Object.fromEntries([...scopes].map((scope) => [scope, cursorOf(cursors, scope)]));
+      await writeJson(file, { ...cursors, channelsFrom });
+    }
+  }
   /**
    * Threads were once read in the scope's single conversation, so a member had read every thread
    * up to its scope's cursor. Each scope's threads start from that cursor now, as each thread's
@@ -2974,17 +3226,20 @@ ${charter.purpose}
   /**
    * A short-lived token for one turn, handed to the CLI by the runner. Only its hash is kept,
    * in memory, until it expires, so no raw agent token ever needs to exist at rest. The turn's
-   * scope and thread ride on the actor it resolves to, so `read_inbox` reads that conversation's
-   * digest.
+   * scope and conversation part, a thread's id or `#channel`, ride on the actor it resolves to, so
+   * `read_inbox` reads that conversation's digest.
    */
-  issueTurnToken(agent2, role2, ttlMs, scope, thread2) {
+  issueTurnToken(agent2, role2, ttlMs, scope, part) {
     const token = mintToken();
+    const thread2 = threadOfPart(part);
+    const channel = channelOfPart(part);
     this.turnTokens.set(hashToken(token), {
       actor: {
         name: agent2,
         role: role2,
         ...scope === void 0 ? {} : { scope },
-        ...thread2 === void 0 ? {} : { thread: thread2 }
+        ...thread2 === void 0 ? {} : { thread: thread2 },
+        ...channel === void 0 ? {} : { channel }
       },
       expiresAt: this.now().getTime() + ttlMs
     });
@@ -3284,34 +3539,44 @@ ${charter.purpose}
     }
     return (await readJson(file, PausedSchema)).paused;
   }
-  /** Every message in a channel, oldest first. Thread messages are listed with `listThread`. */
-  /** Every channel, the society's first, with how many messages it holds and its newest one. */
+  /**
+   * Every channel, the society's first, with how many messages it holds and its newest one; each
+   * place's archived channels follow its open ones.
+   */
   async listChannels() {
     const summaries = [];
-    const scopes = [
-      { project: null, names: (await this.society()).channels },
+    const society = await this.society();
+    const places = [
+      { project: null, names: society.channels, archived: society.archivedChannels },
       ...(await this.listProjects()).map((project2) => ({
         project: project2.slug,
-        names: project2.channels
+        names: project2.channels,
+        archived: project2.archivedChannels
       }))
     ];
-    for (const { project: project2, names } of scopes) {
-      for (const name of names) {
-        const ref = channelRef(project2, name);
+    for (const { project: project2, names, archived } of places) {
+      const entries = [
+        ...names.map((name) => ({ name, archived: void 0 })),
+        ...archived.map((each) => ({ name: each.name, archived: each }))
+      ];
+      for (const entry of entries) {
+        const ref = channelRef(project2, entry.name);
         const files = await listFiles(this.paths.channelDir(ref));
         const last = files.at(-1)?.slice(0, 26) ?? null;
         summaries.push({
           ref,
           project: project2,
-          name,
+          name: entry.name,
           messages: files.length,
           lastMessageId: last,
-          lastAt: last === null ? null : new Date(decodeTime(last)).toISOString()
+          lastAt: last === null ? null : new Date(decodeTime(last)).toISOString(),
+          ...entry.archived === void 0 ? {} : { archived: entry.archived }
         });
       }
     }
     return summaries;
   }
+  /** Every message in a channel, oldest first. Thread messages are listed with `listThread`. */
   async listChannel(ref, limit = 200) {
     await this.assertChannelExists(ref);
     const messages = await this.readMessagesIn(this.paths.channelDir(ref), null);
@@ -3404,6 +3669,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,
@@ -3424,9 +3690,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,
@@ -3464,12 +3730,27 @@ Agents may edit this file. It is rendered by the board UI.
       return (await this.writeRoleUnlocked(actor.name, parsed, {})).charter;
     });
   }
+  /** Opens a channel in a project or the society for a workstream, such as a release's tasks. */
+  async createChannel(actor, input) {
+    const args = VerbInputs.create_channel.parse(input);
+    await this.authorize(actor, "create_channel");
+    return this.mutex.run(async () => {
+      await this.validateAddChannel(args);
+      return this.addChannelUnlocked(actor.name, args, {}, actor.name);
+    });
+  }
+  /** Archives a channel whose workstream is done; refused while a task filed there is in play. */
+  async archiveChannel(actor, input) {
+    const args = VerbInputs.archive_channel.parse(input);
+    await this.authorize(actor, "archive_channel");
+    return this.mutex.run(() => this.archiveChannelUnlocked(actor, args.channel, args.reason));
+  }
   /** Adds a channel to a project or to the society. Also what an approved channel proposal executes. */
   async addChannel(actor, input) {
     this.assertAdmin(actor);
     return this.mutex.run(async () => {
       await this.validateAddChannel(input);
-      return this.addChannelUnlocked(actor.name, input, {});
+      return this.addChannelUnlocked(actor.name, input, {}, actor.name);
     });
   }
   /**
@@ -3516,6 +3797,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);
@@ -3667,19 +3949,19 @@ Agents may edit this file. It is rendered by the board UI.
     return this.mutex.run(async () => {
       const stored = await this.readCursors(actor.name);
       const from = args.since_cursor === void 0 ? stored : { ...NO_CURSORS, digest: args.since_cursor };
-      const conversation = actor.scope === void 0 ? void 0 : { scope: actor.scope, thread: actor.thread ?? null };
+      const conversation = actor.scope === void 0 ? void 0 : { scope: actor.scope, part: conversationPart(actor) ?? null };
       const filed = (await this.digestSince(actor, from, conversation)).slice(0, args.limit);
       if (args.advance) {
         await this.advanceCursors(actor.name, filed);
       }
       const last = filed.at(-1)?.message.id;
-      const cursor = last ?? (conversation === void 0 ? from.digest : cursorOf(from, conversation.scope, conversation.thread));
+      const cursor = last ?? (conversation === void 0 ? from.digest : cursorOf(from, conversation.scope, conversation.part));
       return { messages: filed.map((entry) => entry.message), cursor };
     });
   }
   /**
    * How many unread digest messages a member has in each conversation: a scope's home, for its
-   * channels, or one of its threads. The heartbeat asks, so that it wakes a member where its unread
+   * general channel, one of its other channels, or one of its threads. 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
    * counted, and are read when the member wakes for something else: a task step's, which wakes
@@ -3690,7 +3972,7 @@ Agents may edit this file. It is rendered by the board UI.
     return this.mutex.run(async () => {
       const counts = /* @__PURE__ */ new Map();
       const unscoped = { name: actor.name, role: actor.role };
-      for (const { scope, thread: thread2, message, news } of await this.digestSince(unscoped, await this.readCursors(actor.name))) {
+      for (const { scope, part, message, news } of await this.digestSince(unscoped, await this.readCursors(actor.name))) {
         if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name) {
           continue;
         }
@@ -3698,8 +3980,13 @@ Agents may edit this file. It is rendered by the board UI.
         if (posted !== scope && scope !== SOCIETY_SCOPE) {
           continue;
         }
-        const key = conversationKey(scope, thread2);
-        const entry = counts.get(key) ?? { scope, thread: thread2, count: 0 };
+        const key = conversationKey(scope, part);
+        const entry = counts.get(key) ?? {
+          scope,
+          thread: threadOfPart(part) ?? null,
+          channel: channelOfPart(part) ?? null,
+          count: 0
+        };
         counts.set(key, { ...entry, count: entry.count + 1 });
       }
       return [...counts.values()];
@@ -3715,7 +4002,7 @@ Agents may edit this file. It is rendered by the board UI.
     const scopes = { ...cursors.scopes };
     let news = newsStart(cursors);
     let moved = false;
-    for (const { scope, thread: thread2, message, news: isNews } of filed) {
+    for (const { scope, part, message, news: isNews } of filed) {
       if (isNews === true) {
         if (news === null || message.id > news) {
           news = message.id;
@@ -3723,8 +4010,8 @@ Agents may edit this file. It is rendered by the board UI.
         }
         continue;
       }
-      const key = conversationKey(scope, thread2);
-      const current = scopes[key] ?? cursorOf(cursors, scope, thread2);
+      const key = conversationKey(scope, part);
+      const current = scopes[key] ?? cursorOf(cursors, scope, part);
       if (current === null || message.id > current) {
         scopes[key] = message.id;
         moved = true;
@@ -3743,29 +4030,32 @@ Agents may edit this file. It is rendered by the board UI.
    * message is filed in: what mentions the member, sits in a channel it follows, or belongs to a
    * thread it takes part in, and for the front desk, which every post by the user wakes, every post
    * by the user wherever it is. With a conversation, only what is filed there: for a thread, every
-   * message of the thread, since the conversation is about it; for a scope's home, its channel
-   * messages, since each thread is a conversation of its own.
+   * message of the thread, since the conversation is about it; for a channel's, that channel's
+   * top-level messages; for a scope's home, general's and those of a project the member is not in,
+   * since each thread and each other channel is a conversation of its own.
    */
   async digestSince(actor, cursors, conversation) {
-    if (conversation !== void 0 && conversation.thread !== null) {
-      const { scope, thread: thread2 } = conversation;
-      const found = await this.tryFindThread(thread2);
+    const conversationThread = threadOfPart(conversation?.part);
+    if (conversation !== void 0 && conversationThread !== void 0) {
+      const { scope, part } = conversation;
+      const found = await this.tryFindThread(conversationThread);
       if (found === null) {
         return [];
       }
-      const messages = await this.readMessagesIn(this.paths.threadMessages(found.threads, thread2), cursorOf(cursors, scope, thread2));
-      return messages.filter((message) => message.author !== actor.name).map((message) => ({ scope, thread: thread2, message })).toSorted(byId);
+      const messages = await this.readMessagesIn(this.paths.threadMessages(found.threads, conversationThread), cursorOf(cursors, scope, part));
+      return messages.filter((message) => message.author !== actor.name).map((message) => ({ scope, part, message })).toSorted(byId);
     }
     const agent2 = await this.readAgent(actor.name);
     const charter = await this.readRole(agent2.role);
     const subscribed = new Set(agent2.subscriptions);
     const frontDesk = charter.wakeTriggers.includes(FRONT_DESK_TRIGGER);
     const threadParticipation = /* @__PURE__ */ new Map();
+    const openChannels = /* @__PURE__ */ new Map();
     const collected = [];
     const newsFrom = charter.societyScope ? void 0 : newsStart(cursors);
     const scopes = conversation !== void 0 ? [conversation.scope] : [...agent2.memberships, SOCIETY_SCOPE];
     const starts = [
-      ...scopes.flatMap((each) => conversation === void 0 ? [cursorOf(cursors, each), threadStart(cursors, each)] : [cursorOf(cursors, each)]),
+      ...scopes.flatMap((each) => conversation === void 0 ? [cursorOf(cursors, each), threadStart(cursors, each), channelStart(cursors, each)] : [cursorOf(cursors, each, conversation.part)]),
       ...newsFrom === void 0 ? [] : [newsFrom]
     ];
     const known = starts.filter((start) => start !== null);
@@ -3778,20 +4068,24 @@ Agents may edit this file. It is rendered by the board UI.
         if ((newsFrom === null || message.id > newsFrom) && subscribed.has(message.channel) && message.author !== actor.name) {
           collected.push({
             scope: conversation?.scope ?? SOCIETY_SCOPE,
-            thread: null,
+            part: null,
             message,
             news: true
           });
         }
         continue;
       }
-      if (conversation !== void 0 && filedIn !== conversation.scope) {
-        continue;
+      const named = thread2 === null ? channelConversation(filedIn, message.channel) : void 0;
+      let open2 = named === void 0 ? void 0 : openChannels.get(message.channel);
+      if (named !== void 0 && open2 === void 0) {
+        open2 = await this.channelOpen(message.channel);
+        openChannels.set(message.channel, open2);
       }
-      if (conversation !== void 0 && thread2 !== null) {
+      const part = thread2 ?? (open2 === true ? `#${named}` : null);
+      if (conversation !== void 0 && (filedIn !== conversation.scope || part !== conversation.part)) {
         continue;
       }
-      const cursor = cursorOf(cursors, filedIn, thread2);
+      const cursor = cursorOf(cursors, filedIn, part);
       if (cursor !== null && message.id <= cursor) {
         continue;
       }
@@ -3809,7 +4103,7 @@ Agents may edit this file. It is rendered by the board UI.
         include = participates;
       }
       if (include && message.author !== actor.name) {
-        collected.push({ scope: filedIn, thread: thread2, message });
+        collected.push({ scope: filedIn, part, message });
       }
     }
     return collected.toSorted(byId);
@@ -3978,6 +4272,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");
@@ -4048,7 +4378,7 @@ ${task2.body}`;
   taskThreadOpening(task2) {
     return {
       id: task2.id,
-      channel: channelRef(task2.project, "general"),
+      channel: channelRef(task2.project, task2.channel),
       title: task2.title,
       subject: { kind: "task", id: task2.id }
     };
@@ -4094,7 +4424,7 @@ ${task2.body}`;
       if (task2.status === "done" || task2.status === "abandoned") {
         throw new BoardError("INVALID_STATE", `task ${task2.id} is ${task2.status}`);
       }
-      const channel = args.channel ?? channelRef(project2, "general");
+      const channel = args.channel ?? channelRef(project2, task2.channel);
       if (parseChannelRef(channel).project !== project2) {
         throw new BoardError("VALIDATION", `a task's thread hangs off a channel of its project, ${project2}`);
       }
@@ -4127,6 +4457,44 @@ ${task2.body}`;
     await this.assertChannelOpen(args.channel);
     return { id: this.newId(), channel: args.channel, title: args.title };
   }
+  /**
+   * Where the board learns which turns are in flight, from the server that hosts them, so it
+   * refuses to end a conversation under someone else's turn.
+   */
+  watchTurns(source) {
+    this.turnsInFlight = source;
+  }
+  /**
+   * 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
+   * from inside it is how a citizen finishes there.
+   */
+  assertNoTurnCut(actor, what, cut) {
+    const busy = [
+      ...new Set(this.turnsInFlight().filter((turn2) => cut(turn2) && !ownTurn(actor, turn2)).map((turn2) => turn2.agent))
+    ].toSorted((a, b) => a.localeCompare(b));
+    if (busy.length === 0) {
+      return;
+    }
+    const one = busy.length === 1;
+    throw new BoardError("INVALID_STATE", `${what} while ${namesList(busy)} ${one ? "is in a turn" : "are in turns"} there; try again once ${one ? "it ends" : "they end"}, or stop ${one ? "it" : "them"}`);
+  }
+  /** The open threads in a folder of threads that `keep` picks. */
+  async openThreadIds(dir, keep) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const file of await listFiles(dir)) {
+      const doc = await readMarkdown(path6.join(dir, file), ThreadFrontmatterSchema);
+      if (doc.data.state === "open" && keep({ ...doc.data, body: doc.body })) {
+        ids.add(doc.data.id);
+      }
+    }
+    return ids;
+  }
+  /** Refuses to archive a project while a turn runs in it or in a thread its archive closes. */
+  async assertProjectQuiet(actor, slug) {
+    const threads = await this.openThreadIds(this.paths.threads(slug), () => true);
+    this.assertNoTurnCut(actor, `project ${slug} cannot be archived`, (turn2) => turn2.scope === slug || turn2.thread !== void 0 && threads.has(turn2.thread));
+  }
   async closeThread(actor, input) {
     const args = VerbInputs.close_thread.parse(input);
     await this.authorize(actor, "close_thread");
@@ -4141,6 +4509,7 @@ ${task2.body}`;
       if (!PLANNING_ROLES.includes(actor.role) && !await this.participatesInThread(actor, thread2, threads)) {
         throw new BoardError("FORBIDDEN", "only the thread's participants, the user, the steward, or the concierge may close it");
       }
+      this.assertNoTurnCut(actor, `thread ${thread2.id} cannot close`, (turn2) => turn2.thread === thread2.id);
       const summary = await this.writeMessage(this.paths.channelDir(thread2.channel), { author: actor.name, channel: thread2.channel, closes: thread2.id }, `Thread closed: "${thread2.title}" (${thread2.id}).
 
 ${args.summary}`);
@@ -4179,10 +4548,12 @@ ${args.summary}`);
       if (first === void 0) {
         throw new BoardError("VALIDATION", "a plan needs at least one stage");
       }
+      await this.assertChannelOpen(channelRef(args.project, args.channel));
       const ts = this.now().toISOString();
       const frontmatter = TaskFrontmatterSchema.parse({
         id: this.newId(),
         project: args.project,
+        channel: args.channel,
         title: args.title,
         status: "open",
         createdBy: actor.name,
@@ -4198,11 +4569,11 @@ ${args.summary}`);
         onDone: project2.onDone,
         completing: false
       });
-      await this.assertChannelExists(channelRef(args.project, "general"));
       const task2 = await this.writeTask(args.project, { ...frontmatter, body: args.body });
       await this.events.append("task.created", actor.name, {
         taskId: task2.id,
         project: task2.project,
+        channel: task2.channel,
         title: task2.title,
         parentId: task2.parentId ?? null,
         stage: task2.stage
@@ -4318,6 +4689,12 @@ ${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);
+      }
       const reworkDone = current.returned === void 0 || next === void 0 || index + 1 >= stageIndex(current, current.returned.from);
       const base = {
         ...current,
@@ -4431,6 +4808,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(", "));
@@ -4481,6 +4859,7 @@ ${args.summary}`);
         if (!mayAbandon) {
           throw new BoardError("FORBIDDEN", "only the holder, the creator, the user, the steward, or the concierge may abandon a task");
         }
+        this.assertNoTurnCut(actor, `task ${current.id} cannot be abandoned`, (turn2) => turn2.thread === current.id);
         next = {
           ...next,
           status: "abandoned",
@@ -4518,6 +4897,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);
@@ -4543,12 +4928,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");
@@ -4659,6 +5078,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 },
@@ -4682,6 +5104,7 @@ ${rationale}`}`);
     await this.authorize(actor, "archive_project");
     return this.mutex.run(async () => {
       await this.validateArchive(args.project);
+      await this.assertProjectQuiet(actor, args.project);
       return (await this.archiveUnlocked(actor.name, args.project, args.reason, {})).project;
     });
   }
@@ -4689,6 +5112,10 @@ ${rationale}`}`);
    * A citizen joins a project itself, or a reallocating role adds it. The pair gets its project
    * directory now and, through the `agent.joined` event, an onboarding turn.
    */
+  /**
+   * A member follows the project's general from the start; the result names the project's other
+   * open channels, which it subscribes to when its work there needs them.
+   */
   async joinProject(actor, input) {
     const args = VerbInputs.join_project.parse(input);
     await this.authorize(actor, "join_project");
@@ -4701,7 +5128,7 @@ ${rationale}`}`);
         throw new BoardError("INVALID_STATE", `${target} is retired`);
       }
       if (current.memberships.includes(args.project)) {
-        return current;
+        return { ...current, otherChannels: await this.otherChannels(args.project, current) };
       }
       await this.assertMayJoinProjects(target, current.role);
       const agent2 = await this.updateAgent(target, (a) => ({
@@ -4720,9 +5147,13 @@ ${rationale}`}`);
         project: args.project,
         cli: agent2.cli
       });
-      return agent2;
+      return { ...agent2, otherChannels: await this.otherChannels(args.project, agent2) };
     });
   }
+  /** The open channels of a project a citizen does not follow. */
+  async otherChannels(project2, agent2) {
+    return (await this.readProject(project2)).channels.map((name) => channelRef(project2, name)).filter((ref) => !agent2.subscriptions.includes(ref));
+  }
   async leaveProject(actor, input) {
     const args = VerbInputs.leave_project.parse(input);
     await this.authorize(actor, "leave_project");
@@ -4827,6 +5258,12 @@ ${rationale}`}`);
         return this.configureProject(actor, VerbInputs.configure_project.parse(input));
       case "archive_project":
         return this.archiveProject(actor, VerbInputs.archive_project.parse(input));
+      case "create_channel":
+        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)}`);
     }
@@ -4937,29 +5374,30 @@ ${rationale}`}`);
   /**
    * Moves a conversation's cursor forward to `cursor` once a turn there has delivered up to it. It
    * never moves back, so a turn that ends after a later one in the same conversation cannot rewind it.
+   * `part` names the conversation beside the scope's home: a thread's id or `#channel`.
    */
-  async setDigestCursor(agent2, scope, cursor, thread2) {
+  async setDigestCursor(agent2, scope, cursor, part) {
     await this.mutex.run(async () => {
       if (cursor === null) {
         return;
       }
       const cursors = await this.readCursors(agent2);
-      const current = cursorOf(cursors, scope, thread2 ?? null);
+      const current = cursorOf(cursors, scope, part ?? null);
       const news = newsStart(cursors);
-      const readNews = thread2 === void 0 && (news === null || cursor > news);
+      const readNews = part === void 0 && (news === null || cursor > news);
       if (current !== null && cursor <= current && !readNews) {
         return;
       }
       await writeJson(this.paths.agentCursors(agent2), {
         ...cursors,
-        scopes: current !== null && cursor <= current ? cursors.scopes : { ...cursors.scopes, [conversationKey(scope, thread2 ?? null)]: cursor },
+        scopes: current !== null && cursor <= current ? cursors.scopes : { ...cursors.scopes, [conversationKey(scope, part ?? null)]: cursor },
         ...readNews ? { news: cursor } : {}
       });
     });
   }
   /** Where a conversation's digest resumes: the newest message a turn there was shown. */
-  async digestCursor(agent2, scope, thread2) {
-    return this.mutex.run(async () => cursorOf(await this.readCursors(agent2), scope, thread2 ?? null));
+  async digestCursor(agent2, scope, part) {
+    return this.mutex.run(async () => cursorOf(await this.readCursors(agent2), scope, part ?? null));
   }
   /** Records that a running turn took posts delivered into it, which wake latency counts to. */
   async recordSteered(input) {
@@ -4968,25 +5406,29 @@ ${rationale}`}`);
         turnId: input.turnId,
         project: input.project,
         ...input.thread === void 0 ? {} : { thread: input.thread },
+        ...input.channel === void 0 ? {} : { channel: input.channel },
         messages: [...input.messages]
       });
     });
   }
-  /** Where a conversation's session ids and last turn are kept: the scope's home, or a thread's. */
-  sessionDir(agent2, scope, thread2) {
-    return thread2 === void 0 ? this.paths.agentProject(agent2, scope) : this.paths.agentThread(agent2, scope, thread2);
+  /**
+   * Where a conversation's session ids and last turn are kept: the scope's home, or beside it a
+   * thread's or a channel's, named by `part` as `conversationPart` gives it.
+   */
+  sessionDir(agent2, scope, part) {
+    return part === void 0 ? this.paths.agentProject(agent2, scope) : this.paths.agentConversation(agent2, scope, part);
   }
-  async readSessions(agent2, project2, thread2) {
-    const file = path6.join(this.sessionDir(agent2, project2, thread2), "sessions.json");
+  async readSessions(agent2, project2, part) {
+    const file = path6.join(this.sessionDir(agent2, project2, part), "sessions.json");
     return await exists(file) ? readJson(file, SessionsFileSchema) : {};
   }
   /**
    * Records a conversation's session for a CLI and the runner it began on. A session started on
    * another runner replaces the record, since sessions do not move between machines.
    */
-  async writeSession(agent2, project2, cli, sessionId, runner2, thread2) {
+  async writeSession(agent2, project2, cli, sessionId, runner2, part) {
     await this.mutex.run(async () => {
-      const dir = this.sessionDir(agent2, project2, thread2);
+      const dir = this.sessionDir(agent2, project2, part);
       await ensureDir(dir);
       const file = path6.join(dir, "sessions.json");
       const current = await exists(file) ? await readJson(file, SessionsFileSchema) : {};
@@ -4994,17 +5436,21 @@ ${rationale}`}`);
       await writeJson(file, { ...kept, [cli]: sessionId, runner: runner2 });
     });
   }
-  /** The last turn of one conversation: the scope's home, or a thread's. */
-  async readLastTurn(agent2, project2, thread2) {
-    const file = path6.join(this.sessionDir(agent2, project2, thread2), "last-turn.json");
+  /** The last turn of one conversation: the scope's home, a channel's, or a thread's. */
+  async readLastTurn(agent2, project2, part) {
+    const file = path6.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. */
   async readLatestTurn(agent2, project2) {
     let latest = await this.readLastTurn(agent2, project2);
-    const threads = path6.join(this.paths.agentProject(agent2, project2), "threads");
-    for (const thread2 of await listDirs(threads)) {
-      const turn2 = await this.readLastTurn(agent2, project2, thread2);
+    const place = this.paths.agentProject(agent2, project2);
+    const parts = [
+      ...await listDirs(path6.join(place, "threads")),
+      ...(await listDirs(path6.join(place, "channels"))).map((name) => `#${name}`)
+    ];
+    for (const part of parts) {
+      const turn2 = await this.readLastTurn(agent2, project2, part);
       if (turn2 !== null && (latest === null || turnTime(turn2) > turnTime(latest))) {
         latest = turn2;
       }
@@ -5021,6 +5467,7 @@ ${rationale}`}`);
         turnId: parsed.id,
         project: parsed.project,
         ...parsed.thread === void 0 ? {} : { thread: parsed.thread },
+        ...parsed.channel === void 0 ? {} : { channel: parsed.channel },
         trigger: parsed.trigger.kind,
         session: parsed.session,
         runner: parsed.runner
@@ -5046,13 +5493,15 @@ ${rationale}`}`);
           ...parsed.id === void 0 ? {} : { turnId: parsed.id },
           agent: parsed.agent,
           project: parsed.project,
-          ...parsed.thread === void 0 ? {} : { thread: parsed.thread }
+          ...parsed.thread === void 0 ? {} : { thread: parsed.thread },
+          ...parsed.channel === void 0 ? {} : { channel: parsed.channel }
         });
       }
       await this.events.append(failed ? "turn.failed" : "turn.completed", parsed.agent, {
         ...parsed.id === void 0 ? {} : { turnId: parsed.id },
         project: parsed.project,
         ...parsed.thread === void 0 ? {} : { thread: parsed.thread },
+        ...parsed.channel === void 0 ? {} : { channel: parsed.channel },
         trigger: parsed.trigger.kind,
         session: parsed.session,
         exitReason: parsed.exitReason,
@@ -5076,10 +5525,51 @@ ${rationale}`}`);
       });
     });
   }
+  /**
+   * 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
+   * nothing, once `CLOSING_ATTEMPTS` closing turns have been given for it.
+   */
+  async recordLeftovers(input) {
+    const { conversation } = input;
+    const payload = {
+      agent: input.agent,
+      project: input.scope,
+      ...conversation.kind === "thread" ? { thread: conversation.id } : { channel: conversation.name }
+    };
+    return this.mutex.run(async () => {
+      const earlier = (await this.events.readSince(null, Number.MAX_SAFE_INTEGER)).filter((event) => event.type === "workspace.leftovers" && Object.entries(payload).every(([key, value]) => event.payload[key] === value)).length;
+      if (earlier >= CLOSING_ATTEMPTS) {
+        return false;
+      }
+      await this.events.append("workspace.leftovers", SYSTEM_ACTOR.name, payload);
+      return true;
+    });
+  }
+  /**
+   * Whether a conversation with a workspace of its own has ended: a thread closed, a task ended
+   * (for one from before tasks had threads), or a channel archived.
+   */
+  async conversationEnded(conversation) {
+    if (conversation.kind === "channel") {
+      const place = conversation.scope === SOCIETY_SCOPE ? null : conversation.scope;
+      return !await this.channelOpen(channelRef(place, conversation.name));
+    }
+    const found = await this.tryFindThread(conversation.id);
+    if (found !== null) {
+      return found.thread.state === "closed";
+    }
+    try {
+      const { task: task2 } = await this.findTask(conversation.id);
+      return task2.status === "done" || task2.status === "abandoned";
+    } catch {
+      return false;
+    }
+  }
   /**
    * 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 () => {
@@ -5089,8 +5579,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) {
@@ -5110,8 +5600,8 @@ ${rationale}`}`);
         for (const name of new Set(task3.stages.flatMap((stage) => stage.completedBy ?? []))) {
           await this.refreshMember(name);
         }
-        if (merged) {
-          await this.appendMessage(actor.name, channelRef(location.project, "general"), `Task ${task3.id} "${task3.title}" is done: ${sentence(input.detail)}.`);
+        if (landed) {
+          await this.appendMessage(actor.name, channelRef(location.project, task3.channel), `Task ${task3.id} "${task3.title}" is done: ${sentence(input.detail)}.`);
         }
         return task3;
       }
@@ -5140,15 +5630,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 = [];
@@ -5348,7 +5854,7 @@ ${rationale}`}`);
     return this.files.read(this.paths.board, paths, () => true);
   }
   async writeTurnRecord(record) {
-    const dir = this.sessionDir(record.agent, record.project, record.thread);
+    const dir = this.sessionDir(record.agent, record.project, conversationPart(record));
     await ensureDir(dir);
     await writeJson(path6.join(dir, "last-turn.json"), record);
   }
@@ -5652,7 +6158,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         };
       }
       case "channel": {
-        const channel = await this.addChannelUnlocked(by, ChannelProposalSchema.parse(proposal2.charter), meta);
+        const channel = await this.addChannelUnlocked(by, ChannelProposalSchema.parse(proposal2.charter), meta, proposal2.proposedBy);
         return { channel };
       }
       case "role": {
@@ -5758,18 +6264,20 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     return { agent: agent2, token };
   }
   async validateAddChannel(input) {
-    if (input.project === null) {
-      if ((await this.society()).channels.includes(input.name)) {
-        throw new BoardError("ALREADY_EXISTS", `society channel ${input.name} already exists`);
-      }
-      return;
+    const place = input.project === null ? await this.society() : await this.readActiveProject(input.project);
+    const ref = channelRef(input.project, input.name);
+    if (place.channels.includes(input.name)) {
+      throw new BoardError("ALREADY_EXISTS", `channel ${ref} already exists`);
     }
-    const project2 = await this.readActiveProject(input.project);
-    if (project2.channels.includes(input.name)) {
-      throw new BoardError("ALREADY_EXISTS", `channel ${channelRef(input.project, input.name)} already exists`);
+    if (place.archivedChannels.some((each) => each.name === input.name)) {
+      throw new BoardError("ALREADY_EXISTS", `channel ${ref} was archived; open the new one under another name`);
     }
   }
-  async addChannelUnlocked(by, input, meta) {
+  /**
+   * Opens a channel, which `opener` follows from the start: the citizen who opened it or proposed
+   * it. Nobody else is subscribed, and the user, who reads channels directly, follows nothing.
+   */
+  async addChannelUnlocked(by, input, meta, opener) {
     const ref = channelRef(input.project, input.name);
     if (input.project === null) {
       const doc = await readMarkdown(this.paths.societyFile(), SocietySchema);
@@ -5783,14 +6291,104 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       }));
       await ensureDir(this.paths.projectChannel(project2, input.name));
     }
+    const follower = await this.readAgent(opener).catch(() => null);
+    const follows = follower !== null && follower.status === "active" && follower.role !== USER_ROLE;
+    if (follows) {
+      await this.updateAgent(opener, (agent2) => ({
+        ...agent2,
+        subscriptions: [.../* @__PURE__ */ new Set([...agent2.subscriptions, ref])]
+      }));
+      await this.refreshMember(opener);
+    }
     await this.events.append("channel.added", by, {
       channel: ref,
       purpose: input.purpose,
+      ...follows ? { followedBy: opener } : {},
       ...meta
     });
-    await this.appendMessage(SYSTEM_ACTOR.name, ref, `Channel ${ref} opened: ${input.purpose}`);
+    const purpose = withoutMentions(input.purpose);
+    await this.appendMessage(SYSTEM_ACTOR.name, ref, `Channel ${ref} opened: ${purpose}`);
+    await this.appendMessage(SYSTEM_ACTOR.name, channelRef(input.project, "general"), `Channel ${ref} opened by ${by}: ${purpose}. Subscribe to it to follow its posts; its tasks and mentions reach whoever they concern either way.`);
     return ref;
   }
+  /**
+   * Ends a channel: its open threads close, its followers stop following it, and it leaves the
+   * place's channels for its archived ones, where its history stays readable. The notice is the
+   * board's and leaves the reason out, since a board-authored mention would wake whoever it names.
+   */
+  async archiveChannelUnlocked(actor, ref, reason) {
+    const by = actor.name;
+    const { project: project2, channel } = parseChannelRef(ref);
+    if (isBoardChannel(project2, channel)) {
+      throw new BoardError("FORBIDDEN", `the board itself uses ${ref}, so it is never archived`);
+    }
+    await this.assertChannelOpen(ref);
+    if (project2 !== null) {
+      const inPlay = (await this.listTasks(project2)).filter((task2) => task2.channel === channel && task2.status !== "done" && task2.status !== "abandoned");
+      if (inPlay.length > 0) {
+        throw new BoardError("INVALID_STATE", `${inPlay.length} task(s) filed in ${ref} are still in play: ${inPlay.map((task2) => task2.id).join(", ")}`);
+      }
+    }
+    const ts = this.now().toISOString();
+    const threads = project2 === null ? this.paths.societyThreads() : this.paths.threads(project2);
+    const closing = await this.openThreadIds(threads, (thread2) => thread2.channel === ref);
+    const scope = project2 ?? SOCIETY_SCOPE;
+    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(path6.join(threads, file), ThreadFrontmatterSchema);
+      if (doc.data.channel !== ref || doc.data.state !== "open") {
+        continue;
+      }
+      await this.writeThread(threads, {
+        ...doc.data,
+        body: doc.body,
+        state: "closed",
+        closedBy: by,
+        closedAt: ts
+      });
+      await this.events.append("thread.closed", by, {
+        threadId: doc.data.id,
+        channel: ref,
+        ended: "archived"
+      });
+      threadsClosed.push(doc.data.id);
+    }
+    const unsubscribed = [];
+    for (const agent2 of await this.listAgents()) {
+      if (agent2.subscriptions.includes(ref)) {
+        await this.updateAgent(agent2.name, (a) => ({
+          ...a,
+          subscriptions: a.subscriptions.filter((each) => each !== ref)
+        }));
+        await this.refreshMember(agent2.name);
+        unsubscribed.push(agent2.name);
+      }
+    }
+    const archived = { name: channel, at: ts, by, reason };
+    if (project2 === null) {
+      const doc = await readMarkdown(this.paths.societyFile(), SocietySchema);
+      await writeMarkdown(this.paths.societyFile(), {
+        ...doc.data,
+        channels: doc.data.channels.filter((name) => name !== channel),
+        archivedChannels: [...doc.data.archivedChannels, archived]
+      }, doc.body);
+    } else {
+      await this.updateProject(project2, (current) => ({
+        ...current,
+        channels: current.channels.filter((name) => name !== channel),
+        archivedChannels: [...current.archivedChannels, archived]
+      }));
+    }
+    await this.events.append("channel.archived", by, {
+      channel: ref,
+      reason,
+      threadsClosed,
+      unsubscribed
+    });
+    await this.appendMessage(SYSTEM_ACTOR.name, channelRef(project2, "general"), `Channel ${ref} is archived by ${by}. Its posts, threads, and tasks stay readable; nothing more is posted or filed there.`);
+    return archived;
+  }
   /** A role becomes a society role only while none of its members is in a project. */
   async validateRole(charter) {
     if (charter.name === USER_ROLE) {
@@ -6003,23 +6601,35 @@ ${charter.purpose}
   async publishSignalUnlocked(signal) {
     return this.events.append("ops.signal", SYSTEM_ACTOR.name, OpsSignalSchema.parse(signal));
   }
+  /** A channel that exists, open or archived, and the record of its archive when it has one. */
   async assertChannelExists(ref) {
     const parsed = parseChannelRef(ref);
-    if (parsed.project === null) {
-      const society = await this.society();
-      if (!society.channels.includes(parsed.channel)) {
-        throw new BoardError("NOT_FOUND", `society channel ${ref} not found`);
-      }
-      return;
+    const place = parsed.project === null ? await this.society() : await this.readProject(parsed.project);
+    if (place.channels.includes(parsed.channel)) {
+      return void 0;
     }
-    const project2 = await this.readProject(parsed.project);
-    if (!project2.channels.includes(parsed.channel)) {
-      throw new BoardError("NOT_FOUND", `channel ${ref} not found`);
+    const archived = place.archivedChannels.find((each) => each.name === parsed.channel);
+    if (archived === void 0) {
+      throw new BoardError("NOT_FOUND", parsed.project === null ? `society channel ${ref} not found` : `channel ${ref} not found`);
     }
+    return archived;
   }
-  /** A channel that takes new posts, threads, and followers: it exists, and its project is not archived. */
+  /** Whether a channel exists and is not archived, its conversations still going. */
+  async channelOpen(ref) {
+    try {
+      return await this.assertChannelExists(ref) === void 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * A channel that takes new posts, threads, tasks, and followers: it exists, it is not archived,
+   * and its project is not archived.
+   */
   async assertChannelOpen(ref) {
-    await this.assertChannelExists(ref);
+    if (await this.assertChannelExists(ref) !== void 0) {
+      throw new BoardError("INVALID_STATE", `channel ${ref} is archived`);
+    }
     const { project: project2 } = parseChannelRef(ref);
     if (project2 !== null) {
       await this.readActiveProject(project2);
@@ -6119,6 +6729,10 @@ ${charter.purpose}
       if (outcome === "approved") {
         await this.validateProvision(proposal2.kind, proposal2.charter);
       }
+      this.assertNoTurnCut(actor, `proposal ${proposalId} cannot be decided`, (turn2) => turn2.thread === proposalId);
+      if (outcome === "approved" && proposal2.kind === "archive") {
+        await this.assertProjectQuiet(actor, ArchiveProposalSchema.parse(proposal2.charter).project);
+      }
       const ts = this.now().toISOString();
       const decision = DecisionSchema.parse({
         id: this.newId(),
@@ -6387,7 +7001,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) => {
@@ -6519,6 +7133,14 @@ channelCommand.command("add <ref>").description("Open a channel: <name> for the
   });
   print({ channel: added }, () => `Channel ${added} opened`);
 });
+channelCommand.command("archive <ref>").description("Archive a channel whose workstream is done, once no task filed there is in play").requiredOption("--reason <text>", "why its work is done").option("--as <agent>", "act as this agent instead of the user").action(async (ref, opts) => {
+  const board = await open();
+  const archived = await board.archiveChannel(await actorFor(board, opts.as), {
+    channel: ref,
+    reason: opts.reason
+  });
+  print(archived, () => `Channel ${ref} archived: ${archived.reason}`);
+});
 program.command("signals").description("Recent operations signals, oldest first").option("--limit <n>", "how many", "50").action(async (opts) => {
   const board = await open();
   const signals = await board.listSignals(Number(opts.limit));
@@ -6540,18 +7162,19 @@ program.command("ask <text>").description("Post to the society's general channel
   print(message, () => `Posted ${message.id} to general; the concierge wakes on it`);
 });
 var task = program.command("task").description("Manage tasks");
-task.command("create <project> <title>").description("Create a task with a plan, or with one stage anyone in the project may take").option("--body <text>", "task body", "").option("--parent <id>", "parent task id").option("--plan <json>", `stages, for example '[{"name":"analysis","role":"analyst"}]'`).option("--as <agent>", "act as this agent instead of the user").action(async (projectSlug, title, opts) => {
+task.command("create <project> <title>").description("Create a task with a plan, or with one stage anyone in the project may take").option("--body <text>", "task body", "").option("--parent <id>", "parent task id").option("--plan <json>", `stages, for example '[{"name":"analysis","role":"analyst"}]'`).option("--channel <name>", "the project's channel to file it in, such as a release's", "general").option("--as <agent>", "act as this agent instead of the user").action(async (projectSlug, title, opts) => {
   const board = await open();
   const who = await actorFor(board, opts.as);
   const created = await board.createTask(who, {
     project: projectSlug,
     title,
     body: opts.body,
+    channel: opts.channel,
     ...opts.parent === void 0 ? {} : { parent_id: opts.parent },
     ...opts.plan === void 0 ? {} : { stages: parsePlan(opts.plan) }
   });
   print(created, () => [
-    `Task ${created.id} created in ${created.project}: ${created.title}`,
+    `Task ${created.id} created in ${created.project}/${created.channel}: ${created.title}`,
     describePlan(created)
   ].join("\n"));
 });