@kubitnodes/stellaris 0.3.10 → 0.3.12

package/dist/server/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(project, name) {
+  const used = project === null ? SOCIETY_CHANNELS : PROJECT_DEFAULT_CHANNELS;
+  return used.includes(name);
+}
 var SOCIETY_SCOPE = "society";
 function wakeScope(member, project) {
   return project !== null && member.memberships.includes(project) ? project : 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)
+  })
 };
 var VERB_DESCRIPTIONS = {
   post_message: "Post a markdown message to a channel, or into a thread when thread_id is given; a thread's message goes to the thread's channel.",
@@ -672,25 +765,28 @@ var VERB_DESCRIPTIONS = {
   search: "Search messages, tasks, and knowledge by text, optionally within a project or channel.",
   open_thread: "Open a thread on a channel with a title, for a topic of its own. Tasks and proposals have theirs already. Its messages reach only its participants and anyone mentioned.",
   close_thread: "Close a thread with a summary that is posted to the thread's channel. A task's thread closes with its task, a proposal's with its decision.",
-  create_task: "Create a task in a project with its plan: stages of {name, role or agent, gate}. Without stages it gets one stage, work, that anyone in the project may take. Its thread opens with it, under the task's id, for everything said about the work.",
+  create_task: "Create a task in a project with its plan: stages of {name, role or agent, gate}. Without stages it gets one stage, work, that anyone in the project may take. File it in a channel of the project, such as a release's, or general by default; its thread opens there with it, under the task's id, for everything said about the work.",
   claim_task: "Hold the task's current stage. Claims are leases renewed by every turn that touches the task.",
   release_task: "Let go of the stage you hold so someone else can take it.",
-  update_task: "Move a task back to an earlier stage, abandon it, or set what it is blocked by. A note is posted to the task's thread.",
+  update_task: "Move a task back to an earlier stage, abandon it, set what it is blocked by, or link its pull request (pull_request: url, with the merge commit's merge_subject and merge_body), which a ghpr task needs before its last stage completes. A note is posted to the task's thread.",
   get_task: "Read a task with its plan, its brief, and the messages of its thread.",
   subscribe: "Subscribe to a channel. Subscriptions feed your digest; they never wake you.",
   unsubscribe: "Unsubscribe from a channel.",
   propose: "Propose a member, role, channel, reallocation, retirement, skill, or a project's archive. The charter shape per kind is in your instructions. Opens the proposal's thread in governance with your rationale; approval provisions it.",
   approve: "Approve a proposal; the board then provisions it, posts the decision in the proposal's thread, and closes it. User and steward only, never on your own proposal.",
   reject: "Reject a proposal with a reason, posted in the proposal's thread, which closes. User and steward only, never on your own proposal.",
-  create_project: "Create a project with its general channel: a slug, a display name, a git remote when one exists, and optionally a completion effect (none or merge).",
-  join_project: "Join a project, or add another citizen to one when your role allows it. Membership gives the pair a worktree and an onboarding turn.",
+  create_project: "Create a project with its general channel: a slug, a display name, a git remote when one exists, and optionally a completion effect (none, merge, or ghpr for a GitHub remote).",
+  join_project: "Join a project, or add another citizen to one when your role allows it. Membership gives the pair a worktree and an onboarding turn, and follows the project's general; the result lists its other open channels, to subscribe to when the work needs them.",
   leave_project: "Leave a project, or remove another citizen from one when your role allows it.",
   write_knowledge: "Write or replace a knowledge topic: durable facts every member of a project should know, or with project null the society's shared knowledge (steward and user). Not a message; use post_message for those.",
   remove_knowledge: "Remove a knowledge topic that is wrong, superseded, or folded into another, so no turn or search finds it again. Whoever may write the topic may remove it; the board keeps its text aside for the user to restore.",
   plan_task: "Reshape a task's plan from the current stage onward, or after it while someone holds it: keep a stage by passing its id, drop it by leaving it out, add one without an id. Gated stages and on_done: user, steward, concierge.",
   advance_task: "Finish the stage you hold, with a note for the task's thread on what you did. The next stage becomes current; past the last one the task is done.",
-  configure_project: "Set a project's completion effect (none, or merge to land each finished task's branch on the default branch), its display name, or its default branch, any of them at once. The slug never changes.",
-  archive_project: "Archive a project whose work is finished or has moved: its members leave, its open threads close, and nothing more is posted, filed, or joined there, while its files and history stay. Refused while a task there is in play."
+  configure_project: "Set a project's completion effect (none; merge to land each finished task's branch on the default branch; ghpr, for a project on GitHub, to merge each finished task's linked pull request), its display name, or its default branch, any of them at once. Tasks already filed keep theirs. The slug never changes.",
+  archive_project: "Archive a project whose work is finished or has moved: its members leave, its open threads close, and nothing more is posted, filed, or joined there, while its files and history stay. Refused while a task there is in play.",
+  create_channel: "Open a channel in a project, or with project null in the society, for a workstream such as a release, whose tasks are filed there. You follow it; a notice in the place's general announces it, and members subscribe when it concerns them. User, steward, concierge.",
+  archive_channel: "Archive a channel whose workstream is done: its open threads close, its followers stop following it, and nothing more is posted or filed there, while its history stays readable. Refused while a task filed there is in play, and for the channels the board itself uses. User, steward, concierge.",
+  update_dashboard: "Replace the dashboard of a project you are a member of, the status page the user reads on its view, with a whole markdown body. Pass the revision from the frontmatter of the dashboard you read; if it was updated since, the call is refused with the current text to merge yours into. dashboard.md in the board projection is a copy, so editing it changes nothing."
 };
 
 // packages/shared/dist/events.js
@@ -723,12 +819,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",
@@ -744,7 +842,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({
@@ -824,6 +923,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
 });
 
@@ -839,6 +940,7 @@ var PATH_TOKENS = {
   worktree: "{{stellaris:worktree}}"
 };
 var SERVER_TOKEN = "{{stellaris:server}}";
+var WORKSPACE_TOKEN = "{{stellaris:workspace}}";
 var HOME_SCRATCH = "scratch";
 var HOME_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
 var RunnerHelloSchema = z6.object({
@@ -896,15 +998,33 @@ var PendingEnrollmentSchema = z6.object({
 var ProjectRepoSchema = z6.object({
   slug: NameSchema,
   origin: z6.string().nullable(),
-  defaultBranch: z6.string().min(1)
+  defaultBranch: z6.string().min(1),
+  /**
+   * The board lands finished tasks on the default branch, itself or through their pull requests,
+   * so the runner lets nothing else move it.
+   */
+  boardLands: z6.boolean()
 });
+function projectRepo(project) {
+  return {
+    slug: project.slug,
+    origin: project.repo,
+    defaultBranch: project.defaultBranch,
+    boardLands: project.onDone !== "none"
+  };
+}
 var TurnWorkspaceSchema = z6.discriminatedUnion("kind", [
-  z6.object({ kind: z6.literal("home"), 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 })
 ]);
@@ -920,6 +1040,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.
@@ -953,12 +1075,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);
@@ -1012,6 +1149,23 @@ 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 })
+]);
+function workspaceConversationOf(turn) {
+  if (turn.thread !== void 0) {
+    return { kind: "thread", id: turn.thread };
+  }
+  return turn.channel === void 0 ? null : { kind: "channel", scope: turn.scope, name: turn.channel };
+}
+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 }),
@@ -1033,7 +1187,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() }),
@@ -1061,7 +1224,8 @@ var TriggerKindSchema = z7.enum([
   "onboarding",
   "manual",
   "ops_event",
-  "user_post"
+  "user_post",
+  "closing"
 ]);
 var TriggerSchema = z7.object({
   kind: TriggerKindSchema,
@@ -1078,12 +1242,32 @@ 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 sessionKey(agent, scope, thread) {
-  return thread === void 0 ? `${agent}/${scope}` : `${agent}/${scope}/${thread}`;
+function conversationPart(conversation) {
+  return conversation.thread ?? (conversation.channel === void 0 ? void 0 : `#${conversation.channel}`);
+}
+function sessionKey(agent, scope, part) {
+  return part === void 0 ? `${agent}/${scope}` : `${agent}/${scope}/${part}`;
+}
+function parseSessionKey(key) {
+  const [agent, scope, part, rest] = key.split("/");
+  if (agent === void 0 || scope === void 0 || rest !== void 0) {
+    return null;
+  }
+  if (part === void 0) {
+    return { agent, scope };
+  }
+  return part.startsWith("#") ? { agent, scope, channel: part.slice(1) } : { agent, scope, thread: part };
+}
+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. */
@@ -1092,6 +1276,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(),
@@ -1121,8 +1307,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()
 });
@@ -1149,6 +1336,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(),
@@ -1175,7 +1364,8 @@ var OPS_SIGNAL_KINDS = [
   "turn_cost",
   "scaled",
   "runner",
-  "home_conflict"
+  "home_conflict",
+  "stuck_workspace"
 ];
 var OpsSignalKindSchema = z8.enum(OPS_SIGNAL_KINDS);
 var WAKING_SIGNAL_KINDS = [
@@ -1382,7 +1572,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 {
@@ -1656,6 +1846,7 @@ var HOME_GITIGNORE = [
   "/projects/*/sessions*.json",
   "/projects/*/last-turn.json",
   "/projects/*/threads/",
+  "/projects/*/channels/",
   `/${HOME_SCRATCH}/`,
   "*.tmp",
   "node_modules/",
@@ -1673,7 +1864,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
@@ -1934,6 +2125,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({
@@ -1976,7 +2168,14 @@ function answers(mention, turn) {
   if (turn.thread !== null) {
     return mention.thread === turn.thread;
   }
-  return mention.scopes.includes(turn.project) && (mention.thread === null || turn.trigger === "mention");
+  if (!mention.scopes.includes(turn.project)) {
+    return false;
+  }
+  const own = mention.thread === null ? channelConversation(turn.project, mention.channel) : void 0;
+  if (turn.channel !== null) {
+    return mention.thread === null && own === turn.channel;
+  }
+  return mention.thread === null && own === void 0 || turn.trigger === "mention";
 }
 function computeMetrics(input) {
   const { events, now, window } = input;
@@ -2041,6 +2240,7 @@ function computeMetrics(input) {
           agent: event.actor,
           at,
           thread: turn.data.thread ?? null,
+          channel: turn.data.channel ?? null,
           project: turn.data.project,
           trigger: turn.data.trigger
         };
@@ -2137,6 +2337,7 @@ function computeMetrics(input) {
             at: Date.parse(event.ts),
             message: message.data.id ?? null,
             thread,
+            channel: message.data.channel,
             scopes: [project, wakeScope(citizen, project)].filter((scope) => scope !== null)
           });
         }
@@ -2412,9 +2613,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, thread) {
-    return path5.join(this.agentProject(name, slug), "threads", thread);
+  /**
+   * 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");
@@ -2448,6 +2652,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, turn) {
+  return turn.agent === actor.name && turn.scope === actor.scope && turn.thread === actor.thread && turn.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) }))
@@ -2465,6 +2676,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),
@@ -2480,12 +2692,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, thread) {
-  return thread === null ? scope : `${scope}/${thread}`;
+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];
@@ -2498,11 +2721,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, thread = null) {
-  if (thread === null) {
+function cursorOf(cursors, scope, part = null) {
+  if (part === null) {
     return cursors.scopes[scope] ?? cursors.digest;
   }
-  return cursors.scopes[conversationKey(scope, thread)] ?? 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;
@@ -2513,6 +2736,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";
@@ -2529,6 +2755,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";
@@ -2565,6 +2795,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,
@@ -2659,6 +2894,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();
@@ -2719,7 +2956,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;
@@ -2749,18 +2988,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));
       }
     }
   }
@@ -2925,6 +3184,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 agent of await this.listAgents()) {
+      const file = this.paths.agentCursors(agent.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("/")),
+        ...agent.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
@@ -3058,17 +3338,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(agent, role, ttlMs, scope, thread) {
+  issueTurnToken(agent, role, ttlMs, scope, part) {
     const token = mintToken();
+    const thread = threadOfPart(part);
+    const channel = channelOfPart(part);
     this.turnTokens.set(hashToken(token), {
       actor: {
         name: agent,
         role,
         ...scope === void 0 ? {} : { scope },
-        ...thread === void 0 ? {} : { thread }
+        ...thread === void 0 ? {} : { thread },
+        ...channel === void 0 ? {} : { channel }
       },
       expiresAt: this.now().getTime() + ttlMs
     });
@@ -3368,34 +3651,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((project) => ({
         project: project.slug,
-        names: project.channels
+        names: project.channels,
+        archived: project.archivedChannels
       }))
     ];
-    for (const { project, names } of scopes) {
-      for (const name of names) {
-        const ref = channelRef(project, name);
+    for (const { project, 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(project, entry.name);
         const files = await listFiles(this.paths.channelDir(ref));
         const last = files.at(-1)?.slice(0, 26) ?? null;
         summaries.push({
           ref,
           project,
-          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, limit2 = 200) {
     await this.assertChannelExists(ref);
     const messages = await this.readMessagesIn(this.paths.channelDir(ref), null);
@@ -3488,6 +3781,7 @@ ${charter.purpose}
     if (await exists(file)) {
       throw new BoardError("ALREADY_EXISTS", `project ${input.slug} already exists`);
     }
+    assertLandsByPullRequest(input.onDone ?? "none", input.repo ?? null, `project ${input.slug}`);
     const project = ProjectSchema.parse({
       slug: input.slug,
       name: input.name ?? input.slug,
@@ -3508,9 +3802,9 @@ ${charter.purpose}
     await ensureDir(this.paths.tasks(project.slug));
     await ensureDir(this.paths.threads(project.slug));
     await ensureDir(this.paths.projectKnowledge(project.slug));
-    await writeMarkdown(this.paths.dashboard(project.slug), { project: project.slug, updatedAt: this.now().toISOString() }, `# ${project.name} dashboard
+    await writeMarkdown(this.paths.dashboard(project.slug), { project: project.slug, revision: 0, updatedAt: this.now().toISOString() }, `# ${project.name} dashboard
 
-Agents may edit this file. It is rendered by the board UI.
+${DASHBOARD_LINE}
 `);
     await this.updateAgent(USER_NAME, (user) => ({
       ...user,
@@ -3548,12 +3842,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);
     });
   }
   /**
@@ -3600,6 +3909,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);
@@ -3751,19 +4061,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
@@ -3774,7 +4084,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, 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;
         }
@@ -3782,8 +4092,13 @@ Agents may edit this file. It is rendered by the board UI.
         if (posted !== scope && scope !== SOCIETY_SCOPE) {
           continue;
         }
-        const key = conversationKey(scope, thread);
-        const entry = counts.get(key) ?? { scope, thread, 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()];
@@ -3799,7 +4114,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, 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;
@@ -3807,8 +4122,8 @@ Agents may edit this file. It is rendered by the board UI.
         }
         continue;
       }
-      const key = conversationKey(scope, thread);
-      const current = scopes[key] ?? cursorOf(cursors, scope, thread);
+      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;
@@ -3827,29 +4142,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 } = conversation;
-      const found = await this.tryFindThread(thread);
+    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, thread), cursorOf(cursors, scope, thread));
-      return messages.filter((message) => message.author !== actor.name).map((message) => ({ scope, thread, 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 agent = await this.readAgent(actor.name);
     const charter = await this.readRole(agent.role);
     const subscribed = new Set(agent.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] : [...agent.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);
@@ -3862,20 +4180,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 = thread === null ? channelConversation(filedIn, message.channel) : void 0;
+      let open = named === void 0 ? void 0 : openChannels.get(message.channel);
+      if (named !== void 0 && open === void 0) {
+        open = await this.channelOpen(message.channel);
+        openChannels.set(message.channel, open);
       }
-      if (conversation !== void 0 && thread !== null) {
+      const part = thread ?? (open === true ? `#${named}` : null);
+      if (conversation !== void 0 && (filedIn !== conversation.scope || part !== conversation.part)) {
         continue;
       }
-      const cursor = cursorOf(cursors, filedIn, thread);
+      const cursor = cursorOf(cursors, filedIn, part);
       if (cursor !== null && message.id <= cursor) {
         continue;
       }
@@ -3893,7 +4215,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, message });
+        collected.push({ scope: filedIn, part, message });
       }
     }
     return collected.toSorted(byId);
@@ -4062,6 +4384,42 @@ ${task.body}`;
       throw new BoardError("FORBIDDEN", `${actor.name} is not a member of ${project}`);
     }
   }
+  /**
+   * Replaces a project's dashboard, by a member or the user. A turn reads the dashboard from the
+   * copy of the projection pulled when it started, so a revision other than the current one means
+   * someone updated it since; the refusal carries the current text, which that copy lacks.
+   */
+  async updateDashboard(actor, input) {
+    const args = VerbInputs.update_dashboard.parse(input);
+    await this.authorize(actor, "update_dashboard");
+    return this.mutex.run(async () => {
+      const project = await this.readActiveProject(args.project);
+      if (actor.role !== USER_ROLE && !project.members.includes(actor.name)) {
+        throw new BoardError("FORBIDDEN", `${actor.name} is not a member of ${args.project}`);
+      }
+      const current = await this.dashboardOf(args.project);
+      if (args.revision !== current.revision) {
+        const by = current.updatedBy === void 0 ? "" : `, updated by ${current.updatedBy} at ${current.updatedAt ?? "an unknown time"}`;
+        throw new BoardError("INVALID_STATE", `the dashboard of ${args.project} is at revision ${current.revision}${by}, not ${args.revision}. Merge your changes into its current text, below, and update again with revision ${current.revision}.
+
+${current.body}`);
+      }
+      const updated = DashboardSchema.parse({
+        project: args.project,
+        revision: current.revision + 1,
+        updatedBy: actor.name,
+        updatedAt: this.now().toISOString(),
+        body: args.body
+      });
+      const { body, ...frontmatter } = updated;
+      await writeMarkdown(this.paths.dashboard(args.project), frontmatter, body);
+      await this.events.append("dashboard.updated", actor.name, {
+        project: args.project,
+        revision: updated.revision
+      });
+      return updated;
+    });
+  }
   async openThread(actor, input) {
     const args = VerbInputs.open_thread.parse(input);
     await this.authorize(actor, "open_thread");
@@ -4132,7 +4490,7 @@ ${task.body}`;
   taskThreadOpening(task) {
     return {
       id: task.id,
-      channel: channelRef(task.project, "general"),
+      channel: channelRef(task.project, task.channel),
       title: task.title,
       subject: { kind: "task", id: task.id }
     };
@@ -4178,7 +4536,7 @@ ${task.body}`;
       if (task.status === "done" || task.status === "abandoned") {
         throw new BoardError("INVALID_STATE", `task ${task.id} is ${task.status}`);
       }
-      const channel = args.channel ?? channelRef(project, "general");
+      const channel = args.channel ?? channelRef(project, task.channel);
       if (parseChannelRef(channel).project !== project) {
         throw new BoardError("VALIDATION", `a task's thread hangs off a channel of its project, ${project}`);
       }
@@ -4211,6 +4569,44 @@ ${task.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((turn) => cut(turn) && !ownTurn(actor, turn)).map((turn) => turn.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`, (turn) => turn.scope === slug || turn.thread !== void 0 && threads.has(turn.thread));
+  }
   async closeThread(actor, input) {
     const args = VerbInputs.close_thread.parse(input);
     await this.authorize(actor, "close_thread");
@@ -4225,6 +4621,7 @@ ${task.body}`;
       if (!PLANNING_ROLES.includes(actor.role) && !await this.participatesInThread(actor, thread, threads)) {
         throw new BoardError("FORBIDDEN", "only the thread's participants, the user, the steward, or the concierge may close it");
       }
+      this.assertNoTurnCut(actor, `thread ${thread.id} cannot close`, (turn) => turn.thread === thread.id);
       const summary = await this.writeMessage(this.paths.channelDir(thread.channel), { author: actor.name, channel: thread.channel, closes: thread.id }, `Thread closed: "${thread.title}" (${thread.id}).
 
 ${args.summary}`);
@@ -4263,10 +4660,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,
@@ -4282,11 +4681,11 @@ ${args.summary}`);
         onDone: project.onDone,
         completing: false
       });
-      await this.assertChannelExists(channelRef(args.project, "general"));
       const task = await this.writeTask(args.project, { ...frontmatter, body: args.body });
       await this.events.append("task.created", actor.name, {
         taskId: task.id,
         project: task.project,
+        channel: task.channel,
         title: task.title,
         parentId: task.parentId ?? null,
         stage: task.stage
@@ -4402,6 +4801,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`, (turn) => turn.thread === current.id);
+      }
       const reworkDone = current.returned === void 0 || next === void 0 || index + 1 >= stageIndex(current, current.returned.from);
       const base = {
         ...current,
@@ -4515,6 +4920,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(", "));
@@ -4565,6 +4971,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`, (turn) => turn.thread === current.id);
         next = {
           ...next,
           status: "abandoned",
@@ -4602,6 +5009,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);
@@ -4627,12 +5040,46 @@ ${args.summary}`);
           project: location.project,
           from: current.status,
           to: task.status,
-          note: args.note ?? null
+          note: args.note ?? null,
+          ...args.pull_request === void 0 ? {} : { pullRequest: task.pullRequest?.url ?? null }
         });
       }
       return task;
     });
   }
+  /**
+   * The pull request a task is linked to, or none for `null`: one on the repository of its project,
+   * by a member of the project or a planner, while the task is in play and before it lands.
+   */
+  async pullRequestLink(actor, task, link) {
+    this.assertInPlay(task);
+    if (task.completing) {
+      throw new BoardError("INVALID_STATE", `task ${task.id} is landing, so its pull request no longer changes`);
+    }
+    if (!PLANNING_ROLES.includes(actor.role)) {
+      const agent = await this.readAgent(actor.name);
+      if (!agent.memberships.includes(task.project)) {
+        throw new BoardError("FORBIDDEN", `${actor.name} is not a member of ${task.project}`);
+      }
+    }
+    if (link === null) {
+      return void 0;
+    }
+    const project = await this.readProject(task.project);
+    const repository = githubRepository(project.repo);
+    const named = parsePullRequestUrl(link.url);
+    if (repository === null || named === null || !sameRepository(repository, named)) {
+      throw new BoardError("VALIDATION", `${link.url} is not a pull request of ${project.slug}'s repository${project.repo === null ? ", since it has no remote" : ` at ${project.repo}`}`);
+    }
+    return PullRequestLinkSchema.parse({
+      url: link.url,
+      number: named.number,
+      ...link.merge_subject === void 0 ? {} : { subject: link.merge_subject },
+      ...link.merge_body === void 0 ? {} : { body: link.merge_body },
+      linkedBy: actor.name,
+      linkedAt: this.now().toISOString()
+    });
+  }
   async getTask(actor, input) {
     const args = VerbInputs.get_task.parse(input);
     await this.authorize(actor, "get_task");
@@ -4743,6 +5190,9 @@ ${rationale}`}`);
     }
     return this.mutex.run(async () => {
       const previous = await this.readActiveProject(args.project);
+      if (args.on_done !== void 0) {
+        assertLandsByPullRequest(args.on_done, previous.repo, `project ${previous.slug}`);
+      }
       const project = await this.updateProject(args.project, (current) => ({
         ...current,
         ...args.on_done === void 0 ? {} : { onDone: args.on_done },
@@ -4766,6 +5216,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;
     });
   }
@@ -4773,6 +5224,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");
@@ -4785,7 +5240,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 agent = await this.updateAgent(target, (a) => ({
@@ -4804,9 +5259,13 @@ ${rationale}`}`);
         project: args.project,
         cli: agent.cli
       });
-      return agent;
+      return { ...agent, otherChannels: await this.otherChannels(args.project, agent) };
     });
   }
+  /** The open channels of a project a citizen does not follow. */
+  async otherChannels(project, agent) {
+    return (await this.readProject(project)).channels.map((name) => channelRef(project, name)).filter((ref) => !agent.subscriptions.includes(ref));
+  }
   async leaveProject(actor, input) {
     const args = VerbInputs.leave_project.parse(input);
     await this.authorize(actor, "leave_project");
@@ -4911,6 +5370,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)}`);
     }
@@ -5021,29 +5486,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(agent, scope, cursor, thread) {
+  async setDigestCursor(agent, scope, cursor, part) {
     await this.mutex.run(async () => {
       if (cursor === null) {
         return;
       }
       const cursors = await this.readCursors(agent);
-      const current = cursorOf(cursors, scope, thread ?? null);
+      const current = cursorOf(cursors, scope, part ?? null);
       const news = newsStart(cursors);
-      const readNews = thread === 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(agent), {
         ...cursors,
-        scopes: current !== null && cursor <= current ? cursors.scopes : { ...cursors.scopes, [conversationKey(scope, thread ?? 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(agent, scope, thread) {
-    return this.mutex.run(async () => cursorOf(await this.readCursors(agent), scope, thread ?? null));
+  async digestCursor(agent, scope, part) {
+    return this.mutex.run(async () => cursorOf(await this.readCursors(agent), scope, part ?? null));
   }
   /** Records that a running turn took posts delivered into it, which wake latency counts to. */
   async recordSteered(input) {
@@ -5052,25 +5518,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(agent, scope, thread) {
-    return thread === void 0 ? this.paths.agentProject(agent, scope) : this.paths.agentThread(agent, scope, thread);
+  /**
+   * 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(agent, scope, part) {
+    return part === void 0 ? this.paths.agentProject(agent, scope) : this.paths.agentConversation(agent, scope, part);
   }
-  async readSessions(agent, project, thread) {
-    const file = path6.join(this.sessionDir(agent, project, thread), "sessions.json");
+  async readSessions(agent, project, part) {
+    const file = path6.join(this.sessionDir(agent, project, 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(agent, project, cli, sessionId, runner, thread) {
+  async writeSession(agent, project, cli, sessionId, runner, part) {
     await this.mutex.run(async () => {
-      const dir = this.sessionDir(agent, project, thread);
+      const dir = this.sessionDir(agent, project, part);
       await ensureDir(dir);
       const file = path6.join(dir, "sessions.json");
       const current = await exists(file) ? await readJson(file, SessionsFileSchema) : {};
@@ -5078,17 +5548,21 @@ ${rationale}`}`);
       await writeJson(file, { ...kept, [cli]: sessionId, runner });
     });
   }
-  /** The last turn of one conversation: the scope's home, or a thread's. */
-  async readLastTurn(agent, project, thread) {
-    const file = path6.join(this.sessionDir(agent, project, thread), "last-turn.json");
+  /** The last turn of one conversation: the scope's home, a channel's, or a thread's. */
+  async readLastTurn(agent, project, part) {
+    const file = path6.join(this.sessionDir(agent, project, 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(agent, project) {
     let latest = await this.readLastTurn(agent, project);
-    const threads = path6.join(this.paths.agentProject(agent, project), "threads");
-    for (const thread of await listDirs(threads)) {
-      const turn = await this.readLastTurn(agent, project, thread);
+    const place = this.paths.agentProject(agent, project);
+    const parts = [
+      ...await listDirs(path6.join(place, "threads")),
+      ...(await listDirs(path6.join(place, "channels"))).map((name) => `#${name}`)
+    ];
+    for (const part of parts) {
+      const turn = await this.readLastTurn(agent, project, part);
       if (turn !== null && (latest === null || turnTime(turn) > turnTime(latest))) {
         latest = turn;
       }
@@ -5105,6 +5579,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
@@ -5130,13 +5605,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,
@@ -5160,10 +5637,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 } = await this.findTask(conversation.id);
+      return task.status === "done" || task.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 () => {
@@ -5173,8 +5691,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) {
@@ -5194,8 +5712,8 @@ ${rationale}`}`);
         for (const name of new Set(task2.stages.flatMap((stage) => stage.completedBy ?? []))) {
           await this.refreshMember(name);
         }
-        if (merged) {
-          await this.appendMessage(actor.name, channelRef(location.project, "general"), `Task ${task2.id} "${task2.title}" is done: ${sentence(input.detail)}.`);
+        if (landed) {
+          await this.appendMessage(actor.name, channelRef(location.project, task2.channel), `Task ${task2.id} "${task2.title}" is done: ${sentence(input.detail)}.`);
         }
         return task2;
       }
@@ -5224,15 +5742,31 @@ ${rationale}`}`);
   async writeState(name, value) {
     await this.mutex.run(() => writeJson(path6.join(this.paths.state(), `${name}.json`), value));
   }
-  /** The project's editable dashboard: frontmatter plus markdown body. Empty when none exists. */
+  /** The project's dashboard, empty at revision 0 when it has none. */
   async readDashboard(slug) {
     await this.readProject(slug);
+    return this.dashboardOf(slug);
+  }
+  /**
+   * Read loosely, since agents wrote dashboards by hand before they had a verb: a revision or an
+   * author that does not parse counts as none.
+   */
+  async dashboardOf(slug) {
     const file = this.paths.dashboard(slug);
     if (!await exists(file)) {
-      return { data: { project: slug }, body: "" };
+      return { project: slug, revision: 0, body: "" };
     }
     const { data, body } = await readLooseMarkdown(file);
-    return { data, body };
+    const revision = z12.number().int().min(0).safeParse(data["revision"]);
+    const updatedBy = NameSchema.safeParse(data["updatedBy"]);
+    const updatedAt = IsoDateTimeSchema.safeParse(data["updatedAt"]);
+    return {
+      project: slug,
+      revision: revision.success ? revision.data : 0,
+      ...updatedBy.success ? { updatedBy: updatedBy.data } : {},
+      ...updatedAt.success ? { updatedAt: updatedAt.data } : {},
+      body
+    };
   }
   async listRunners() {
     const runners2 = [];
@@ -5432,7 +5966,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);
   }
@@ -5736,7 +6270,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         };
       }
       case "channel": {
-        const channel = await this.addChannelUnlocked(by, ChannelProposalSchema.parse(proposal.charter), meta);
+        const channel = await this.addChannelUnlocked(by, ChannelProposalSchema.parse(proposal.charter), meta, proposal.proposedBy);
         return { channel };
       }
       case "role": {
@@ -5842,18 +6376,20 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     return { agent, 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 project = await this.readActiveProject(input.project);
-    if (project.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);
@@ -5867,14 +6403,104 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       }));
       await ensureDir(this.paths.projectChannel(project, 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, (agent) => ({
+        ...agent,
+        subscriptions: [.../* @__PURE__ */ new Set([...agent.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, channel } = parseChannelRef(ref);
+    if (isBoardChannel(project, channel)) {
+      throw new BoardError("FORBIDDEN", `the board itself uses ${ref}, so it is never archived`);
+    }
+    await this.assertChannelOpen(ref);
+    if (project !== null) {
+      const inPlay2 = (await this.listTasks(project)).filter((task) => task.channel === channel && task.status !== "done" && task.status !== "abandoned");
+      if (inPlay2.length > 0) {
+        throw new BoardError("INVALID_STATE", `${inPlay2.length} task(s) filed in ${ref} are still in play: ${inPlay2.map((task) => task.id).join(", ")}`);
+      }
+    }
+    const ts = this.now().toISOString();
+    const threads = project === null ? this.paths.societyThreads() : this.paths.threads(project);
+    const closing = await this.openThreadIds(threads, (thread) => thread.channel === ref);
+    const scope = project ?? SOCIETY_SCOPE;
+    this.assertNoTurnCut(actor, `${ref} cannot be archived`, (turn) => turn.channel === channel && turn.scope === scope || turn.thread !== void 0 && closing.has(turn.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 agent of await this.listAgents()) {
+      if (agent.subscriptions.includes(ref)) {
+        await this.updateAgent(agent.name, (a) => ({
+          ...a,
+          subscriptions: a.subscriptions.filter((each) => each !== ref)
+        }));
+        await this.refreshMember(agent.name);
+        unsubscribed.push(agent.name);
+      }
+    }
+    const archived = { name: channel, at: ts, by, reason };
+    if (project === 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(project, (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(project, "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) {
@@ -6087,23 +6713,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 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`);
     }
-    const project = await this.readProject(parsed.project);
-    if (!project.channels.includes(parsed.channel)) {
-      throw new BoardError("NOT_FOUND", `channel ${ref} not found`);
+    return 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, and followers: it exists, and its project is not archived. */
+  /**
+   * 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 } = parseChannelRef(ref);
     if (project !== null) {
       await this.readActiveProject(project);
@@ -6203,6 +6841,10 @@ ${charter.purpose}
       if (outcome === "approved") {
         await this.validateProvision(proposal.kind, proposal.charter);
       }
+      this.assertNoTurnCut(actor, `proposal ${proposalId} cannot be decided`, (turn) => turn.thread === proposalId);
+      if (outcome === "approved" && proposal.kind === "archive") {
+        await this.assertProjectQuiet(actor, ArchiveProposalSchema.parse(proposal.charter).project);
+      }
       const ts = this.now().toISOString();
       const decision = DecisionSchema.parse({
         id: this.newId(),
@@ -6389,6 +7031,8 @@ function decideWake(input) {
       return { wake: true, reason: "operations signal", priority: 0 };
     case "user_post":
       return { wake: true, reason: "user post", priority: 2 };
+    case "closing":
+      return { wake: true, reason: "an ended conversation left work on no branch", priority: 1 };
     case "heartbeat":
       break;
   }
@@ -6404,6 +7048,16 @@ function decideWake(input) {
 
 // packages/scheduler/dist/scheduler.js
 import { z as z13 } from "zod";
+function besideFields(beside) {
+  if (beside === void 0) {
+    return {};
+  }
+  return "thread" in beside ? { thread: beside.thread } : { channel: beside.channel };
+}
+function conversationKey2(agent, scope, beside) {
+  const fields = besideFields(beside);
+  return sessionKey(agent, scope, conversationPart({ thread: fields.thread?.id, channel: fields.channel }));
+}
 var DEFAULT_TIMINGS = Object.freeze({
   pollMs: 1e3,
   debounceMs: 3e4,
@@ -6529,6 +7183,12 @@ var Scheduler = class {
   /** Tasks whose completion effect waits for the turn that finished their last stage to end. */
   completions = /* @__PURE__ */ new Map();
   completing = /* @__PURE__ */ new Set();
+  /** Running turns that must run alone among their citizen's, by session key: see `heldBack`. */
+  exclusive = /* @__PURE__ */ new Map();
+  /** Tasks being landed now; a turn in a task's thread waits until its landing is done. */
+  landing = /* @__PURE__ */ new Set();
+  /** Sweeps of ended conversations' workspaces under way, which `drain` and `stop` wait for. */
+  sweeping = /* @__PURE__ */ new Set();
   state = StateSchema.parse({
     cursor: null,
     lastHeartbeat: {}
@@ -6581,7 +7241,8 @@ var Scheduler = class {
     await Promise.allSettled([
       ...this.running.values(),
       ...this.completing,
-      ...this.steering.values()
+      ...this.steering.values(),
+      ...this.sweeping
     ]);
   }
   /** One pass, unless one is under way already. */
@@ -6630,7 +7291,8 @@ var Scheduler = class {
     await Promise.allSettled([
       ...this.steering.values(),
       ...this.running.values(),
-      ...this.completing
+      ...this.completing,
+      ...this.sweeping
     ]);
   }
   async load() {
@@ -6678,7 +7340,7 @@ var Scheduler = class {
             reason: `mentioned by ${event.actor}`,
             ...messageId === void 0 ? {} : { messageId },
             ...channel === null ? {} : { channel }
-          }, now, threadId === void 0 ? void 0 : await this.conversationOf(threadId, scope));
+          }, now, await this.postedIn(scope, channel, threadId));
         }
         const step = payload["step"];
         if (event.actor === USER_NAME && (step === void 0 || step === null)) {
@@ -6733,6 +7395,21 @@ var Scheduler = class {
         if (creator !== null && creator !== event.actor) {
           await this.wakeCreator(taskId, project, creator, event.actor, now);
         }
+        const threaded = await this.board.readThread(taskId).then(() => true, () => false);
+        if (!threaded) {
+          this.sweep({ kind: "thread", id: taskId });
+        }
+        return;
+      }
+      case "thread.closed": {
+        const threadId = stringOf(payload["threadId"]);
+        if (threadId !== null) {
+          this.sweep({ kind: "thread", id: threadId });
+        }
+        return;
+      }
+      case "workspace.leftovers": {
+        await this.wakeClosing(payload, now);
         return;
       }
       case "task.updated": {
@@ -6810,6 +7487,26 @@ var Scheduler = class {
         await this.wakeNewcomer(name, project, now);
         return;
       }
+      case "channel.archived": {
+        const channel = stringOf(payload["channel"]);
+        if (channel === null) {
+          return;
+        }
+        const archived = parseChannelRef(channel);
+        this.sweep({
+          kind: "channel",
+          scope: archived.project ?? SOCIETY_SCOPE,
+          name: archived.channel
+        });
+        for (const [key, item] of this.pending) {
+          const { dispatch } = item;
+          if (dispatch.channel !== void 0 && channelConversation(dispatch.project, channel) === dispatch.channel) {
+            this.pending.delete(key);
+            this.log.info({ agent: dispatch.agent, project: dispatch.project, channel }, "dropping channel wake, the channel is archived");
+          }
+        }
+        return;
+      }
       case "agent.left": {
         const name = stringOf(payload["name"]);
         const project = stringOf(payload["project"]);
@@ -6880,7 +7577,7 @@ var Scheduler = class {
         reason: `the user posted in ${channel ?? "a channel"}`,
         ...messageId === void 0 ? {} : { messageId },
         ...channel === null ? {} : { channel }
-      }, now, threadId === void 0 ? void 0 : await this.conversationOf(threadId, scope));
+      }, now, await this.postedIn(scope, channel, threadId));
     }
   }
   /**
@@ -6954,7 +7651,7 @@ var Scheduler = class {
       from,
       reason: `stage "${name}" of task ${task.id} "${task.title}" ${state}`,
       taskId: task.id
-    }, now, { id: task.id, task: scope === task.project });
+    }, now, { thread: { id: task.id, task: scope === task.project } });
     return sessionKey(agent.name, scope, task.id);
   }
   /**
@@ -7015,6 +7712,49 @@ var Scheduler = class {
     const scope = this.scopeForProject(agent, project);
     this.enqueue(agent.name, scope, { kind: "task_done", from, reason: `task ${taskId} you created is done`, taskId }, now);
   }
+  /**
+   * Whether a dispatch is in the thread of a task whose landing is queued or under way: it waits,
+   * so a stream of turns there cannot hold the landing off, nor commit to the branch during it.
+   */
+  landingIn(dispatch) {
+    const thread = dispatch.thread?.id;
+    return thread !== void 0 && (this.completions.has(thread) || this.landing.has(thread));
+  }
+  /** Asks the runners to remove an ended conversation's workspaces, without holding up the pass. */
+  sweep(conversation) {
+    const sweep = this.runner.sweep?.bind(this.runner);
+    if (sweep === void 0) {
+      return;
+    }
+    const promise = sweep(conversation).catch((error) => {
+      this.log.warn({ conversation, error: String(error) }, "sweeping workspaces failed");
+    }).finally(() => {
+      this.sweeping.delete(promise);
+    });
+    this.sweeping.add(promise);
+  }
+  /**
+   * A citizen's workspace in a conversation that has ended holds work on no branch: one closing turn
+   * there, in the same session and workspace, decides whether it matters and whose it is.
+   */
+  async wakeClosing(payload, now) {
+    const name = stringOf(payload["agent"]);
+    const scope = stringOf(payload["project"]);
+    const thread = stringOf(payload["thread"]);
+    const channel = stringOf(payload["channel"]);
+    const agent = name === null ? null : await this.tryReadAgent(name);
+    if (agent === null || scope === null) {
+      return;
+    }
+    const beside = thread !== null ? { thread: await this.conversationOf(thread, scope) } : channel !== null ? { channel } : null;
+    if (beside === null) {
+      return;
+    }
+    this.enqueue(agent.name, scope, {
+      kind: "closing",
+      reason: "a conversation you took part in has ended, and its workspace holds work on no branch"
+    }, now, beside);
+  }
   /** A decided proposal wakes the citizen that made it, to carry on with what it enables. */
   async wakeProposer(proposalId, proposer, event, now) {
     const agent = await this.tryReadAgent(proposer);
@@ -7044,6 +7784,17 @@ var Scheduler = class {
       return { id: threadId, task: false };
     }
   }
+  /**
+   * The conversation a post wakes a citizen in, for a turn in `scope`: its thread's, else its
+   * channel's when that is a channel of the scope other than general, else the scope's home.
+   */
+  async postedIn(scope, channel, threadId) {
+    if (threadId !== void 0) {
+      return { thread: await this.conversationOf(threadId, scope) };
+    }
+    const name = channel === null ? void 0 : channelConversation(scope, channel);
+    return name === void 0 ? void 0 : { channel: name };
+  }
   async tryReadAgent(name) {
     try {
       const agent = await this.board.readAgent(name);
@@ -7059,8 +7810,8 @@ var Scheduler = class {
   scopeForProject(agent, project) {
     return wakeScope(agent, project);
   }
-  /** Queues a wake in one conversation: a thread's, or without one, the scope's home. */
-  enqueue(agent, project, input, now, thread) {
+  /** Queues a wake in one conversation: a thread's, a channel's, or without either, the scope's home. */
+  enqueue(agent, project, input, now, beside) {
     const trigger = TriggerSchema.parse(input);
     const decision = decideWake({
       trigger,
@@ -7073,7 +7824,7 @@ var Scheduler = class {
       return;
     }
     const debounce = this.debounceFor(trigger);
-    const key = sessionKey(agent, project, thread?.id);
+    const key = conversationKey2(agent, project, beside);
     const readyAt = now + debounce;
     const existing = this.pending.get(key);
     const message = messageOf(trigger);
@@ -7082,7 +7833,7 @@ var Scheduler = class {
         dispatch: {
           agent,
           project,
-          ...thread === void 0 ? {} : { thread },
+          ...besideFields(beside),
           trigger,
           priority: decision.priority,
           onboarding: trigger.kind === "onboarding"
@@ -7132,7 +7883,8 @@ var Scheduler = class {
   }
   /**
    * A heartbeat per member and scope on the cadence, which then looks at every conversation of the
-   * scope: the unread messages of its home and of each thread, a stage the member holds, and a stage
+   * scope: the unread messages of its home, of each other channel, and of each thread, a stage the
+   * member holds, and a stage
    * waiting that it may take, each in its task's thread. Each conversation with something wakes on
    * its own, so a heartbeat never brings one task's business into another's turn.
    */
@@ -7163,31 +7915,31 @@ var Scheduler = class {
         unread ??= await this.board.unreadByConversation(actor);
         held ??= await this.board.heldClaims(agent.name);
         const reasons = /* @__PURE__ */ new Map();
-        const reasonsIn = (thread) => {
-          const key = sessionKey(agent.name, project, thread?.id);
+        const reasonsIn = (beside) => {
+          const key = conversationKey2(agent.name, project, beside);
           const existing = reasons.get(key);
           if (existing !== void 0) {
             return existing;
           }
-          const fresh = { thread, digestSize: 0, claimsHeld: 0, waiting: 0 };
+          const fresh = { beside, digestSize: 0, claimsHeld: 0, waiting: 0 };
           reasons.set(key, fresh);
           return fresh;
         };
         for (const entry of unread) {
           if (entry.scope === project) {
-            const thread = entry.thread === null ? void 0 : await this.conversationOf(entry.thread, project);
-            reasonsIn(thread).digestSize += entry.count;
+            const beside = entry.thread !== null ? { thread: await this.conversationOf(entry.thread, project) } : entry.channel !== null ? { channel: entry.channel } : void 0;
+            reasonsIn(beside).digestSize += entry.count;
           }
         }
         for (const task of held) {
           if (task.project === project) {
-            reasonsIn({ id: task.id, task: true }).claimsHeld += 1;
+            reasonsIn({ thread: { id: task.id, task: true } }).claimsHeld += 1;
           }
         }
         if (project !== SOCIETY_SCOPE) {
           for (const task of await this.board.openTasks(project)) {
             if (mayHoldStage(agent, task)) {
-              reasonsIn({ id: task.id, task: true }).waiting += 1;
+              reasonsIn({ thread: { id: task.id, task: true } }).waiting += 1;
             }
           }
         }
@@ -7208,7 +7960,7 @@ var Scheduler = class {
               dispatch: {
                 agent: agent.name,
                 project,
-                ...reason.thread === void 0 ? {} : { thread: reason.thread },
+                ...besideFields(reason.beside),
                 trigger,
                 priority: decision.priority,
                 onboarding: false
@@ -7246,8 +7998,8 @@ var Scheduler = class {
         this.state.lastReflection[agent.name] = iso(now);
         continue;
       }
-      const key = sessionKey(agent.name, latest.scope);
-      if (this.pending.has(key) || this.running.has(key)) {
+      const busy = [...this.pending.keys(), ...this.running.keys()].some((key) => parseSessionKey(key)?.agent === agent.name);
+      if (busy) {
         continue;
       }
       this.state.lastReflection[agent.name] = iso(now);
@@ -7564,7 +8316,8 @@ var Scheduler = class {
       const attempt = steer({
         agent: dispatch.agent,
         project: dispatch.project,
-        ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id }
+        ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id },
+        ...dispatch.channel === void 0 ? {} : { channel: dispatch.channel }
       }).then((outcome) => {
         const current = this.pending.get(key);
         if (outcome !== "busy" && current !== void 0) {
@@ -7585,16 +8338,19 @@ var Scheduler = class {
       return false;
     }
     const { dispatch } = item;
-    const cursor = await this.board.digestCursor(dispatch.agent, dispatch.project, dispatch.thread?.id);
+    const cursor = await this.board.digestCursor(dispatch.agent, dispatch.project, conversationPart({ thread: dispatch.thread?.id, channel: dispatch.channel }));
     return cursor !== null && cursor >= item.newestMessage;
   }
   async dispatchReady(now) {
     this.steerRunning(now);
-    const ready = [...this.pending.entries()].filter(([key, item]) => item.readyAt <= now && !this.running.has(key)).toSorted(([, a], [, b]) => b.dispatch.priority - a.dispatch.priority || a.readyAt - b.readyAt);
+    const ready = [...this.pending.entries()].filter(([key, item]) => item.readyAt <= now && !this.running.has(key) && !this.landingIn(item.dispatch)).toSorted(([, a], [, b]) => b.dispatch.priority - a.dispatch.priority || a.readyAt - b.readyAt);
     for (const [key, item] of ready) {
       if (this.running.size >= this.concurrency) {
         break;
       }
+      if (this.heldBack(key, item.dispatch)) {
+        continue;
+      }
       this.pending.delete(key);
       if (await this.alreadyRead(item)) {
         this.log.info({ agent: item.dispatch.agent, project: item.dispatch.project }, "dropping message wake, its conversation has read the message");
@@ -7618,6 +8374,7 @@ var Scheduler = class {
         agent: dispatch.agent,
         project: dispatch.project,
         thread: dispatch.thread?.id,
+        channel: dispatch.channel,
         trigger: dispatch.trigger.kind
       }, "dispatching turn");
       const promise = (async () => {
@@ -7633,19 +8390,45 @@ var Scheduler = class {
           this.log.error({ agent: dispatch.agent, project: dispatch.project, error: String(error) }, "turn crashed");
         } finally {
           this.running.delete(key);
+          this.exclusive.delete(key);
         }
       })();
       this.running.set(key, promise);
+      if (dispatch.onboarding) {
+        this.exclusive.set(key, "onboarding");
+      } else if (dispatch.trigger.kind === "reflection") {
+        this.exclusive.set(key, "reflection");
+      }
+    }
+  }
+  /**
+   * Whether a ready turn waits for another of its citizen's turns that must run alone: its
+   * onboarding in the project, queued or running, which comes before any other work of its there;
+   * and a reflection, which consolidates the memory the citizen's other turns would be writing, so
+   * it starts only once none of them runs and they wait while it does.
+   */
+  heldBack(key, dispatch) {
+    const { agent, project } = dispatch;
+    const home = sessionKey(agent, project);
+    if (key !== home && (this.pending.get(home)?.dispatch.onboarding === true || this.exclusive.get(home) === "onboarding")) {
+      return true;
+    }
+    const others = [...this.running.keys()].filter((other) => other !== key && parseSessionKey(other)?.agent === agent);
+    if (dispatch.trigger.kind === "reflection") {
+      return others.length > 0;
     }
+    return others.some((other) => this.exclusive.get(other) === "reflection");
   }
   /** Starts each queued completion once the turn that finished the task's last stage has ended. */
   runCompletions() {
     for (const [taskId, item] of this.completions) {
       const home = sessionKey(item.actor, item.project);
-      if ([...this.running.keys()].some((key) => key === home || key.startsWith(`${home}/`))) {
+      const busy = [...this.running.keys()].some((key) => key === home || key.startsWith(`${home}/`) || parseSessionKey(key)?.thread === taskId);
+      if (busy) {
         continue;
       }
       this.completions.delete(taskId);
+      this.landing.add(taskId);
       const promise = this.runner.completeTask(item.project, taskId).then((outcome) => {
         if (outcome === "deferred" && !this.completions.has(taskId)) {
           this.completions.set(taskId, item);
@@ -7655,6 +8438,7 @@ var Scheduler = class {
         this.log.error({ project: item.project, taskId, error: String(error) }, "completion failed");
       }).finally(() => {
         this.completing.delete(promise);
+        this.landing.delete(taskId);
       });
       this.completing.add(promise);
     }
@@ -7666,16 +8450,17 @@ import { randomUUID } from "node:crypto";
 
 // packages/turn-host/dist/render.js
 var TURN_CONTRACT = [
-  "- Every turn belongs to one conversation, named at the top of your prompt: your home conversation in a project or the society, for its channels and for work tied to no thread, or the conversation of one thread you take part in, a task's, a proposal's, or a topic's. Each has its own session and its own turns, which may run while this one does. The prompt carries this conversation only: in a thread, its new messages, or the whole thread when the conversation is new, and in a task's thread the task and its stage; at home, the channel messages that concern you. Read anything else you need with get_task, search, and the board's files, and leave other threads' and other projects' work to their own turns.",
+  "- Every turn belongs to one conversation, named at the top of your prompt: your home conversation in a project or the society, for its general channel and for work tied to no other channel and no thread; the conversation of one other channel of the place, a workstream such as a release; or the conversation of one thread you take part in, a task's, a proposal's, or a topic's. Each has its own session and its own turns, which may run while this one does. The prompt carries this conversation only: in a thread, its new messages, or the whole thread when the conversation is new, and in a task's thread the task and its stage; in a channel's or at home, that channel's or general's messages that concern you. Read anything else you need with get_task, search, and the board's files, and leave other channels', other threads', and other projects' work to their own turns.",
   "- Act through the board tools (the `board` MCP server). Holding a stage is a lease; every turn that touches the task renews it.",
-  "- Work only inside your worktree. In a task's conversation it is a worktree of its own on the task's branch `task/<id>`: commit your work there. After each turn the runner commits what you left on the branch and lets it go for the next holder. Your home worktree is on your own branch, `agent/<name>`, for work tied to no task. In a proposal's or a topic's conversation it is a worktree of its own, detached at your own branch's tip, which goes when the thread closes, so work that should last goes on a task's branch.",
+  "- Work only inside your worktree. In a task's conversation it is a worktree of its own on the task's branch `task/<id>`: commit your work there. After each turn the runner commits what you left on the branch and lets it go for the next holder. Your home worktree is on your own branch, `agent/<name>`, for work tied to no task; nothing lands from it by itself. In a proposal's, a topic's, or a channel's conversation it is a worktree of its own, detached at the project's default branch, which goes when the thread closes or the channel is archived, so work that should last goes on a task's branch. Before each turn the runner fetches the project's remote and brings what holds no work of yours up to the default branch: your own branch when it has no commits of its own, a task's branch nobody has worked on, and a detached worktree with nothing uncommitted; what it leaves where it is, and why, is under Your workspace in the prompt. It never merges or commits for you.",
   "- Posts that would wake this conversation may arrive while you work, delivered into the turn under a heading that says so and formatted like the digest. They are part of this turn: act on them now, after the step in hand, or not at all, as with the digest. The user may also stop a turn; the next turn is told.",
   "- Silence is allowed. If the digest needs no reply, post nothing.",
   "- An @mention wakes the citizen named, and every wake costs a turn. Address someone with @ only when you need them to act; when you merely refer to citizens, write their names plainly. @user wakes nobody, since the user takes no turns; it is what puts a question before the user, so use it only when you need the user to answer or decide.",
-  "- A thread is a conversation off a channel that reaches only its participants and whoever is mentioned in it. Every task has one, opened with it under the task's id on its project's general channel: talk about a task there, with post_message and its thread_id, and the notes you give advance_task and update_task are posted there as you. Its participants are the task's creator, its stage holders and assignees, whoever may take the stage that waits, and anyone who posted; it closes when the task ends. Every proposal has one too, in governance, opened with its pitch and closed by its decision. Open other threads with open_thread on a channel with a title, for any other topic; close_thread posts your summary to its channel.",
+  "- A thread is a conversation off a channel that reaches only its participants and whoever is mentioned in it. Every task has one, opened with it under the task's id on the channel of its project it was filed in, general unless it was filed in another: talk about a task there, with post_message and its thread_id, and the notes you give advance_task and update_task are posted there as you. Its participants are the task's creator, its stage holders and assignees, whoever may take the stage that waits, and anyone who posted; it closes when the task ends. Every proposal has one too, in governance, opened with its pitch and closed by its decision. Open other threads with open_thread on a channel with a title, for any other topic; close_thread posts your summary to its channel.",
   "- Route every lesson: about you, your craft, or the user, write it to memory/core.md in your home directory, and keep that file short by moving detail to memory/<topic>.md, your archive; a durable fact about a project's codebase or process goes through `write_knowledge` on that project; something the whole project should know now, post it to the project channel, and anything about one task, in the task's thread.",
   '- A procedure you have followed twice is a skill: write it to skills/<name>/SKILL.md in your home, frontmatter with `name` and a one-line `description` and then the steps, and your skills index lists it from the next turn. Propose it with kind "skill" when the whole society would use it.',
   "- Report memoryUpdated: true in the status object whenever you changed memory/core.md or a skill, so a warm session restarts with the new instructions.",
+  "- Other turns of yours may be running at the same time and share your home. Change a file there with your edit tool, which refuses a file changed since you read it, and never rewrite one whole from an earlier read, with a shell redirect or a script, or you erase what another of your turns wrote.",
   "- To ask the user something, mention @user where the question belongs: the task's thread for a task, the proposal's thread for a proposal, and for anything else a thread you open on your scope's general channel, titled with the question. The user answers in the same thread, and the answer comes back to that thread's conversation. A proposal waiting on the user is already in front of them and needs no mention.",
   "- End every turn with the status object: summary, claims held, what is blocked, and whether the user must decide. If you report that the user must decide, mentioned @user nowhere this turn, and proposed nothing for the user to decide, the runner asks in this turn's thread when it has one, and otherwise opens a thread on your scope's general channel with your summary as the question."
 ].join("\n");
@@ -7697,7 +8482,7 @@ var GOVERNANCE = [
   '  - archive: {"project", "reason"}: approval archives the project: its members leave, its open threads close, and nothing more is posted, filed, or joined there, while its files and history stay; refused while a task there is in play',
   '  - reallocation: {"description"}',
   `  - skill: {"name", "summary", "body"}: the SKILL.md text; approval publishes it under society/skills, where every citizen's skills index lists it`,
-  "- Projects and membership: a project is a lasting area of work, not one request; `create_project` opens one with its general channel (front desk and user), and `configure_project` sets its completion effect, its display name, or its default branch, never its slug (user, steward, concierge). A project whose work is finished or has moved to another project is archived by proposal, once no task there is in play. `join_project` and `leave_project` move yourself, or another citizen when you are the concierge, the steward, or the user; joining gives the pair a worktree and an onboarding turn. A society role, one that keeps watch over the whole society as the concierge and the steward do, is never in a project: it moves others, never itself.",
+  "- Projects and membership: a project is a lasting area of work, not one request; `create_project` opens one with its general channel (front desk and user), and `configure_project` sets its completion effect, its display name, or its default branch, never its slug (user, steward, concierge). A workstream within a project or the society, such as a release, gets a channel of its own: `create_channel` opens it, which its opener follows, and announces it in the place's general, where members subscribe when it concerns them, `create_task` with `channel` files the workstream's tasks there, and `archive_channel` ends it once none of its tasks is in play, leaving its history readable (user, steward, concierge; others propose a channel). A project whose work is finished or has moved to another project is archived by proposal, once no task there is in play. `join_project` and `leave_project` move yourself, or another citizen when you are the concierge, the steward, or the user; joining gives the pair a worktree and an onboarding turn. A society role, one that keeps watch over the whole society as the concierge and the steward do, is never in a project: it moves others, never itself.",
   "- Prefer scaling an existing role over inventing one; a new role is justified by work a project needs that no existing role covers. A role that needs a tool the board lacks is an engineering task, not a hiring request.",
   "- Operations signals are counters and timers the board logs, listed in the prompt of a role that reads them: stages waiting for a holder, backlog per role, stages waiting on a role nobody fills, churn, stale threads, idle members, missing capabilities, replicas added, spend. They are not posts in any channel; interpreting them is your judgment."
 ].join("\n");
@@ -7708,6 +8493,9 @@ function renderOnboardingPreamble(context) {
     `Your role in one paragraph: ${context.roleSummary}`,
     "",
     `You are working on project "${context.project}" in the worktree at ${context.worktree}.`,
+    ...(context.otherChannels ?? []).length === 0 ? [] : [
+      `You follow its general channel. It also has ${(context.otherChannels ?? []).map((ref) => `#${ref}`).join(", ")}, each a workstream such as a release: subscribe to one when your work there needs its posts. Its tasks and mentions reach you either way.`
+    ],
     "Your memory is empty. Write durable lessons about yourself, your craft, or the user to memory/core.md in your home directory.",
     "Write profile.md in your home directory: one paragraph on what you do well and what to send your way. The roster the front desk routes with is built from it.",
     "Read the project's instructions file, if it has one, before doing anything else.",
@@ -7733,7 +8521,7 @@ function renderInstructions(input) {
   if (norms.length > 0) {
     sections.push("", "## Society norms", "", norms);
   }
-  sections.push("", "## Core memory", "", memory.length === 0 ? "(empty)" : memory, "", "## Skills", "", ...renderSkillsIndex(input.skills ?? []), "", "## Where things are", "", `- Your home directory: ${input.homeDir}. memory/core.md is loaded every turn; memory/<topic>.md is your archive; skills/<name>/SKILL.md are your skills; projects/<slug>/notes.md are your notes. You may read and write all of it, and the board's search covers your archive and skills for you alone. The runner keeps it in git and shares it with the board after every turn, so whatever machine your next turn runs on has it; leave git there to the runner. Files over ${HOME_FILE_LIMIT_BYTES / (1024 * 1024)} MB are not kept.`, `- ${HOME_SCRATCH}/ in your home is your working folder in turns outside any project, and a thread's conversation there works in a folder of its own inside it, which goes when the thread closes: none of it is kept or shared, so put downloads, environments, and other working files there, and keep the rest of your home for what you mean to remember.`, `- The board projection: ${input.boardDir} (read-only markdown: society and project channels, tasks, threads; shared knowledge under projects/<slug>/knowledge/ and society/knowledge/; the society's skills under society/skills/). Search it with your file tools; act through the board tools.`, "", "## Turn contract", "", TURN_CONTRACT, "", "## Planning", "", PLANNING, "", "## Governance", "", GOVERNANCE);
+  sections.push("", "## Core memory", "", memory.length === 0 ? "(empty)" : memory, "", "## Skills", "", ...renderSkillsIndex(input.skills ?? []), "", "## Where things are", "", `- Your home directory: ${input.homeDir}. memory/core.md is loaded every turn; memory/<topic>.md is your archive; skills/<name>/SKILL.md are your skills; projects/<slug>/notes.md are your notes. You may read and write all of it, and the board's search covers your archive and skills for you alone. The runner keeps it in git and shares it with the board after every turn, so whatever machine your next turn runs on has it; leave git there to the runner. Files over ${HOME_FILE_LIMIT_BYTES / (1024 * 1024)} MB are not kept.`, `- ${HOME_SCRATCH}/ in your home is your working folder in turns outside any project, and a thread's or a channel's conversation there works in a folder of its own inside it, which goes when the thread closes or the channel is archived: none of it is kept or shared, so put downloads, environments, and other working files there, and keep the rest of your home for what you mean to remember.`, `- The board projection: ${input.boardDir} (read-only markdown: society and project channels, tasks, threads; shared knowledge under projects/<slug>/knowledge/ and society/knowledge/; the society's skills under society/skills/; each project's dashboard, the status page the user reads on its view, at projects/<slug>/dashboard.md, which its members change with update_dashboard). Search it with your file tools; act through the board tools.`, "", "## Turn contract", "", TURN_CONTRACT, "", "## Planning", "", PLANNING, "", "## Governance", "", GOVERNANCE);
   if (input.onboarding !== void 0) {
     sections.push("", "## First turn", "", renderOnboardingPreamble(input.onboarding));
   }
@@ -7780,7 +8568,7 @@ function planLine(task, whose) {
   const index = stageIndex(task, task.stage);
   const stage = task.stages[index];
   const rest = task.stages.slice(index + 1).map((next) => `${next.name} (${next.gate ? "gate, " : ""}${assignee(next)})`);
-  const then = rest.length === 0 ? `then ${task.onDone === "merge" ? "the board merges it" : "done"}` : `next: ${rest.join(", ")}`;
+  const then = rest.length === 0 ? `then ${task.onDone === "merge" ? "the board merges it" : task.onDone === "ghpr" ? "the board merges its pull request" : "done"}` : `next: ${rest.join(", ")}`;
   const gated = stage?.gate === true ? ", gated" : "";
   return `- ${task.id} "${task.title}": ${stage?.name ?? task.stage} (${whose}, ${index + 1} of ${task.stages.length}${gated}); ${then}`;
 }
@@ -7870,12 +8658,16 @@ function buildTurnPrompt(input) {
   }
   const conversation = input.conversation ?? null;
   lines.push("", "## This conversation", "");
-  if (conversation === null) {
-    lines.push(`This turn is in your home conversation for ${dispatch.project}: its channels, and work tied to no thread. Each thread you take part in, a task's, a proposal's, or a topic's, is a conversation of its own with turns of its own; read one when you need it, and leave its work to its turn.`);
+  if (conversation === null && dispatch.channel !== void 0) {
+    const ref = channelRef(dispatch.project === SOCIETY_SCOPE ? null : dispatch.project, dispatch.channel);
+    lines.push(`This turn is in your conversation of ${ref}, a workstream with turns of its own: its posts, and the work it asks for. Your home conversation for ${dispatch.project} carries its general channel, and each other channel and each thread you take part in is a conversation of its own; read one when you need it, and leave its work to its turn. Post here with post_message and channel ${ref}.`);
+  } else if (conversation === null) {
+    lines.push(`This turn is in your home conversation for ${dispatch.project}: its general channel, and work tied to no other channel and no thread. Each other channel, a workstream, and each thread you take part in, a task's, a proposal's, or a topic's, is a conversation of its own with turns of its own; read one when you need it, and leave its work to its turn.`);
   } else {
     const { thread, task } = conversation;
     const about = thread.subject === void 0 ? "a topic" : `${thread.subject.kind} ${thread.subject.id}`;
-    lines.push(`This turn is in the thread "${thread.title}" on ${thread.channel}, about ${about}. Only this conversation is below: read anything else you need with get_task, search, or the board's files, and leave other tasks and threads to their own turns. Talk here with post_message and thread_id ${thread.id}.`);
+    const talk = thread.state === "closed" ? `This thread is closed, so posts to it are refused: if something still needs saying, post it in ${conversation.replyIn ?? thread.channel}.` : `Talk here with post_message and thread_id ${thread.id}.`;
+    lines.push(`This turn is in the thread "${thread.title}" on ${thread.channel}, about ${about}. Only this conversation is below: read anything else you need with get_task, search, or the board's files, and leave other tasks and threads to their own turns. ${talk}`);
     if (task !== null) {
       lines.push("", `Task ${task.id} "${task.title}", ${task.status}:`, planLine(task, "now"));
       if (task.body.trim() !== "") {
@@ -7883,6 +8675,11 @@ function buildTurnPrompt(input) {
       }
     }
   }
+  const ending = input.ending ?? null;
+  if (ending !== null) {
+    lines.push("", "## This conversation has ended", "", `${capitalized(ending.how)}. You are woken once more because your workspace here still holds work on no branch, listed under Your workspace, and it is removed when this turn ends, whatever it still holds. You may not be the one who ended the conversation, and the work may not be yours to finish, so decide for each piece:`, "- It is yours and it matters: land it through a task. File one, or use one you hold, switch this worktree to its branch task/<id> (git switch -c task/<id> for a task filed in this turn), and commit there.", `- It matters but is someone else's to finish: put it on a task's branch the same way, then hand that task to whoever should own it and ask them in ${ending.askIn} with a mention, since this conversation takes no more posts.`, "- It is disposable: leave it, and it goes with the workspace.");
+  }
+  lines.push("", WORKSPACE_TOKEN);
   const conflicts = input.conflicts ?? [];
   if (dispatch.trigger.kind === "reflection") {
     lines.push("", "## Reflection", "", REFLECTION_INTRO, ...conflicts.length > 0 ? [RECONCILE] : [], ...REFLECTION_STEPS);
@@ -7899,7 +8696,7 @@ function buildTurnPrompt(input) {
   }
   const society = input.societyView;
   if (society !== void 0 && society !== null) {
-    lines.push("", "## The society", "", "### Projects", "");
+    lines.push("", "## The society", "", `Each ask is a conversation of its own, and others may be in a turn at the same time. Before proposing a citizen, a role, or a project, look at the proposals still waiting under ${PATH_TOKENS.board}/society/proposals/: another ask may have proposed it already.`, "", "### Projects", "");
     if (society.projects.length === 0) {
       lines.push("None yet.");
     }
@@ -7934,8 +8731,13 @@ function buildTurnPrompt(input) {
     }
   }
   const project = input.project;
-  if (project !== void 0 && project !== null && project.onDone === "merge") {
-    lines.push("", `## Project ${project.slug}`, "", `A finished task lands by the board merging its branch task/<id> into ${project.defaultBranch}. Never merge or fast-forward ${project.defaultBranch} yourself.`);
+  const landing = conversation?.task?.onDone ?? project?.onDone;
+  if (project !== void 0 && project !== null && landing === "merge") {
+    lines.push("", `## Project ${project.slug}`, "", `A finished task lands by the board merging its branch task/<id> into ${project.defaultBranch}. Never merge or fast-forward ${project.defaultBranch} yourself, or push other work to it on the remote; the runner refuses both.`);
+  }
+  if (project !== void 0 && project !== null && landing === "ghpr") {
+    const base = project.defaultBranch;
+    lines.push("", `## Project ${project.slug}`, "", `A finished task lands by the board merging its pull request on GitHub into ${base}. Open the pull request yourself, from a branch named for what it does that holds the same files as task/<id>, as \`git push origin task/<id>:<branch>\` gives, and link it to the task with update_task pull_request before its last stage completes, with the merge commit's merge_subject and merge_body, which you may change by linking again until it lands. Never merge the pull request or ${base} yourself, nor push other work to ${base}: the board merges once the task's stages are done, and the runner refuses the pushes.`);
   }
   if (conflicts.length > 0) {
     lines.push("", "## Edits to reconcile in your home", "", "Two of your turns changed these files at once on different runners. The file in place kept the other turn's version; yours is the copy named here, beside it. Merge what still holds into the file, then delete the copy.", "", ...conflicts.map((conflict) => `- ${conflict.path}, beside ${conflict.file}, since ${conflict.since}`));
@@ -7981,6 +8783,9 @@ function buildTurnPrompt(input) {
   return `${lines.join("\n")}
 `;
 }
+function capitalized(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
 
 // packages/turn-host/dist/host.js
 var SILENT = { info() {
@@ -8036,11 +8841,14 @@ var TurnHost = class {
     const agent = await this.board.readAgent(dispatch.agent);
     const actor = { name: agent.name, role: agent.role };
     const thread = dispatch.thread;
+    const channel = thread === void 0 ? dispatch.channel : void 0;
+    const part = conversationPart({ thread: thread?.id, channel });
     const startedAt = this.now().toISOString();
     const base = {
       agent: agent.name,
       project: dispatch.project,
       ...thread === void 0 ? {} : { thread: thread.id },
+      ...channel === void 0 ? {} : { channel },
       runner: runner.name,
       cli: agent.cli,
       session: null,
@@ -8065,23 +8873,29 @@ var TurnHost = class {
     const societyScope = dispatch.project === SOCIETY_SCOPE;
     const taskId = thread?.task === true ? thread.id : void 0;
     const project = societyScope ? null : await this.board.readProject(dispatch.project);
-    const workspace = await this.workspaceOf(project, thread);
-    const sessions = await this.board.readSessions(agent.name, dispatch.project, thread?.id);
+    const workspace = await this.workspaceOf(project, thread, channel);
+    const sessions = await this.board.readSessions(agent.name, dispatch.project, part);
     const recorded = sessions.runner === runner.name ? sessions[agent.cli] : void 0;
     const newSession = recorded === void 0;
-    const lastTurn = await this.board.readLastTurn(agent.name, dispatch.project, thread?.id);
+    const lastTurn = await this.board.readLastTurn(agent.name, dispatch.project, part);
     const costSoFarUsd = !newSession && lastTurn?.session === recorded ? lastTurn.sessionCostUsd ?? lastTurn.costUsd : 0;
-    const digest = await this.board.readDigest({ ...actor, scope: dispatch.project, ...thread === void 0 ? {} : { thread: thread.id } }, { advance: false, limit: thread === void 0 ? 50 : 100 });
+    const digest = await this.board.readDigest({
+      ...actor,
+      scope: dispatch.project,
+      ...thread === void 0 ? {} : { thread: thread.id },
+      ...channel === void 0 ? {} : { channel }
+    }, { advance: false, limit: thread === void 0 ? 50 : 100 });
     const threadSoFar = thread !== void 0 && newSession ? (await this.board.listThread(thread.id).catch(() => [])).slice(-100) : null;
     const messages = threadSoFar ?? digest.messages;
     const cursorAfter = threadSoFar?.at(-1)?.id ?? digest.cursor;
     const task = taskId === void 0 ? null : await this.board.findTask(taskId).then((found) => found.task).catch(() => null);
     const held = task === null ? [] : (await this.board.heldClaims(agent.name)).filter((each) => each.id === task.id);
-    const onboarding = dispatch.onboarding || newSession && thread === void 0 ? {
+    const onboarding = dispatch.onboarding || newSession && part === void 0 ? {
       agentName: agent.name,
       roleSummary: charter.purpose,
       project: dispatch.project,
-      worktree: PATH_TOKENS.worktree
+      worktree: PATH_TOKENS.worktree,
+      otherChannels: (project?.channels ?? []).map((name) => channelRef(dispatch.project, name)).filter((ref) => !agent.subscriptions.includes(ref))
     } : null;
     const instructions = renderInstructions({
       agentName: agent.name,
@@ -8117,7 +8931,7 @@ var TurnHost = class {
       dir: `${PATH_TOKENS.board}/projects/${dispatch.project}/knowledge`,
       topics: await this.board.listKnowledge(dispatch.project)
     };
-    const signals = thread === void 0 && charter.wakeTriggers.includes(OPS_TRIGGER2) ? (await this.board.listSignals(500)).filter((record2) => wakeScope(agent, record2.signal.project ?? null) === dispatch.project && (lastTurn === null || record2.ts > lastTurn.startedAt)).slice(-MAX_SIGNALS) : null;
+    const signals = part === void 0 && charter.wakeTriggers.includes(OPS_TRIGGER2) ? (await this.board.listSignals(500)).filter((record2) => wakeScope(agent, record2.signal.project ?? null) === dispatch.project && (lastTurn === null || record2.ts > lastTurn.startedAt)).slice(-MAX_SIGNALS) : null;
     const waiting = task !== null && task.status === "open" && !task.completing && mayHoldStage(actor, task) ? [task] : [];
     const threads = /* @__PURE__ */ new Map();
     for (const id of new Set(messages.flatMap((message) => message.thread ?? []))) {
@@ -8127,12 +8941,19 @@ var TurnHost = class {
       }
     }
     const threadRecord = thread === void 0 ? void 0 : threads.get(thread.id) ?? await this.board.readThread(thread.id).catch(() => void 0);
-    const conversation = threadRecord === void 0 ? null : { thread: threadRecord, task, fresh: threadSoFar !== null };
+    const conversation = threadRecord === void 0 ? null : {
+      thread: threadRecord,
+      task,
+      fresh: threadSoFar !== null,
+      ...threadRecord.state === "closed" ? { replyIn: await this.replyIn(threadRecord) } : {}
+    };
+    const ending = dispatch.trigger.kind === "closing" ? await this.endingOf(dispatch.project, threadRecord, task, channel) : null;
     const prompt = buildTurnPrompt({
       dispatch,
       messages,
       threads,
       conversation,
+      ending,
       heldClaims: held,
       waitingStages: waiting,
       project,
@@ -8144,9 +8965,9 @@ var TurnHost = class {
       signals,
       conflicts: await this.board.listHomeConflicts(agent.name)
     });
-    const resident = charter.resident && thread === void 0 && runner.residentClis.includes(agent.cli);
+    const resident = charter.resident && part === void 0 && runner.residentClis.includes(agent.cli);
     const residentKey = resident ? sessionKey(agent.name, dispatch.project) : null;
-    const token = residentKey === null ? this.board.issueTurnToken(agent.name, agent.role, this.tokenLifetime(5 * 6e4), dispatch.project, thread?.id) : this.residentToken(runner, residentKey, actor, dispatch.project);
+    const token = residentKey === null ? this.board.issueTurnToken(agent.name, agent.role, this.tokenLifetime(5 * 6e4), dispatch.project, part) : this.residentToken(runner, residentKey, actor, dispatch.project);
     const record = await this.board.beginTurn({
       ...base,
       session: recorded ?? null,
@@ -8164,6 +8985,7 @@ var TurnHost = class {
       ...agent.effort === void 0 ? {} : { effort: agent.effort },
       scope: dispatch.project,
       ...thread === void 0 ? {} : { thread: thread.id },
+      ...channel === void 0 ? {} : { channel },
       session: recorded ?? null,
       costSoFarUsd,
       instructions,
@@ -8202,6 +9024,7 @@ var TurnHost = class {
       agent: agent.name,
       project: dispatch.project,
       thread: thread?.id,
+      channel,
       runner: runner.name,
       session: recorded,
       newSession,
@@ -8239,6 +9062,7 @@ var TurnHost = class {
             agent: turn.job.agent,
             project: turn.job.scope,
             thread: turn.job.thread,
+            channel: turn.job.channel,
             messages: sent.messages
           }).catch((error) => {
             this.log.warn({ turnId, error: String(error) }, "could not record a steer");
@@ -8246,19 +9070,31 @@ var TurnHost = class {
         }
       }
       turn.transcript.push(entry);
-      this.onEvent?.(turn.job.agent, turn.job.scope, entry.event, turn.job.thread);
+      this.onEvent?.(turn.job.agent, turn.job.scope, entry.event, {
+        thread: turn.job.thread,
+        channel: turn.job.channel
+      });
     }
   }
   /** The turn in flight in a conversation, if any. */
-  turnIn(agent, scope, thread) {
+  turnIn(agent, scope, conversation = {}) {
     for (const turn of this.open.values()) {
       const { job } = turn;
-      if (job.agent === agent && job.scope === scope && job.thread === thread) {
+      if (job.agent === agent && job.scope === scope && job.thread === conversation.thread && job.channel === conversation.channel) {
         return { turnId: job.turnId, runner: turn.runner, cli: job.cli };
       }
     }
     return null;
   }
+  /** The turns in flight and their conversations, which the board checks before ending one. */
+  inFlight() {
+    return [...this.open.values()].map(({ job }) => ({
+      agent: job.agent,
+      scope: job.scope,
+      ...job.thread === void 0 ? {} : { thread: job.thread },
+      ...job.channel === void 0 ? {} : { channel: job.channel }
+    }));
+  }
   /** The turns in flight, for the interface: their conversations and where a mention reaches them. */
   runningTurns() {
     return [...this.open.values()].map((turn) => ({
@@ -8266,8 +9102,9 @@ var TurnHost = class {
       agent: turn.job.agent,
       scope: turn.job.scope,
       ...turn.job.thread === void 0 ? {} : { thread: turn.job.thread },
+      ...turn.job.channel === void 0 ? {} : { channel: turn.job.channel },
       cli: turn.job.cli,
-      ...turn.record.trigger.channel === void 0 ? {} : { channel: turn.record.trigger.channel },
+      ...turn.record.trigger.channel === void 0 ? {} : { askedIn: turn.record.trigger.channel },
       runner: turn.runner
     }));
   }
@@ -8288,7 +9125,8 @@ var TurnHost = class {
     const digest = await this.board.readDigest({
       ...turn.actor,
       scope: job.scope,
-      ...job.thread === void 0 ? {} : { thread: job.thread }
+      ...job.thread === void 0 ? {} : { thread: job.thread },
+      ...job.channel === void 0 ? {} : { channel: job.channel }
     }, {
       ...turn.delivered === null ? {} : { since_cursor: turn.delivered },
       advance: false,
@@ -8348,6 +9186,7 @@ var TurnHost = class {
       this.board.revokeTurnToken(turn.coldToken);
     }
     const { job } = turn;
+    const part = conversationPart(job);
     const finished = {
       ...turn.record,
       session: outcome.session,
@@ -8363,29 +9202,52 @@ var TurnHost = class {
       ...outcome.work === null ? {} : { work: outcome.work },
       ...outcome.exitReason === "stopped" ? { stoppedBy: turn.stopRequestedBy ?? USER_NAME } : {}
     };
+    const ended = await this.conversationEnded(job);
+    const closing = turn.record.trigger.kind === "closing";
+    const decided = closing && outcome.exitReason !== "error" && outcome.exitReason !== "timeout";
     const recorded = await this.recorded(turn, async () => {
       if (outcome.session !== job.session) {
-        await this.board.writeSession(job.agent, job.scope, job.cli, outcome.session, turn.runner, job.thread);
+        await this.board.writeSession(job.agent, job.scope, job.cli, outcome.session, turn.runner, part);
       }
       if (outcome.exitReason === "completed" || outcome.exitReason === "blocked" || outcome.exitReason === "stopped") {
-        await this.board.setDigestCursor(job.agent, job.scope, turn.delivered, job.thread);
+        await this.board.setDigestCursor(job.agent, job.scope, turn.delivered, part);
         await this.renewLeases(turn.actor, turn.held);
         if (outcome.status?.needsUserDecision === true) {
-          await this.askUser(turn.actor, job.scope, job.thread, turn.record.startedAt, outcome.status.summary);
+          await this.askUser(turn.actor, job, turn.record.startedAt, outcome.status.summary);
         }
       }
       await this.board.finishTurn(finished, turn.transcript);
+      const conversation = ended ? workspaceConversationOf(job) : null;
+      if (conversation !== null && (closing ? !decided : outcome.leftovers)) {
+        const again = await this.board.recordLeftovers({
+          agent: job.agent,
+          scope: job.scope,
+          conversation
+        });
+        if (!again) {
+          const where = conversation.kind === "thread" ? `thread ${conversation.id}` : `channel ${conversation.name}`;
+          await this.board.publishSignal({
+            kind: "stuck_workspace",
+            key: `stuck_workspace:${job.agent}:${job.scope}:${conversationPart(job) ?? ""}`,
+            summary: `${job.agent}'s workspace in ${where} still holds work on no branch after ${CLOSING_ATTEMPTS} closing turns failed, so it stays on runner ${turn.runner}`,
+            value: CLOSING_ATTEMPTS,
+            agent: job.agent,
+            ...job.scope === SOCIETY_SCOPE ? {} : { project: job.scope }
+          });
+        }
+      }
     });
     if (recorded) {
       this.log.info({
         agent: job.agent,
         project: job.scope,
         thread: job.thread,
+        channel: job.channel,
         exitReason: finished.exitReason
       }, "turn finished");
       turn.done(finished);
     }
-    return { dropWorkspace: await this.conversationEnded(job) };
+    return { dropWorkspace: ended && (closing ? decided : !outcome.leftovers) };
   }
   /** Ends a turn whose outcome will never come, as when its runner went away, as failed. */
   async abortTurn(turnId, reason) {
@@ -8433,6 +9295,7 @@ var TurnHost = class {
       agent: dispatch.agent,
       project: dispatch.project,
       ...dispatch.thread === void 0 ? {} : { thread: dispatch.thread.id },
+      ...dispatch.thread !== void 0 || dispatch.channel === void 0 ? {} : { channel: dispatch.channel },
       runner,
       cli: agent?.cli ?? null,
       session: null,
@@ -8477,48 +9340,66 @@ var TurnHost = class {
     this.residentTokens.set(slot, token);
     return token;
   }
-  /** Where a conversation works: a task's on its branch, any other thread's in a place of its own. */
-  async workspaceOf(project, thread) {
-    const own = thread === void 0 || thread.task ? {} : { thread: thread.id };
+  /**
+   * Where a conversation works: a task's on its branch, any other thread's and a channel's in a
+   * place of its own, and the home in the citizen's own.
+   */
+  async workspaceOf(project, thread, channel) {
+    const own = thread !== void 0 ? thread.task ? {} : { thread: thread.id } : channel === void 0 ? {} : { channel };
     if (project === null) {
       return { kind: "home", ...own };
     }
-    const repo = {
-      slug: project.slug,
-      origin: project.repo,
-      defaultBranch: project.defaultBranch
-    };
+    const repo = projectRepo(project);
     if (thread?.task === true) {
       return { kind: "task", repo, taskId: thread.id };
     }
     const branches = (await this.board.listTasks(project.slug)).filter((task) => task.status === "open" || task.status === "claimed").map((task) => `task/${task.id}`);
     return { kind: "project", repo, branches, ...own };
   }
-  /** Whether a thread conversation's task or thread has ended, which frees its workspace. */
+  /**
+   * Whether a thread conversation's task or thread has ended, or a channel conversation's channel
+   * was archived, which frees its workspace.
+   */
   async conversationEnded(job) {
-    if (job.thread === void 0) {
-      return false;
+    const conversation = workspaceConversationOf(job);
+    return conversation !== null && await this.board.conversationEnded(conversation);
+  }
+  /** Where a closed thread's citizens say what still needs saying: its channel, else its place's general. */
+  async replyIn(thread) {
+    return await this.board.channelOpen(thread.channel) ? thread.channel : channelRef(parseChannelRef(thread.channel).project, "general");
+  }
+  /**
+   * How a closing turn's conversation ended, and where its citizen asks someone else to take over
+   * work that is not its own: the thread's channel while it is open, else the place's general.
+   */
+  async endingOf(scope, thread, task, channel) {
+    const place = scope === SOCIETY_SCOPE ? null : scope;
+    if (thread !== void 0) {
+      const closed = `the thread "${thread.title}" on ${thread.channel} was closed${thread.closedBy === void 0 ? "" : ` by ${thread.closedBy}`}${task === null ? "" : `, its task ${task.status}`}`;
+      return { how: closed, askIn: await this.replyIn(thread) };
     }
-    try {
-      if (job.workspace.kind === "task") {
-        const { task } = await this.board.findTask(job.thread);
-        return task.status === "done" || task.status === "abandoned";
-      }
-      return (await this.board.readThread(job.thread)).state === "closed";
-    } catch {
-      return false;
+    if (channel === void 0) {
+      return null;
     }
+    const ref = channelRef(place, channel);
+    const archived = (await this.board.listChannels()).find((each) => each.ref === ref)?.archived;
+    return {
+      how: archived === void 0 ? `${ref} was archived` : `${ref} was archived by ${archived.by}: ${archived.reason}`,
+      askIn: channelRef(place, "general")
+    };
   }
   /**
    * A turn that reported the user must decide asks where the question belongs, with a mention of
    * the user, which is what puts it before them. One that mentioned the user nowhere asks in its
    * own thread when it was in one that is still open, so the answer comes back to the same
-   * conversation, and otherwise in a thread of its own on its scope's general channel, opened as the
-   * citizen with its summary. One that proposed something the user decides has put its decision
-   * before the user already, where deciding it clears it; a mention would stay until the user
-   * posted beside it.
+   * conversation, and otherwise in a thread of its own on its conversation's channel, or its scope's
+   * general for the home, opened as the citizen with its summary. One that proposed something the
+   * user decides has put its decision before the user already, where deciding it clears it; a
+   * mention would stay until the user posted beside it.
    */
-  async askUser(actor, scope, threadId, since, summary) {
+  async askUser(actor, job, since, summary) {
+    const threadId = job.thread;
+    const place = job.scope === SOCIETY_SCOPE ? null : job.scope;
     try {
       if (await this.board.hasMentioned(actor.name, USER_NAME, since)) {
         return;
@@ -8536,7 +9417,7 @@ var TurnHost = class {
         return;
       }
       const thread = await this.board.openThread(actor, {
-        channel: scope === SOCIETY_SCOPE ? "general" : `${scope}/general`,
+        channel: channelRef(place, job.channel ?? "general"),
         title: `${actor.name} asks for a decision: ${summary}`.slice(0, 200)
       });
       await this.board.postMessage(actor, {
@@ -8587,12 +9468,15 @@ var DEFAULT_GRACE_MS = 2 * 6e4;
 var DEFAULT_REQUEST_TIMEOUT_MS = 10 * 6e4;
 var CONTROL_TIMEOUT_MS = 15e3;
 var FILE_TIMEOUT_MS = 6e4;
+var SWEEP_TIMEOUT_MS = 2 * 6e4;
+var DEFAULT_ACK_TIMEOUT_MS = 3e4;
 var RunnerHub = class {
   board;
   host;
   version;
   graceMs;
   requestTimeoutMs;
+  ackTimeoutMs;
   now;
   log;
   seats = /* @__PURE__ */ new Map();
@@ -8608,6 +9492,7 @@ var RunnerHub = class {
     this.version = options.version;
     this.graceMs = options.graceMs ?? DEFAULT_GRACE_MS;
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.ackTimeoutMs = options.ackTimeoutMs ?? DEFAULT_ACK_TIMEOUT_MS;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.log = options.log ?? SILENT2;
     this.startedAt = this.now().getTime();
@@ -8623,9 +9508,15 @@ var RunnerHub = class {
   // -------------------------------------------------------------------------------------------
   // The protocol, as the server's routes call it
   // -------------------------------------------------------------------------------------------
+  /** The jobs sent to a runner that it has not acknowledged yet. */
+  unacknowledged(runner) {
+    return [...this.seats.get(runner)?.unacked.keys() ?? []];
+  }
   /**
-   * A runner registers, first or again. Its turns in flight that it no longer runs, because it
-   * restarted, end as failed.
+   * A runner registers, first or again. A turn in flight it still runs, or whose job it never
+   * acknowledged, carries on, the latter sent again once its stream opens, since a job written
+   * into a stream that had stopped delivering never arrived; one it took and no longer runs,
+   * because it restarted, ends as failed.
    */
   async register(name, hello) {
     if (hello.protocol !== RUNNER_PROTOCOL) {
@@ -8640,25 +9531,31 @@ var RunnerHub = class {
         inUse: 0,
         warm: /* @__PURE__ */ new Set(),
         disconnectedAt: null,
-        grace: null
+        grace: null,
+        unacked: /* @__PURE__ */ new Map(),
+        unconfirmed: false
       });
     } else {
       seat.hello = hello;
       seat.warm = /* @__PURE__ */ new Set();
     }
     const still = new Set(hello.turns);
+    const unacked = this.seats.get(name)?.unacked ?? /* @__PURE__ */ new Map();
     for (const turnId of this.host.turnsOn(name)) {
-      if (!still.has(turnId)) {
+      if (still.has(turnId)) {
+        this.settle(unacked, turnId);
+      } else if (!unacked.has(turnId)) {
         await this.host.abortTurn(turnId, `runner ${name} restarted during the turn`);
       }
     }
     await this.board.markRunner(name, {
       os: hello.os,
       clis: hello.clis,
-      capabilities: hello.capabilities
+      capabilities: hello.capabilities,
+      version: hello.version
     });
     this.runnerChanged(name);
-    this.log.info({ runner: name, clis: hello.clis, slots: hello.slots }, "runner registered");
+    this.log.info({ runner: name, version: hello.version, clis: hello.clis, slots: hello.slots }, "runner registered");
     return { name, version: this.version };
   }
   /** A registered runner's stream opened. Returns what to call when it closes. */
@@ -8669,10 +9566,17 @@ var RunnerHub = class {
     }
     seat.send = send;
     seat.disconnectedAt = null;
+    seat.unconfirmed = false;
     if (seat.grace !== null) {
       clearTimeout(seat.grace);
       seat.grace = null;
     }
+    for (const { job } of seat.unacked.values()) {
+      if (send({ type: "turn", job })) {
+        this.expectAck(seat, job);
+        this.log.info({ runner: name, turnId: job.turnId }, "sent again a job the runner never took");
+      }
+    }
     await this.board.markRunner(name, { status: "connected" });
     this.runnerChanged(name);
     return async () => {
@@ -8697,6 +9601,9 @@ var RunnerHub = class {
         clearTimeout(seat.grace);
         seat.grace = null;
       }
+      for (const { timer } of seat.unacked.values()) {
+        clearTimeout(timer);
+      }
     }
     await Promise.allSettled(this.detaching);
   }
@@ -8704,6 +9611,18 @@ var RunnerHub = class {
     this.assertOwns(runner, turnId);
     await this.host.addEvents(turnId, entries);
   }
+  /** A runner's word that a turn's job arrived, which also shows its stream delivers again. */
+  received(runner, turnId) {
+    const seat = this.seats.get(runner);
+    if (seat === void 0 || !seat.unacked.has(turnId)) {
+      return;
+    }
+    this.settle(seat.unacked, turnId);
+    if (seat.unconfirmed) {
+      seat.unconfirmed = false;
+      this.log.info({ runner }, "runner is taking jobs again");
+    }
+  }
   async turnOutcome(runner, turnId, outcome) {
     this.assertOwns(runner, turnId);
     const ack = await this.host.closeTurn(turnId, outcome);
@@ -8722,6 +9641,25 @@ var RunnerHub = class {
       pending.reject(new Error(answer.error));
     }
   }
+  /**
+   * The workspaces a runner holds, reported when its stream opens: those of conversations that
+   * ended while it was away are swept there now, as a sweep at their end would have.
+   */
+  heldWorkspaces(runner, workspaces) {
+    const seat = this.seats.get(runner);
+    if (seat === void 0) {
+      return;
+    }
+    const conversations = /* @__PURE__ */ new Map();
+    for (const { conversation } of workspaces) {
+      conversations.set(JSON.stringify(conversation), conversation);
+    }
+    for (const conversation of conversations.values()) {
+      void this.board.conversationEnded(conversation).then((ended) => ended ? this.sweepOn(seat, conversation) : void 0).catch((error) => {
+        this.log.warn({ runner, conversation, error: String(error) }, "could not sweep");
+      });
+    }
+  }
   warmChanged(runner, warm) {
     const seat = this.seats.get(runner);
     if (seat !== void 0) {
@@ -8771,12 +9709,25 @@ var RunnerHub = class {
   // -------------------------------------------------------------------------------------------
   // The scheduler's runner
   // -------------------------------------------------------------------------------------------
+  /**
+   * A conversation ended: every connected runner removes its citizens' workspaces for it, and
+   * those kept for holding work on no branch are recorded, which gives their citizens a closing
+   * turn. A runner away now sweeps when it reports its workspaces on reconnecting.
+   */
+  async sweep(conversation) {
+    await Promise.all([...this.seats.values()].filter((seat) => seat.send !== null).map((seat) => this.sweepOn(seat, conversation).catch((error) => {
+      this.log.warn({ runner: seat.name, conversation, error: String(error) }, "could not sweep");
+    })));
+  }
   /**
    * Delivers what arrived in a conversation into its turn in flight, when that turn's runner can
    * steer its CLI. `refused` leaves the wake to a turn of its own once this one ends.
    */
   async steer(conversation) {
-    const turn = this.host.turnIn(conversation.agent, conversation.project, conversation.thread);
+    const turn = this.host.turnIn(conversation.agent, conversation.project, {
+      thread: conversation.thread,
+      channel: conversation.channel
+    });
     const seat = turn === null ? void 0 : this.seats.get(turn.runner);
     if (turn === null || seat === void 0 || seat.send === null) {
       return "refused";
@@ -8815,7 +9766,7 @@ var RunnerHub = class {
       return { refused: `${agent.name} has no CLI binding` };
     }
     const cli = agent.cli;
-    const free = (seat) => seat.send !== null && seat.hello.clis.includes(cli) && (seat.hello.slots === null || seat.inUse < seat.hello.slots);
+    const free = (seat) => seat.send !== null && !seat.unconfirmed && seat.hello.clis.includes(cli) && (seat.hello.slots === null || seat.inUse < seat.hello.slots);
     let chosen;
     if (dispatch.project === SOCIETY_SCOPE) {
       chosen = await this.pinnedSeat(agent.name, agent.homeRunner, cli, free);
@@ -8854,6 +9805,7 @@ var RunnerHub = class {
       return this.host.refuseTurn(dispatch, "none", assignment.refused);
     }
     const seat = this.seats.get(assignment.runner);
+    let turnId = null;
     try {
       if (seat === void 0) {
         return await this.host.refuseTurn(dispatch, assignment.runner, "the runner is gone");
@@ -8864,11 +9816,17 @@ var RunnerHub = class {
       }
       if (seat.send === null || !seat.send({ type: "turn", job: opened.job })) {
         await this.host.abortTurn(opened.job.turnId, `runner ${seat.name} went away before the turn`);
+      } else {
+        this.expectAck(seat, opened.job);
       }
+      turnId = opened.job.turnId;
       return await opened.ended;
     } finally {
       if (seat !== void 0) {
         seat.inUse = Math.max(0, seat.inUse - 1);
+        if (turnId !== null) {
+          this.settle(seat.unacked, turnId);
+        }
       }
     }
   }
@@ -8877,7 +9835,7 @@ var RunnerHub = class {
     if (!task.completing) {
       return "done";
     }
-    if (task.onDone !== "merge") {
+    if (task.onDone === "none") {
       await this.board.finishCompletion(SYSTEM_ACTOR, {
         taskId,
         ok: true,
@@ -8887,6 +9845,15 @@ var RunnerHub = class {
     }
     const record = await this.board.readProject(project);
     const branch = `task/${taskId}`;
+    const pull = task.onDone === "ghpr" ? task.pullRequest : void 0;
+    if (task.onDone === "ghpr" && pull === void 0) {
+      await this.board.finishCompletion(SYSTEM_ACTOR, {
+        taskId,
+        ok: false,
+        detail: "no pull request is linked to the task"
+      });
+      return "done";
+    }
     let outcome = { ok: true, detail: "nothing to land, since the task left no branch" };
     if (record.runner !== void 0) {
       const seat = this.seats.get(record.runner);
@@ -8898,8 +9865,15 @@ var RunnerHub = class {
           type: "land",
           request,
           land: {
-            repo: { slug: record.slug, origin: record.repo, defaultBranch: record.defaultBranch },
-            branch
+            repo: projectRepo(record),
+            branch,
+            ...pull === void 0 ? {} : {
+              pullRequest: {
+                url: pull.url,
+                ...pull.subject === void 0 ? {} : { subject: pull.subject },
+                ...pull.body === void 0 ? {} : { body: pull.body }
+              }
+            }
           }
         })));
       } catch (error) {
@@ -8975,6 +9949,34 @@ var RunnerHub = class {
     }
   }
   // -------------------------------------------------------------------------------------------
+  /**
+   * Waits for a runner to acknowledge a job. One that does not in time may be behind a stream that
+   * looks open but delivers nothing, as when its machine's network stops passing traffic, so no
+   * more turns go to it until it acknowledges or connects again; the turns it has carry on, since
+   * they report by posts.
+   */
+  expectAck(seat, job) {
+    const previous = seat.unacked.get(job.turnId);
+    if (previous !== void 0) {
+      clearTimeout(previous.timer);
+    }
+    const timer = setTimeout(() => {
+      if (!seat.unacked.has(job.turnId) || seat.unconfirmed || seat.send === null) {
+        return;
+      }
+      seat.unconfirmed = true;
+      this.log.warn({ runner: seat.name, turnId: job.turnId, waitedMs: this.ackTimeoutMs }, "runner has not acknowledged a job; no more turns go to it until it does or reconnects");
+    }, this.ackTimeoutMs);
+    timer.unref?.();
+    seat.unacked.set(job.turnId, { job, timer });
+  }
+  settle(unacked, turnId) {
+    const entry = unacked.get(turnId);
+    if (entry !== void 0) {
+      clearTimeout(entry.timer);
+      unacked.delete(turnId);
+    }
+  }
   async detach(seat) {
     seat.send = null;
     this.runnerChanged(seat.name);
@@ -8995,7 +9997,7 @@ var RunnerHub = class {
         return;
       }
       for (const turnId of this.host.turnsOn(seat.name)) {
-        void this.host.abortTurn(turnId, `runner ${seat.name} went away during the turn`);
+        void this.host.abortTurn(turnId, seat.unacked.has(turnId) ? `the turn never reached runner ${seat.name}, which went away` : `runner ${seat.name} went away during the turn`);
       }
     }, this.graceMs);
     seat.grace.unref?.();
@@ -9072,7 +10074,7 @@ var RunnerHub = class {
     }
     return {
       seat,
-      repo: { slug: record.slug, origin: record.repo, defaultBranch: record.defaultBranch }
+      repo: projectRepo(record)
     };
   }
   assertOwns(runner, turnId) {
@@ -9081,6 +10083,12 @@ var RunnerHub = class {
       throw new RunnerProtocolError(`turn ${turnId} is not ${runner}'s`);
     }
   }
+  async sweepOn(seat, conversation) {
+    const { kept } = SweepResultSchema.parse(await this.request(seat, (request) => ({ type: "sweep", request, conversation }), SWEEP_TIMEOUT_MS));
+    for (const workspace of kept) {
+      await this.board.recordLeftovers(workspace);
+    }
+  }
   request(seat, message, timeoutMs = this.requestTimeoutMs) {
     const request = randomUUID2();
     return new Promise((resolve, reject) => {
@@ -9531,11 +10539,19 @@ function runnerRoutes(board2, hub, enrollments, enrollLimit) {
     await hub.turnEvents(c.get("runner"), UlidSchema.parse(c.req.param("id")), entries);
     return c.json({ ok: true });
   });
+  routes.post("/turns/:id/received", (c) => {
+    hub.received(c.get("runner"), UlidSchema.parse(c.req.param("id")));
+    return c.json({ ok: true });
+  });
   routes.post("/turns/:id/outcome", async (c) => c.json(await hub.turnOutcome(c.get("runner"), UlidSchema.parse(c.req.param("id")), TurnOutcomeSchema.parse(await c.req.json()))));
   routes.post("/requests/:id", async (c) => {
     hub.answer(c.get("runner"), c.req.param("id"), RunnerAnswerSchema.parse(await c.req.json()));
     return c.json({ ok: true });
   });
+  routes.post("/workspaces", async (c) => {
+    hub.heldWorkspaces(c.get("runner"), HeldWorkspacesSchema.parse(await c.req.json()).workspaces);
+    return c.json({ ok: true });
+  });
   routes.post("/warm", async (c) => {
     hub.warmChanged(c.get("runner"), WarmSessionsSchema.parse(await c.req.json()).warm);
     return c.json({ ok: true });
@@ -9701,6 +10717,7 @@ function createApp(deps) {
   });
   api.delete("/sign-in", async (c) => c.json({ signedOut: await board2.signOut(bearer2(c) ?? "") }));
   api.get("/society", async (c) => c.json(await board2.society()));
+  api.get("/version", (c) => c.json({ version }));
   api.get("/agents", async (c) => c.json((await board2.listAgents()).map(({ tokenHash: _hash, ...agent }) => agent)));
   api.get("/members", async (c) => c.json(await board2.listMembers()));
   api.get("/agents/:name/turns", async (c) => c.json(await board2.listTurns(c.req.param("name"), Number(c.req.query("limit") ?? "50"))));
@@ -10132,15 +11149,16 @@ var TurnHub = class {
   get lastSeq() {
     return this.seq;
   }
-  /** Records one event of a turn, in its scope and, for a thread's conversation, its thread. */
-  push(agent, project, event, thread) {
+  /** Records one event of a turn, in its scope and its conversation there: a thread's, a channel's, or home. */
+  push(agent, project, event, conversation = {}) {
     this.seq += 1;
     const item = {
       seq: this.seq,
       ts: this.now().toISOString(),
       agent,
       project,
-      ...thread === void 0 ? {} : { thread },
+      ...conversation.thread === void 0 ? {} : { thread: conversation.thread },
+      ...conversation.channel === void 0 ? {} : { channel: conversation.channel },
       event
     };
     this.buffer.push(item);
@@ -10192,12 +11210,13 @@ var host = new TurnHost({
   maxTurns: config.toolRounds,
   residentIdleMs: config.residentIdleMs,
   log,
-  onEvent: (agent, scope, event, thread) => {
-    turns.push(agent, scope, event, thread);
-    log.debug({ agent, scope, thread, event }, "agent event");
+  onEvent: (agent, scope, event, conversation) => {
+    turns.push(agent, scope, event, conversation);
+    log.debug({ agent, scope, ...conversation, event }, "agent event");
   }
 });
 var runners = new RunnerHub({ board, host, version: VERSION, log });
+board.watchTurns(() => host.inFlight());
 var concurrency = config.concurrency ?? Number.POSITIVE_INFINITY;
 var timings = parseTimings(JSON.parse(process.env["STELLARIS_TIMINGS"] ?? "{}"));
 var scheduler = new Scheduler({ board, runner: runners, log, concurrency, timings });