@celsoft/coordinator 0.0.0 → 0.1.0

package/build/_server.ts-OB4O27HF.js

@@ -0,0 +1,683 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  describe
+} from "./chunk-UEKOZGRO.js";
+import {
+  StageName
+} from "./chunk-4CIG53L5.js";
+import {
+  AskKind,
+  CONSOLE,
+  IssueMove,
+  IssueState,
+  IssueType,
+  Leash,
+  USER,
+  addressOfIssue,
+  cmp,
+  followersOf,
+  get,
+  isLive,
+  issueOrder,
+  latestPerSlot,
+  openAsk,
+  slotOf,
+  unfinishedFollowers,
+  waitingOn
+} from "./chunk-PDCON4KS.js";
+import {
+  json
+} from "./chunk-SU26PJVX.js";
+import {
+  CommitEmail,
+  CommitName,
+  GitHubName,
+  SshKey
+} from "./chunk-Q4OQNY5M.js";
+import {
+  SecretName
+} from "./chunk-SOJTASZC.js";
+import "./chunk-WOPREK6Q.js";
+import {
+  DocName,
+  docAddress,
+  docOfPath,
+  docPath
+} from "./chunk-MC5AGLMY.js";
+import {
+  Branch,
+  EditableKind,
+  PartName,
+  RepoSettingsChange,
+  Slot,
+  Track,
+  WRITING_RULE,
+  isSlot
+} from "./chunk-HGYE3UTU.js";
+import {
+  Commit,
+  FollowerRepos,
+  IssueAddress,
+  IssueLink,
+  IssueTitle,
+  Link,
+  Repo,
+  Slug,
+  external_exports,
+  oneLine
+} from "./chunk-NCZ77J5E.js";
+import "./chunk-LFP3UPCM.js";
+
+// node_modules/.pnpm/smol-toml@1.9.1/node_modules/smol-toml/dist/stringify.js
+var HAS_WELLFORMED = !!"".isWellFormed;
+
+// build/server/entries/endpoints/state.json/_server.ts.js
+var VersionSchema = external_exports.object({
+  n: external_exports.number().int().positive(),
+  by: external_exports.string(),
+  at: external_exports.string()
+});
+external_exports.object({
+  format: external_exports.number().int().max(1, "a document record newer than this coordinator"),
+  issue: external_exports.string(),
+  name: external_exports.string(),
+  title: external_exports.string(),
+  by: external_exports.string(),
+  key: external_exports.string(),
+  created_at: external_exports.string(),
+  versions: external_exports.array(VersionSchema).min(1)
+});
+var latest = (record) => record.versions.at(-1).n;
+var updatedAt = (record) => record.versions.at(-1).at;
+var text$1 = (description) => external_exports.string().min(1).describe(description);
+var Recipient = external_exports.string().transform((value) => value === "sean" ? USER : value).refine((value) => value === "user" || isSlot(value), { error: (i) => `'${String(i.input)}' is not a slot, org/repo@track` });
+var repoField = (description) => Repo.describe(description);
+var issueField = (description = "the issue, org/repo#slug") => IssueAddress.describe(description);
+var SendBody = external_exports.strictObject({
+  to: Recipient.describe("a slot, org/repo@track, or user"),
+  text: text$1("the message"),
+  about: issueField("the issue it concerns, org/repo#slug").optional()
+});
+var existingField = external_exports.boolean().describe("when a follower repo's slot on the track already exists, or a worktree is at its place, make it the follower; left out, such a follower refuses the whole request");
+var StartBody = external_exports.strictObject({
+  type: text$1("an Agent Type's name"),
+  track: Track.describe("the track it goes down, a valid git branch name (it names its tab and branch); agents in several repos share a track by naming the same one, and slashes group tracks, as in web/login"),
+  task: text$1("everything the agent needs to do its work"),
+  repo: repoField("the repo to start it in, as org/repo from the catalog's repos; default is your own").optional(),
+  profile: PartName.describe("a profile to give it on top of its repo's: its skills are added, and its handlers follow the repo's at each event").optional(),
+  leash: Leash.describe("gated (the default): it asks the user before building and before landing; free: it asks neither").optional(),
+  keep_open: external_exports.boolean().describe("keep it running after its work lands; default false, so the bus ends it").optional(),
+  issue: issueField("an issue of the repo for it to hold: the bus gives it to the new slot before starting, or holding, the agent, refuses the start if it cannot, and tells the agent in its task").optional(),
+  also: external_exports.array(IssueAddress).describe("other issues of the repo, related to issue, for it to hold and work in the same branch; each is given to the slot with issue, or the start is refused whole; none may name follower repos").optional(),
+  existing: existingField.optional()
+});
+var AskBody = external_exports.strictObject({
+  kind: AskKind.describe("plan: your approach, before building; done: your finished work, before landing; pr: a pr you are about to send; question: a decision"),
+  text: oneLine("An ask", 300).describe("what you ask, in one line of at most 300 characters, as the user will see it on their page and console"),
+  about: issueField("the issue it concerns, org/repo#slug").optional()
+});
+var LeashBody = external_exports.strictObject({
+  to: Slot.describe("the slot whose leash changes"),
+  leash: Leash.describe("gated or free").optional(),
+  keep_open: external_exports.boolean().describe("keep its agent running after its work lands").optional()
+});
+var LeadBody = external_exports.strictObject({
+  to: Slot.describe("the slot that follows"),
+  lead: Slot.describe("the slot that leads it; leave it out to clear its lead").optional()
+});
+var FollowerBody = external_exports.strictObject({
+  lead: Slot.describe("the slot that leads it: your own, unless you are user"),
+  repo: repoField("the follower repo, org/repo: its slot on the lead's track follows the lead"),
+  type: text$1("the Agent Type for a new agent there; default free").optional(),
+  task: text$1("what the follower is for, given to a new agent there; the bus adds that it follows the lead and introduces itself").optional(),
+  existing: existingField.optional()
+});
+var FollowerAnswerBody = external_exports.strictObject({
+  request: external_exports.number().int().min(1).describe("the follower request's id"),
+  approve: external_exports.boolean().describe("true runs it as if user sent it; false declines it"),
+  note: text$1("why, told to the lead").optional()
+});
+var IssueFollowersBody = external_exports.strictObject({
+  issue: IssueAddress.describe("the issue, org/repo#slug"),
+  repos: FollowerRepos.describe("the issue's follower repos, org/repo each, replacing the list; empty clears it")
+});
+var LandedBody = external_exports.strictObject({
+  commit: Commit.describe("the commit the work landed as, on the repo's default branch: its hash, short or full; the bus links it; leave it out when there was nothing to push").optional(),
+  note: text$1("what was done, in a line or two").optional(),
+  about: issueField("the issue the work was for, which this closes").optional()
+});
+var LandBody = external_exports.strictObject({
+  title: oneLine("A title", 200).describe("the work in one line of at most 200 characters: the PR's title, or what the push to the default branch carries"),
+  summary: oneLine("A summary", 300).describe("the change in one plain sentence of at most 300 characters, the line the repo's history shows under the title; required unless no_code").optional(),
+  built: external_exports.string().trim().min(1).max(4e3).describe("what was built, in a few plain lines, as the repo's history keeps it for this landing; required unless no_code").optional(),
+  challenges: external_exports.string().max(4e3).describe("what was hard along the way, in a few plain lines: dead ends, surprises, and above all any change a rebase forced on how something works; empty when nothing was").optional(),
+  body: external_exports.string().describe("the PR's description; left out, it is made from summary, built, and challenges").optional(),
+  about: issueField("the issue the work is for, which landing closes when end is set").optional(),
+  end: external_exports.boolean().describe("this is your last landing: close the issue in about and end you once you rest; leave it out to keep working").optional(),
+  also: external_exports.array(IssueAddress).describe("other issues you hold that this work finishes, closed with about when end is set").optional(),
+  no_code: external_exports.boolean().describe("your work has nothing to push: the bus checks your branch has no commits to land, pushes nothing, and finishes it as a landing with title as its note").optional()
+}).superRefine((b, ctx) => {
+  if (b.no_code) return;
+  for (const field of ["summary", "built"]) if (!b[field]) ctx.addIssue({
+    code: "custom",
+    path: [field],
+    message: `${field} is required on a land with code: the repo's history keeps it for this landing`
+  });
+});
+var ChangesBody = external_exports.strictObject({
+  repo: repoField("the repo, org/repo, one the bus keeps"),
+  before: external_exports.number().int().min(1).describe("only those older than this id, for the page after one already read").optional(),
+  from: external_exports.string().trim().min(1).max(200).describe("with to, a commit or tag: only the landings whose commits are in from..to, oldest first, all at once").optional(),
+  to: external_exports.string().trim().min(1).max(200).describe("with from, a commit, tag, or branch; the default branch on origin when only from is given").optional()
+});
+var PushBody = external_exports.strictObject({});
+var PrBody = external_exports.strictObject({
+  repo: repoField("the repo the PR is in, org/repo, one the bus keeps; default is your own").optional(),
+  head: Branch.describe("the branch the PR is from, a local branch of that repo's clone (any of its worktrees); the bus pushes it first"),
+  base: Branch.describe("the branch the PR goes into, on origin"),
+  title: oneLine("A title", 200).describe("the PR's title, in one line of at most 200 characters"),
+  body: external_exports.string().describe("the PR's description").optional(),
+  about: issueField("the issue the work is for; the PR is commented on it, and it is never closed by this").optional()
+});
+var PrCloseBody = external_exports.strictObject({
+  repo: repoField("the repo the PR is in, org/repo; default is your own").optional(),
+  number: external_exports.number().int().min(1).describe("the Work PR's number, as pr answered")
+});
+var GitHubBody = external_exports.strictObject({
+  what: external_exports.enum(["pr"]).describe("what to read: pr (its state, checks, mergeability, reviews, and comments)"),
+  number: external_exports.number().int().min(1).describe("the PR's number in your repo; default is your open PR").optional()
+});
+var RepoSettingsBody = external_exports.strictObject({
+  repo: repoField("the repo, org/repo"),
+  settings: RepoSettingsChange.describe("the settings to change, by name, each checked by its own rule; null clears one back to none chosen")
+});
+var StopBody = external_exports.strictObject({ to: Slot.describe("the slot of the agent to stop") });
+var ResumeBody = external_exports.strictObject({ to: Slot.describe("the slot to bring back up") });
+var AdoptBody = external_exports.strictObject({
+  type: text$1("the Agent Type that drives the slot once it is brought up"),
+  track: Track.describe("the track: the branch the worktree has checked out"),
+  repo: repoField("the repo, as org/repo from the catalog's repos"),
+  task: text$1("what the slot is for, given to its agent when it is brought up")
+});
+var IssueOpenBody = external_exports.strictObject({
+  slug: Slug.describe("a short name unique in its repo, such as fix-login"),
+  title: IssueTitle.describe("what it is, in one line of at most 120 characters"),
+  type: IssueType.describe("bug, feature, task, or chore; default task").optional(),
+  description: external_exports.string().default("").describe("the details"),
+  repo: repoField("the repo it is for, org/repo; default is your own").optional(),
+  holder: Slot.describe("a slot of that repo to hold it at once: your own, to come back to later, or one you work with").optional(),
+  blocked_by: external_exports.array(IssueAddress).describe("issues in any repo it waits on: it is blocked until each has landed").optional(),
+  links: external_exports.array(IssueLink).describe("links to its work outside the bus, such as its ticket").optional()
+});
+var IssueBody = external_exports.strictObject({ issue: issueField() });
+var IssueAssignBody = external_exports.strictObject({
+  issue: issueField(),
+  to: Slot.describe("the slot of the issue's repo to hold it"),
+  existing: existingField.optional()
+});
+var IssueAskBody = external_exports.strictObject({
+  issue: issueField(),
+  reason: text$1("why you need it")
+});
+var IssueKeepBody = external_exports.strictObject({
+  issue: issueField(),
+  reason: text$1("why you are keeping it")
+});
+var IssueBlockBody = external_exports.strictObject({
+  issue: issueField(),
+  on: issueField("the issue it waits on, in any repo, org/repo#slug")
+});
+var IssueUnblockBody = external_exports.strictObject({
+  issue: issueField(),
+  on: issueField("the issue it should stop waiting on, org/repo#slug")
+});
+var IssueCommentBody = external_exports.strictObject({
+  issue: issueField(),
+  text: text$1("the comment")
+});
+var IssueLinkBody = external_exports.strictObject({
+  issue: issueField(),
+  ...IssueLink.shape,
+  remove: external_exports.boolean().describe("true to take the link with this url away").optional()
+});
+var PlanLink = external_exports.string().refine((v) => Link.safeParse(v).success || /^(https?:\/\/[^/]+)?\//.test(v) && !!docOfPath(v), { error: "A link is an https URL, or a document link from doc_publish." });
+var IssuePlanBody = external_exports.strictObject({
+  issue: issueField(),
+  link: PlanLink.describe("the plan's page: the link doc_publish answered, or an https URL; a new link adds a plan, a known one updates it"),
+  name: oneLine("A plan name", 60).describe("what this plan covers, any name that suits the work, such as Phase 2: the page; Plan when left out").optional(),
+  approved: external_exports.boolean().describe("true once the user has approved this plan; the bus is the record of approval").optional(),
+  replaces: PlanLink.describe("the link of a plan already on the issue that this link takes the place of, keeping its name and approval, such as a plan moved to a document").optional()
+});
+var IssuePlanDeleteBody = external_exports.strictObject({
+  issue: issueField(),
+  link: PlanLink.describe("the link of the plan to delete, as issue_plan recorded it or doc_publish answered it")
+});
+var DocPublishBody = external_exports.strictObject({
+  issue: issueField("the issue it belongs to, org/repo#slug, of your own repo"),
+  name: DocName.describe("its name in the issue, a slug such as store-design; a new name makes a document, a known one replaces its newest version until the issue lands, then adds the next"),
+  title: oneLine("A title", 120).describe("its title, as the issue and its page show it"),
+  path: text$1("the page to publish: an HTML file, or a folder with an index.html and the files it loads (plan.json, mockups, images), at most 64MB")
+});
+var IssueCloseBody = external_exports.strictObject({
+  issue: issueField(),
+  note: text$1("what was done, or why it is closed")
+});
+var IssuesBody = external_exports.strictObject({
+  repo: repoField("only this repo, org/repo").optional(),
+  state: IssueState.describe("open (no slot holds it), held (a slot holds it), or closed").optional(),
+  holder: Slot.describe("only issues this slot holds").optional()
+});
+var IssueTakeBody = external_exports.strictObject({ issue: issueField("the issue, org/repo#slug; leave it out to take the first free open issue in your repo's order").optional() });
+var IssueMoveBody = external_exports.strictObject({
+  issue: issueField(),
+  to: IssueMove.describe("top, up, or down in its repo's order of open issues")
+});
+var IssueHandOverBody = IssueBody;
+var IssueReleaseBody = IssueBody;
+var BADGE_TONES = [
+  "neutral",
+  "info",
+  "success",
+  "warning",
+  "danger"
+];
+var SlotBody = external_exports.strictObject({ slot: Slot.describe("the slot, org/repo@track") });
+var SlotPropertyBody = external_exports.strictObject({
+  slot: Slot.describe("the slot, org/repo@track"),
+  name: oneLine("A name", 40).describe("its name, shown as its key; setting it again replaces it"),
+  value: oneLine("A value", 200).describe("its value; leave it out to clear the property").optional(),
+  link: Link.describe("an https URL its value opens").optional()
+});
+var SlotBadgeBody = external_exports.strictObject({
+  slot: Slot.describe("the slot, org/repo@track"),
+  name: oneLine("A name", 40).describe("its key, never shown; setting it again replaces the badge in place"),
+  label: oneLine("A label", 40).describe("the words it shows; leave it out to clear the badge").optional(),
+  tone: external_exports.enum(BADGE_TONES).default("neutral").describe("its color: neutral, info, success, warning, or danger")
+});
+var SlotsBody = external_exports.strictObject({
+  track: Track.describe("only slots on this track").optional(),
+  repo: repoField("only slots of this repo, org/repo").optional(),
+  live: external_exports.boolean().describe("only slots with an agent running").optional()
+});
+var ReposBody = external_exports.strictObject({
+  repo: repoField("one repo, org/repo: its branches and worktrees, each joined to its slot, agent, and issues").optional(),
+  fresh: external_exports.boolean().describe("read git again now, and the default branch, rather than what was read in the last few seconds").optional()
+});
+var RepoAddBody = external_exports.strictObject({ repo: text$1("org/repo, or any GitHub URL to the repo or a page in it") });
+var SecretKeyBody = external_exports.strictObject({
+  name: SecretName.describe("the secret's name, an environment variable's: capitals, digits, and underscores, such as STRIPE_KEY"),
+  repo: repoField("the repo whose .env.secrets gets it, org/repo; default is your own").optional(),
+  slot: external_exports.boolean().describe("true to add it to your own slot's .env.secrets instead, for this track's work only").optional(),
+  about: issueField("the issue it is for, org/repo#slug").optional()
+});
+var RepoForgetBody = external_exports.strictObject({ repo: repoField("the repo to stop keeping, org/repo") });
+var partKind = EditableKind.describe("profile (what agents get, kept in a Repo) or attachment (a folder of skills)");
+var ProfileSaveBody = external_exports.strictObject({
+  kind: partKind,
+  name: PartName.describe("its name, lowercase words joined by hyphens; a new name creates it"),
+  repo: repoField("for a new profile, the kept repo to keep it in, org/repo").optional(),
+  seen: external_exports.string().describe("the profile's hash as you read it, so a change over a newer version is refused").optional(),
+  change: external_exports.record(external_exports.string(), external_exports.unknown()).describe('the fields to set: for a profile description, skills (per skill group, "all" or a list of its skill names), on_for (org/repo, org/*, or *), handlers (each {name, event, text, every?}), and actions (each {name, label, view: repo, slot, or issue, task, description?}); for an attachment description and path. ' + WRITING_RULE)
+});
+var ProfileDeleteBody = external_exports.strictObject({
+  kind: partKind,
+  name: PartName.describe("its name")
+});
+var ProfilesMoveBody = external_exports.strictObject({ repo: repoField("the kept repo to keep them in, org/repo") });
+var ProfilesBody = external_exports.strictObject({});
+var FoldersBody = external_exports.strictObject({ path: external_exports.string().trim().min(1).describe("a folder under ~, written from ~, such as ~/Development") });
+var LoginSetBody = external_exports.strictObject({
+  login: GitHubName.describe("the GitHub login, one gh is signed in as"),
+  ssh_key: SshKey.describe("its private SSH key, ~/.ssh/...; none or null to make a new one").optional(),
+  name: CommitName.describe("the name its commits carry"),
+  email: CommitEmail.describe("the email its commits carry"),
+  orgs: external_exports.array(GitHubName).describe("the orgs whose kept repos commit and push as it; an org on another login moves here").optional()
+});
+var LoginRemoveBody = external_exports.strictObject({ login: GitHubName.describe("the login to stop keeping") });
+var OrgLoginBody = external_exports.strictObject({
+  org: GitHubName.describe("the org"),
+  login: GitHubName.describe("a login the bus keeps, for its repos")
+});
+var GitHubSignInBody = external_exports.strictObject({ action: external_exports.enum(["start", "cancel"]).describe("start gh's web sign-in, or cancel it") });
+var HistoryBody = external_exports.strictObject({
+  with: Recipient.describe("only Messages to or from this slot, or user").optional(),
+  about: issueField("only Messages about this issue, org/repo#slug").optional(),
+  unread: external_exports.boolean().describe("only Messages not yet read").optional(),
+  limit: external_exports.number().int().min(1).max(100).default(20).describe("how many, the latest; default 20")
+});
+var StatusBody = external_exports.strictObject({
+  stage: StageName.describe("a registered stage, from the catalog or stages; never a gated one"),
+  text: oneLine("A status", 160).describe("what you are doing now, in a few words (one line, at most 160 characters): the stage's description on the user's page").optional()
+});
+var StagesBody = external_exports.strictObject({});
+var ServerBody = external_exports.strictObject({});
+var StageAddBody = external_exports.strictObject({
+  name: StageName.describe("the new stage: lowercase snake_case, one to three words, at most 24 characters, not a Herdr state"),
+  usage: text$1("when to use it, in a sentence, so other agents choose it rightly")
+});
+var ThrottleBody = external_exports.strictObject({});
+var StartNowBody = external_exports.strictObject({ held: external_exports.number().int().min(1).describe("the held work's id, as throttle lists it") });
+var PausedBody = external_exports.strictObject({ note: text$1("where you stopped, if it helps you pick up again").optional() });
+var ReadBody = external_exports.strictObject({});
+var WaitingBody = external_exports.strictObject({});
+var t = (name, description, body) => ({
+  name,
+  description,
+  body
+});
+var TYPES = Object.fromEntries([
+  t("message", "Send a message to a slot, org/repo@track, or to user. Use it to ask, answer, report, or hand off work; name the issue it concerns in about. A message to a slot with no agent running is held, and the bus brings the slot back up; while resources are short, the throttle brings it up once they recover.", SendBody),
+  t("start", "Start an agent of one of the Agent Types in the catalog with a task, on a track, in its own slot in the repo. The reply gives its id; it reports back to you by message. Agents in several repos go down one track together by naming the same track, but a repo has one slot on a track. While resources are short, the throttle holds it: the reply says held, and you are told by message once it starts.", StartBody),
+  t("stop", "End an agent's Session when its work is done or it is no longer needed.", StopBody),
+  t("resume", "Bring a slot whose agent ended back up, in its own worktree, resuming its conversation where it can.", ResumeBody),
+  t("adopt", "Make a worktree that already exists at its slot's place a slot the bus knows, with no agent running; a message to it later brings it up with a fresh agent there.", AdoptBody),
+  t("throttle", "See what the throttle sees and is doing: its level, what it says, the agent it asked to pause, and the work it holds until resources recover, oldest first.", ThrottleBody),
+  t("start_now", "The user's alone, as their page's Start now: run one piece of work the throttle holds at once, whatever resources say.", StartNowBody),
+  t("paused", "Tell the bus you stopped at a safe point after the throttle asked you to pause, because resources ran out; the bus closes you, and brings you back in this conversation once memory recovers.", PausedBody),
+  t("ask", "Tell the bus you are about to ask the user, then ask them with your AskUserQuestion tool in your own session: your plan before building, your finished work before landing, a pr before you send it, or a decision. The user is told you wait; your next send shows you carried on.", AskBody),
+  t("land", "Land your slot's branch, the only way your work reaches the default branch: the bus checks it is committed and on the latest origin default branch, then lands the commit it checked as the repo's Landing Method says (pushed to the default branch, or pushed as your branch with a PR opened or updated). It closes the issue in about once the work is on the default branch, and ends you once you rest, when end is set; without it you keep working; a refusal says why, and nothing is pushed. With no_code, work with nothing to push finishes the same way. A lead whose followers have not all landed stays up, its issue held, until they have.", LandBody),
+  t("push", "Push your slot's own branch to origin under its own name, to back up work, run CI, or share it; it lands nothing.", PushBody),
+  t("pr", "Open a PR that is itself part of your work, such as a preview environment for your branch, or one that bootstraps a system you are deploying: the bus pushes head and opens the PR as the org's account, and records it as your Work PR. It is never a landing: it never changes your stage, closes an issue, or ends you, and the bus does not watch it; follow it yourself with gh pr view and gh pr checks. Never use it to land your work: that is land, which is refused while a Work PR from your branch into the default branch is open, so close it first. Sending it again for the same head and base pushes and keeps that PR.", PrBody),
+  t("pr_close", "Close a Work PR you opened with pr, when it has done its job or before you land the work it was opened from; any other PR is refused.", PrCloseBody),
+  t("github", "Read what the bus allows from GitHub for your repo, with the right account: pr, your PR's state, checks, mergeability, reviews, and comments. Anything else is refused.", GitHubBody),
+  t("landed", "Report work that needs no land: done with nothing to push (an answer, a review), with a note, or already on the repo's default branch, with the commit it landed as, which the bus links. It closes the issue in about. Work with commits to land lands with land, which reports landed itself; landed is refused while your branch has commits to land.", LandedBody),
+  t("leash", "The user's alone: set a slot's leash, gated or free, and whether its agent stays open after landing; the slot is told.", LeashBody),
+  t("lead", "The user's alone: give a slot a lead, another slot whose bus messages and approvals it then takes as the user's, or clear its lead by leaving lead out; the bus tells both in their own sessions, as the user.", LeadBody),
+  t("follower", "Bring a repo's slot on a lead's track up as the lead's follower: a new agent there with the lead set, told to introduce itself to the lead, or with existing, the slot or worktree already there, led. Every rule is checked first, so a refusal changes nothing. From user it runs at once; from a slot, only for its own slot as lead, held as a follower request until the user approves it.", FollowerBody),
+  t("follower_answer", "The user's alone: approve or decline a lead's follower request; approving runs it, checked again.", FollowerAnswerBody),
+  t("status", "Name the stage your work is in, from the stages below, and say in a few words what you are doing; both show on the user's Web Page beside Herdr's state. Send it at each change of work. The bus alone sets the gated stages, as you pass their gates, and refuses status once your work has landed.", StatusBody),
+  t("server", "What this coordinator is: its version, its folder ($COORDINATOR_ROOT), its development folder, and the user's name and their address on the bus. Ask whenever you need one of them; a path under the folder is $COORDINATOR_ROOT/...", ServerBody),
+  t("stages", "List every stage with its usage: the fixed ones, and those agents registered. Check it before adding one.", StagesBody),
+  t("stage_add", "Register a stage, with when to use it, only when none in stages fits your work; every agent can name it after.", StageAddBody),
+  t("issue_open", "Open an issue in any repo (your own by default); its slug must be new in that repo. Set holder to give it to a slot of that repo at once: your own, as a note of work to come back to, or one you work with. Set blocked_by to the issues it waits on.", IssueOpenBody),
+  t("issue_assign", "Give an issue to a slot of its repo, while no slot holds it or its holder has no agent running; refused while it is blocked.", IssueAssignBody),
+  t("issue_take", "Hold an issue of your own repo, while no slot holds it or its holder has no agent running; name none to take the first free one in your repo's order. Blocked issues are skipped, and refused when named.", IssueTakeBody),
+  t("issue_block", "Make an issue wait on another, in any repo: it is blocked, never handed out, until that one lands. Refused for itself, an unknown issue, one closed without landing, or one that already waits on it.", IssueBlockBody),
+  t("issue_unblock", "Stop an issue waiting on another; once it waits on nothing unlanded, its holder and user are told it is ready.", IssueUnblockBody),
+  t("issue_move", "Move an open issue, one no slot holds, to the top of its repo's order, or one place up or down; the first is the next taken. Held and closed issues are not ordered.", IssueMoveBody),
+  t("issue_ask", "Ask the slot holding an issue of your own repo, whose agent is running, to hand it to you.", IssueAskBody),
+  t("issue_hand_over", "Hand an issue you hold to the slot that asked for it.", IssueHandOverBody),
+  t("issue_keep", "Keep an issue you hold that a slot asked for, saying why.", IssueKeepBody),
+  t("issue_release", "Stop holding an issue, leaving it open, last in its repo's order, for any slot of its repo to take.", IssueReleaseBody),
+  t("issue_comment", "Add a comment to an issue.", IssueCommentBody),
+  t("issue_link", "Add a link to an issue's work outside the bus, such as its ticket or a page, shown on its page; once per url. With remove, take the link with that url away.", IssueLinkBody),
+  t("issue_plan", "Record one of an issue's plans on it as soon as it is published: its page's link, a name for its part of the work, and approved once the user approves it; by the issue's holder or user. A new link adds a plan, so an issue keeps as many as the work needs, a known link with a name renames that plan, and replaces moves a plan to a new link in place; the bus is the record of approval, and a cleared or new session finds the plans here.", IssuePlanBody),
+  t("issue_plan_delete", "Delete one of an issue's plans, by anyone at any time, closed issues included: it only removes the link from the issue's plans, and a document it links to stays.", IssuePlanDeleteBody),
+  t("doc_publish", "Publish an HTML page as one of an issue's documents, kept for good and served by the coordinator, the better home for a plan or any page you show the user than a Claude artifact: the bus copies the file or folder at path in place of the document's newest version, or as its next once the issue's work has landed since, and answers with its link, the same view on the Web Page and in a tab of its own, under a live header of its issue and slot. Give a plan's link to issue_plan. Pages may load /docs/doc.js for that context and to ask to act as the user.", DocPublishBody),
+  t("issue_followers", "The user's alone: set an issue's follower repos, kept repos other than its own; when it is started or passed to a slot, each one's slot on that track comes up as the holder's follower.", IssueFollowersBody),
+  t("issue_close", "Close an issue, saying what was done; only an explicit close ends an issue.", IssueCloseBody),
+  t("issues", "List issues, by repo, state (open, held, or closed), or holding slot: open ones in each repo's order, then held and closed ones, newest first.", IssuesBody),
+  t("slot", "One slot's whole picture: its agent and stage, its Landing (state, method, commit, PR number and link), the issues it holds, and its properties and badges.", SlotBody),
+  t("slot_property", "Set one of a slot's properties, a name and value shown on its page, with an optional link its value opens; the same name again replaces it, and no value clears it. Kept for the next agent on the slot.", SlotPropertyBody),
+  t("slot_badge", "Set one of a slot's badges, a short label in a tone shown beside its stage, by a name that keys it, so changing state keeps one badge; no label clears it. Kept for the next agent on the slot.", SlotBadgeBody),
+  t("slots", "List the slots the bus knows, each with its agent's Agent Type, state, task, and latest status; by track, repo, or only those with an agent running.", SlotsBody),
+  t("repos", "List the repos the bus keeps, each with its checkout, default branch, agents running, slots, and open or held issues; name one for its local branches and worktrees from git, each branch with the slot on it, its agent's state and stage, and the issues it holds, then worktrees outside the layout, which the bus never adopts.", ReposBody),
+  t("changes", "Read a repo's Change Summaries, its history of landings: 20 at a time, newest first, each with its title, one-line summary, what was built, the challenges, and its PR or commit link; more says older ones remain, read with before.", ChangesBody),
+  t("repo_add", "Keep a repo, named by org/repo or a GitHub URL: the clone already at its place under repos, or cloned there from GitHub first; its default branch is read from git. Agents start only in repos the bus keeps.", RepoAddBody),
+  t("secret_key", "When your work needs a new secret, add its empty name with this: the bus appends NAME= to the repo's .env.secrets only when no line names it, and tells the user, who fills in the value from the repo's Settings. Your slot's worktree starts with a copy of the repo's file, made when your agent starts; with slot, the name goes in your slot's own file instead, for a secret only this track needs, gone when the track is cleaned up. The reply says added or already there, never anything about a value; you never read, set, or overwrite one.", SecretKeyBody),
+  t("repo_settings", "The user's alone: change some of a repo's settings, such as landing (how its agents' work lands: push or pr), pre_land, during_land, and post_land (its Landing Scripts, .mjs files in the repo the server runs before each landing, while its PR is open, and after), during_every (how often During landing runs), order (the order its agents get the Profiles on for it, after base), and defaults (on or off: whether its agents get the built-in defaults Profile).", RepoSettingsBody),
+  t("repo_forget", "The user's alone: stop keeping a repo, leaving its files; refused while it has agents running or open or held issues.", RepoForgetBody),
+  t("login_set", "The user's alone: add or change a GitHub login the bus keeps: its SSH key (made and uploaded when none is named), the name and email its commits carry, and its orgs; the bus writes it into every kept repo of those orgs.", LoginSetBody),
+  t("login_remove", "The user's alone: stop keeping a GitHub login; its key, gh's sign-in, and repos' config stay.", LoginRemoveBody),
+  t("org_login", "The user's alone: point an org's kept repos at a GitHub login the bus keeps.", OrgLoginBody),
+  t("github_sign_in", "The user's alone: start gh's web sign-in, which shows a one-time code on the page, or cancel it.", GitHubSignInBody),
+  t("profiles", "List the Profiles (base first, which every agent gets, then defaults, the Default Skills, on unless a repo turns it off), each with the repo it is kept in, the repos it is on for, and its own event handlers and actions; and the skills by source (shipped base and extra, each attached folder, each npx skills source, and each marketplace plugin). A profile chooses from each source all of it or some skills.", ProfilesBody),
+  t("profile_save", "The user's alone: create or change a Profile, saved in the repo it is kept in (at once where that repo's git ignores .coord_repo/, else landed there the repo's way), or an attached folder (a folder of skills under ~, used In Place, its path in change); base and defaults are never changed.", ProfileSaveBody),
+  t("profile_delete", "The user's alone: delete a Profile from its repo, or detach a folder no profile takes from.", ProfileDeleteBody),
+  t("profiles_move", "The user's alone: move the Profiles from before they were kept in repos into the kept repo named, as one change landed there.", ProfilesMoveBody),
+  t("folders", "The user's alone: the folders inside a folder under ~, for choosing one to attach.", FoldersBody),
+  t("history", "Look over recent Messages, oldest first: to or from a slot (or user), about an issue, or not yet read. It marks nothing read.", HistoryBody),
+  t("read", "Read your unread Messages, and the catalog if it changed. Use it whenever the bus tells you Messages are waiting.", ReadBody),
+  t("waiting", "Whether Messages wait for you: the newest unread one's id, or null. The agents' plugin asks it after each step to tell you; you need not send it yourself.", WaitingBody)
+].map((kind) => [kind.name, kind]));
+external_exports.strictObject({
+  name: external_exports.string(),
+  description: external_exports.string().min(1),
+  prompt: external_exports.string().default(""),
+  model: external_exports.string().nullable().default(null),
+  permission_mode: external_exports.enum([
+    "default",
+    "acceptEdits",
+    "plan",
+    "auto",
+    "dontAsk",
+    "bypassPermissions"
+  ]).nullable().default(null),
+  effort: external_exports.enum([
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ]).nullable().default(null),
+  settings: external_exports.record(external_exports.string(), external_exports.any()).default({}),
+  mcp: external_exports.record(external_exports.string(), external_exports.record(external_exports.string(), external_exports.any())).default({}),
+  files: external_exports.array(external_exports.string()).default([]),
+  /** The built-in tools it has, as claude's --tools names them; all of them when unset, none when empty. */
+  tools: external_exports.array(external_exports.string()).nullable().default(null),
+  /** Plugin folders it loads from the coordinator's own package; the Agent plugins setting adds the user's to a slot's agent. */
+  plugins: external_exports.array(external_exports.string()).default([]),
+  /** The Message Types its Port may send; all of them when unset. */
+  messages: external_exports.array(external_exports.string().refine((m) => m in TYPES, { error: (i) => `no Message Type ${String(i.input)}` })).nullable().default(null),
+  sandbox: external_exports.boolean().default(false)
+});
+function startable(t2) {
+  return t2.name !== CONSOLE;
+}
+get("waker");
+var AT_REST = /* @__PURE__ */ new Set(["idle", "done"]);
+function restMinutes(s, messages, at = Date.now()) {
+  const slot = slotOf(s);
+  if (!(isLive(s) && slot && AT_REST.has(s.state) && s.idle_since) || s.keep_open || s.landed_at || s.stage === "pr_open" || s.lead || s.finishing) return null;
+  if (openAsk(messages, slot) || messages.some((m) => m.to === slot && !m.delivered)) return null;
+  return (at - Date.parse(s.idle_since)) / 6e4;
+}
+function quiet(s, messages, settings, at = Date.now()) {
+  const rest = restMinutes(s, messages, at);
+  return rest !== null && rest >= settings.idle_warning_minutes;
+}
+function trackTree(sessions) {
+  const root = {
+    name: "",
+    path: "",
+    sessions: [],
+    children: /* @__PURE__ */ new Map()
+  };
+  const sorted = [...sessions].sort((a, b) => cmp(a.track.toLowerCase(), b.track.toLowerCase()) || cmp(a.repo ?? "", b.repo ?? "") || cmp(a.started, b.started));
+  for (const s of sorted) {
+    let node = root;
+    const parts = s.track.split("/");
+    parts.forEach((part, depth) => {
+      if (!node.children.has(part)) node.children.set(part, {
+        name: part,
+        path: parts.slice(0, depth + 1).join("/"),
+        sessions: [],
+        children: /* @__PURE__ */ new Map()
+      });
+      node = node.children.get(part);
+    });
+    node.sessions.push(s.id);
+  }
+  const byId = new Map(sessions.map((s) => [s.id, s]));
+  const leadFirst = (ids) => {
+    const leads = new Set(ids.map((id) => byId.get(id).lead));
+    const rank = (id) => Number(!leads.has(slotOf(byId.get(id))));
+    return [...ids].sort((a, b) => rank(a) - rank(b));
+  };
+  const view = (n) => ({
+    name: n.name,
+    path: n.path,
+    sessions: leadFirst(n.sessions),
+    children: [...n.children.values()].sort((a, b) => cmp(a.name.toLowerCase(), b.name.toLowerCase())).map(view)
+  });
+  return view(root).children;
+}
+function textOf(m) {
+  const body = m.body;
+  if (m.type === "message" || m.type === "status") return body.text ?? "";
+  if (m.type === "start") return `start ${body.type} at ${m.started ?? "?"}: ${body.task ?? ""}`;
+  if (m.type === "stop" || m.type === "resume") return `${m.type} ${body.to ?? ""}`;
+  if (m.type === "issue") return `${body.issue} ${body.event}` + (body.text ? `: ${body.text}` : "");
+  if (m.type === "event") {
+    const n = (body.handlers ?? []).length;
+    return `${body.name} fired` + (n ? `: ${n} handler${n === 1 ? "" : "s"} from its profile given` : "");
+  }
+  if (m.type === "catalog") return "the catalog of Agent Types and Message Types changed";
+  if (m.type === "ask") return `asks you (${body.kind}): ${body.text}`;
+  if (m.type === "landed") return `landed: ${body.link ?? "nothing to push"}` + (body.note ? `. ${body.note}` : "") + (body.waiting ? `; waits on ${body.waiting.join(", ")} before closing` : "");
+  return pythonish(body);
+}
+function pythonish(value) {
+  if (value === null || value === void 0) return "None";
+  if (typeof value === "string") return `'${value}'`;
+  if (typeof value === "boolean") return value ? "True" : "False";
+  if (Array.isArray(value)) return `[${value.map(pythonish).join(", ")}]`;
+  if (typeof value === "object") return `{${Object.entries(value).map(([k, v]) => `'${k}': ${pythonish(v)}`).join(", ")}}`;
+  return String(value);
+}
+function sessionView(s, sessions, messages, settings, landings = {}, workPrs = [], requests = []) {
+  const slot = slotOf(s);
+  const started = sessions.filter((o) => slot && o.parent === slot && isLive(o)).sort((a, b) => cmp(a.started, b.started));
+  const { token: _, ...shown2 } = s;
+  const asked = slot && isLive(s) ? openAsk(messages, slot) : null;
+  const ask = asked ? {
+    id: asked.id,
+    at: asked.at,
+    kind: asked.body.kind,
+    text: asked.body.text,
+    about: asked.body.about ?? null
+  } : null;
+  const followers = slot ? followersOf(sessions, slot) : [];
+  const l = slot ? landings[slot] : void 0;
+  const landing = l ? {
+    state: l.state,
+    method: l.method,
+    title: l.title,
+    reason: l.reason,
+    link: l.link,
+    pr: l.pr,
+    commits: l.commits,
+    summary: l.summary,
+    revised: l.revised,
+    change: l.change,
+    repo: l.repo,
+    during: l.during,
+    updated_at: l.updated_at
+  } : null;
+  const work_prs = workPrs.filter((w) => w.slot === slot).reverse().map((w) => ({
+    repo: w.repo,
+    head: w.head,
+    base: w.base,
+    title: w.title,
+    about: w.about,
+    number: w.number,
+    link: w.link,
+    state: w.state,
+    reason: w.reason,
+    at: w.at
+  }));
+  const follower_requests = requests.filter((r) => r.lead === slot && r.state === "pending").map((r) => ({
+    id: r.id,
+    repo: r.repo,
+    type: r.type,
+    task: r.task,
+    existing: r.existing,
+    at: r.at
+  }));
+  const waits_on = slot && s.finishing ? unfinishedFollowers(sessions, slot) : [];
+  return {
+    ...shown2,
+    slot,
+    started_ids: started.map((o) => o.id),
+    followers,
+    ask,
+    quiet: quiet(s, messages, settings),
+    landing,
+    work_prs,
+    follower_requests,
+    waits_on
+  };
+}
+function issueView(i, all, docs) {
+  const address = addressOfIssue(i);
+  return {
+    ...i,
+    address,
+    blocked: waitingOn(i, (a) => all[a]).length > 0,
+    docs: docs.of(address).map((d) => docView(d, docs))
+  };
+}
+function docView(d, docs) {
+  return {
+    address: docAddress(d),
+    name: d.name,
+    title: d.title,
+    by: d.by,
+    version: latest(d),
+    versions: d.versions.map((v) => v.n),
+    created_at: d.created_at,
+    updated_at: updatedAt(d),
+    path: docPath(d),
+    link: docs.link(d),
+    frame: docs.frame(d)
+  };
+}
+function shown(sessions) {
+  return latestPerSlot(Object.values(sessions));
+}
+function consoleView(system, all) {
+  const latest2 = system.console.latest();
+  return latest2 && system.config.current().console ? sessionView(latest2, all, system.bus.messages(), system.config.current()) : null;
+}
+async function model(system) {
+  const state = system.bus.snapshot();
+  const all = Object.values(state.sessions);
+  const live = shown(state.sessions).filter((s) => !system.cleanup.cleaning(s.id));
+  const msgs = state.messages.slice(-300).map((m) => ({
+    id: m.id,
+    at: m.at,
+    from: m.from,
+    to: m.to,
+    type: m.type,
+    text: textOf(m),
+    about: m.body.about || m.body.issue || null,
+    delivered: m.delivered
+  }));
+  return {
+    tree: trackTree(live),
+    sessions: Object.fromEntries(live.map((s) => [s.id, sessionView(s, all, state.messages, system.config.current(), state.landings, state.work_prs, state.follower_requests)])),
+    slots: Object.fromEntries(live.map((s) => [slotOf(s), s.id])),
+    messages: msgs,
+    inbox: msgs.filter((m) => m.to === USER),
+    bus: "bus",
+    issues: Object.values(state.issues).sort(issueOrder).map((i) => issueView(i, state.issues, system.docs)),
+    groupings: Object.fromEntries(Object.entries(state.groupings).map(([repo, g]) => {
+      const address = (slug) => `${repo}#${slug}`;
+      return [repo, {
+        at: g.at,
+        weighed: g.weighed.map(address),
+        groups: g.groups.map((x) => ({
+          issues: x.issues.map(address),
+          why: x.why
+        }))
+      }];
+    })),
+    types: Object.values(system.types).filter(startable).map((t2) => ({
+      name: t2.name,
+      description: t2.description
+    })),
+    repos: await system.repos.summaries(),
+    ...system.logins.view(),
+    profiles: system.skills.view(),
+    settings: describe(system.config.current()),
+    console: consoleView(system, all)
+  };
+}
+var GET = async ({ locals }) => json({
+  ...await model(locals.served.system),
+  resources: locals.served.resources.latest,
+  throttle: locals.served.system.throttle.view()
+});
+export {
+  GET
+};