@lovek4d/kickflip 0.1.0 → 0.4.0

package/board/bin/board.mjs

@@ -1,24 +1,25 @@
 #!/usr/bin/env node
-var _=Object.defineProperty;var l=(e,s)=>_(e,"name",{value:s,configurable:!0});import{routeRecord as S}from"../../hub/routes.mjs";import g from"node:fs";import f from"node:path";import{spawnSync as O}from"node:child_process";import{fileURLToPath as C,pathToFileURL as E}from"node:url";import*as n from"../store.mjs";import{makeWorktree as q,land as T,skillRepo as L,worktreesDir as N}from"../worktree.mjs";import{ITEM_STATUSES as F}from"../domain.mjs";import{boardAt as K,readManifest as M}from"../../hub/boards.mjs";import{boardRepo as D}from"../../hub/board-repo.mjs";import{pushKindError as B}from"../../hub/push.mjs";import{migrateOnStart as H}from"../../bin/install.mjs";const U=`usage: node board.mjs <command> [--site <route>] ...
+var E=Object.defineProperty;var i=(e,s)=>E(e,"name",{value:s,configurable:!0});import{readiness as B,reportSlack as H}from"../../hub/readiness.mjs";import{readSlack as L,setSlack as D}from"../../hub/slack.mjs";import{routeRecord as y}from"../../hub/routes.mjs";import w from"node:fs";import m from"node:path";import{pathToFileURL as W}from"node:url";import*as n from"../store.mjs";import{boardWorktree as z,builderRepo as G,holdingLandLock as M,land as J,worktreesDir as F}from"../worktree.mjs";import{fileFindings as U}from"../arch-review.mjs";import{finishCard as x}from"../finish.mjs";import{ITEM_STATUSES as K}from"../domain.mjs";import{boardAt as Q,readManifest as V}from"../../hub/boards.mjs";import"../../hub/board-repo.mjs";const X=`usage: node board.mjs <command> [--site <route>] ...
 
 Writes a kickflip board's data files. --site <route> picks ~/.claude/kickflip/sites/<route>, and its
 board.json says where the board's waves live. Without --site, waves come from ~/.claude/waves.
 Paths resolve under $HOME, so HOME=<dir> points every command at a copy.
 A --file argument of - reads stdin.
-item add and followup add create a ticket in the board\u2019s source unless --ticket <id> links one.
+item add creates a ticket in the board\u2019s source unless --ticket <id> links one.
 Internal defaults to INT; GitHub and Linear create an issue from the title and notes, Linear in the board's team and
 project through Hub's Linear key. A linked ticket must exist in the source; an Internal one no other card holds.
 Asks have no ticket; item set --from-ask creates one when the card has none.
 A card moves its ticket one way: --status building or fixing \u2192 In Progress, --pr \u2192 In Review, --status done or
 merged \u2192 Done (a GitHub issue closes), only for a ticket assigned to the owner or created by kickflip. A ticket that
 can't move prints one "ticket <id>: \u2026" line; the card's change still stands.
-A Linear board without Hub's key hands Linear to the session: a linked id is checked on its pattern alone, and a card
-needing an issue, or a ticket to move, prints a "ticket" line saying what to do through your Linear MCP, such as
-creating the issue and running item set <wave>/<id> --ticket <id> (followup set for a follow-up).
+Linear needs Hub's Linear key: settings set tickets refuses it without one, and once the key is removed the hub
+moves every Linear board to internal tickets. A card is never left without a ticket: if Linear can't make one, the
+command fails and changes nothing.
 
-  reply <eventId> (--html <text> | --file <path>)        data/replies/<eventId>.html
-  working <eventId>                                      marks an ask or thread message started; the page
-                                                         shows "Working on it" until a reply or later thread line
+  reply <eventId> (--html <text> | --file <path>)        data/replies/<eventId>.html. A reply to an ask resolves its
+                                                         answered questions (topic item:ask:<eventId>), and one to
+                                                         wave-triage its wave's, noting "Acted on: replied". A
+                                                         reply to overnight-triage ends that triage
   thread <wave>/<id> --text <t> [--link <url>]           one line in the item's thread; ask:<eventId> in place
          [--who claude|love|<name>] [--via github|slack] of <wave>/<id> writes in that ask's thread
          A Claude thread line, or a reply to an ask or item-message, rewrites the body of the thread's
@@ -27,8 +28,9 @@ creating the issue and running item set <wave>/<id> --ticket <id> (followup set
   topic add <id> --title <t> [--summary <s>]             a question topic in data/owner.json
   question add --file <json>                             one question or an array of them:
          {id, topic, question, options: [{id, label, recommended?, detail?, diagram?, practice?}],
-          source?, context?, url?, urgent?}; topic is declared, item:<wave>/<id>, or item:ask:<eventId>
-          for a New card not sorted yet.
+          source?, context?, url?, urgent?, round_of?, ask?}; topic is declared, item:<wave>/<id>, item:ask:<eventId>
+          for a New card not sorted yet, lineup:<slug> for a wave's triage, or wave:<slug> for a wave file's triage on
+          a board over ~/.claude/waves. A question on a done or merged card reopens it.
          url is http(s), or a site page such as prototype-<topic>.html?q=<id>, stored as given.
          Prototype options keep take order, ids matching take keys; recommended: true tags the recommendation.
          Waiting on you shows fitting takes in a grid, or a chooser above one full-width take for a single take or if any
@@ -37,12 +39,20 @@ creating the issue and running item set <wave>/<id> --ticket <id> (followup set
          danger|success, to the next row's box indexes (default all); practice: ["<line>", \u2026]
          A prototype url's topic must be recorded (prototype add), its option ids a non-empty subset of the
          take keys in take order, without repeats, and every take file written; a hand-written prototype-*.html
-         is refused. On an item: topic, each question answered and still waiting on Claude is resolved,
-         noting "Followed by <new id>", and printed as "resolved: <old id>". Any other unresolved question
-         on the same topic that links the same prototype is resolved, noting "Replaced by <new id>", and
-         printed as "replaced: <old id>". Answering or resolving a question drops its queued push tagged
-         q-<id> on this site.
-  question resolve <id> --note <text>                    sets resolved and resolved_at
+         is refused. On an item: topic, each other question answered and still waiting on Claude is
+         resolved, noting "Followed by <new id>", and printed as "resolved: <old id>". Any other unresolved
+         question on the same topic that links the same prototype is resolved, noting "Replaced by <new id>",
+         and printed as "replaced: <old id>". round_of names the question on the same topic whose
+         prototype-request this answers; the question needs a prototype url, takes the next round
+         number, and resolves that one, noting "Followed by prototype round N".
+         ask names a builder ask the session deferred on the item (builder defer): the question puts it to the
+         owner, and while a card's only open questions are such, it waits on them with no Action needed.
+         The board server pushes the new open questions itself, under the card's tag (item-<wave>/<id>, or
+         ask-<eventId>) or topic-<topic> off the cards
+  question resolve <id> --note <text>                   sets resolved and resolved_at; refuses a question on a
+         prototype page until an answer settles its round: a pick, with a note or none, or an answer to
+         an "Is this it?" confirm already on the board. A question already resolved, such as one an
+         answer with a note and no option resolved, is left as it is
   prototype add <topic> --title <t> --take <K>:<label>   records a prototype in data/prototypes.json: the board
          [--take <K>:<label> \u2026] [--card <wave>/<id>]     serves prototype-<topic>.html from its one template, with
                                                          the title, a back arrow to --card (else the board), the
@@ -51,21 +61,58 @@ creating the issue and running item set <wave>/<id> --ticket <id> (followup set
                                                          "A. ", since the pill shows it alone. Prints each take
                                                          file to write,
                                                          public/prototypes/<topic>/<K>.js, which exports
-                                                         render(stage, kit) (board/public/prototype-kit.js lists kit)
+                                                         render(stage, kit) (board/public/prototype-kit.js lists kit).
+                                                         --card starts that card: it leaves Todo
   prototype list                                         one line per recorded prototype
   prototype rm <topic>                                   drops the record, keeping its take files; refuses while an
                                                          open question links it
+  pr <wave>/<id>                                         one JSON line per PR on the card, in its order: the PR's
+                                                         repo, state, checks and new events, using the board's
+                                                         github-login and the card's gh_since
+  pr comment <pr> --body <text>                          posts Claude's words on PR <pr> through gh, a number in the
+                                                         board's repo or owner/repo#<n> for a card's PR in another,
+  pr reply <pr> <comment id> --body <text>               or replies in that review comment's thread, as the board's
+                                                         github-login (else gh's account), adding "\u{1F916} " before and a
+                                                         blank line and <!-- claude-bridge --> after, the marker pr
+                                                         reads as Claude's own. Refuses words that already carry
+                                                         either. Prints the post's url
   item set <wave>/<id> [--status <s> | --clear-status]   edits the item in its wave file
-         [--next <t> | --clear-next] [--pr <n>]          status: ${F.join(", ")}
+         [--next <t> | --clear-next]                     status: ${K.join(", ")}
                                                          an empty --next "" clears it, as --clear-next does
                                                          naming another unfinished card requires it in --deps
-         [--from-ask <eventId>]                          the ask it came from: its New card gives way to this item,
-                                                         whose thread opens with the ask and its thread; it leaves
-                                                         a card it was folded into
-         [--held | --unheld]                             --held sets held: true, for the owner's card-hold;
-                                                         --unheld clears it and a held status
+         [--pr <n> | --pr <owner/repo#n>]...             adds a PR to the card, a bare number in the board's repo;
+                                                         repeatable, and never replaces one. Each PR gets its own
+                                                         badge and polling; the least-ready decides the card's lane
+         [--pushed <branch>]                             on a board whose repo is a plain git remote (no GitHub):
+                                                         the card's branch is pushed there, so it waits In Review
+                                                         on the owner's merge. Push it first (git push origin
+                                                         <branch>). The hub's repo fetch moves it to Done once the
+                                                         branch is merged into the board's branch or gone from the
+                                                         remote. Clears building/fixing as --pr does
+         [--gh-since <ISO time>]                         records the last handled GitHub event, an ISO-8601 UTC
+                                                         time such as 2026-10-23T11:00:00Z, stored as given
+         [--from-ask <eventId> --text <t>]               the ask it came from: its New card gives way to this item,
+                                                         whose thread opens with the ask and its thread, then --text
+                                                         as the item's first line; it leaves a card it was folded into; refuses a card
+                                                         from another ask (use item relate-ask), and one with no
+                                                         state when --state is missing
+         [--state ready|grilling|prototyping]            what a card from an ask does next; it reads New until set.
+                                                         ready refuses while the card has an open question
+         [--held | --unheld | --pick-up-at <time>]       holds or resumes the card on the owner's words; the board
+                                                         server records the owner's own Hold and Resume taps. A later
+                                                         --held/--unheld overrides a tap; --unheld also clears a held status.
+                                                         --pick-up-at holds it until an ISO time such as
+                                                         2026-11-04T09:00 (the Mac's local time without an
+                                                         offset; a past time is refused), stored as UTC
+                                                         pick_up_at. Within a minute of it the board server
+                                                         resumes the card, adds a thread line, and appends
+                                                         card-unblocked {key, until} unless a dep is unfinished.
+                                                         --held holds it with no time; --pick-up-at "" resumes it
          [--ticket <id>]                                links a ticket in the board\u2019s source
          [--title <t>]                                   renames the card
+         [--size small|large] [--model opus|sonnet]      what builder pick reads while the hub's Claude model is
+                                                         Auto: a small card gets Claude Sonnet, any other Opus, and
+                                                         --model wins over --size; "" clears either
          [--notes-file <file>]                           the item's notes: a .md file inside its wave's folder,
                                                          named relative to it, holding the session's understanding
                                                          of the task so far. The open card's Notes link opens it,
@@ -74,31 +121,49 @@ creating the issue and running item set <wave>/<id> --ticket <id> (followup set
                                                          Claude, noting "Recorded in the card's notes", and
                                                          prints "resolved: <id>" for each
          [--deps <id>,<wave>/<id>]                       replaces its blocked-by list; --deps "" clears it
+         [--parent <wave>/<id>]                          sets its Parent, refusing itself or a card below it;
+                                                         --parent "" clears it
+         [--related <id>,<wave>/<id>]                    replaces the cards it is Related to, which both cards
+                                                         show; --related "" clears it, on both
          [--install <url> [--install-sha <sha>]          a device build the owner installs from the card's Install
           [--install-label <text>] | --clear-install]    button, stamped built_at now: itms-services://?action=
                                                          download-manifest&url=https://\u2026/manifest.plist for iOS,
                                                          an https:// .apk URL for Android. --install-sha is the
                                                          head it was built from: the badge reads "Install (stale)"
                                                          once the branch moves past it. Hidden once the card is Done
+         [--text <t>]                                    with --status done or dropped, required on a site: the
+                                                         card's closing line, written last in its thread. merged
+                                                         writes "Merged PR #n." unless --text says otherwise
+         builder start for a build sets building itself. --status building resolves the card's answered
+         questions, noting "Acted on: build started".
          --status building refuses while the item is held or a dep isn't done, merged or dropped,
-         and while the newest owner answer to its questions that link a prototype-*.html page has a
-         note: post the final version with prototype add and question add first.
-         [--confirmed "<owner's words>"] passes when that note itself says go: the words must quote
-         it, and they go in a thread line on the card;
+         and while the newest owner answer to its questions that link a prototype-*.html page picks
+         no take, which leaves the card prototyping with Next "Prototype again" until the next
+         round's pick; a pick's note is the build's guidance;
          done, merged and dropped print "unblocked: <wave>/<id>" and append card-unblocked {key}
          once per unblocking, including held cards: start each unheld card next.
          building and fixing count as working only while a builder record on the card is open.
          --pr clears building/fixing and closes ordinary builders; install builders keep running.
-         checking is a builder's hand-back: In Progress, reading "Orchestrator review",
-         until the owning session verifies it and sets done; it unblocks nothing.
-         Every --status or --clear-status records status_at, which ends the Done button's "Closing\u2026"
-         for the owner's card-done; apply a card-done with --status done.
+         checking is a builder's hand-back of work it couldn't land: In Progress, reading "Orchestrator
+         review", until the owning session takes it on; it unblocks nothing.
+         The board server records the owner's card-done in the wave file itself.
+         Every --status or --clear-status records status_at; a later status change overrides the tap.
          --status done, merged or dropped closes the card: it resolves each of its questions (topic
          item:<wave>/<id>) that has an answer, noting "Closed with the card", and prints "resolved: <id>"
-         for each. It refuses while one has no answer yet; [--force] closes it and resolves that one too
-  item add <wave>/<id> --title <t> [--notes <t>]          a new card, planned (waiting when it has --deps); never
+         for each. It refuses while one has no answer yet; [--force] closes it and resolves that one too.
+         --status done refuses a done card the owner messaged since it closed: it reads reopened, and closes
+         again only on the owner's Done
+  item add <wave>[/<id>] --title <t> [--notes <t>]       a new card, planned (waiting when it has --deps); never
          [--ticket <id>] [--deps <id>,<wave>/<id>]       hand-edit wave.json to add one. Refuses an id the wave has.
          [--notes-file <file>]                           --plan is an alias of --notes-file
+         [--pick-up-at <time>]                           holds it until then, as item set's --pick-up-at
+         [--size small|large] [--model opus|sonnet]      as item set's
+         [--parent <wave>/<id>]                          the card it was spun out of, such as one filed from
+                                                         another card's thread, grill or answer: it reads as a
+                                                         follow-up, and its Parent lists it in Children. A card
+                                                         from the + or New task has none
+         Without /<id>, the card takes its ticket's id (GH-<n> for issue #n); pass an id only to import a
+         card. Prints "<label> added as <key>": use the key in later commands
   item relate-ask <eventId> <wave>/<id> --summary <t>   folds an ask about an existing item into it: the ask's
                                                          card goes, its message and thread show in the item's
                                                          thread marked Moved, then the summary line. Again with
@@ -116,18 +181,40 @@ creating the issue and running item set <wave>/<id> --ticket <id> (followup set
                                                          A card the ask became is dropped, unless it has started.
                                                          Refuses a route that isn't another board, and an ask
                                                          that isn't New
-  hello-ack <eventId>                                    answers the hub's hello: data/handshake.json records that the
-                                                         session hears the board, which clears the setup checklist's
-                                                         Events step. Refuses an older hello than the newest
   checked [--every <minutes> | --idle]                   data/checked.json: GitHub was just checked, next in
-                                                         <minutes> (default 30); run it at the end of each monitor tick.
-                                                         --idle: the board shows no open PR, so never late.
+                                                         <minutes> (default 5, the away cadence); run it at the
+                                                         end of each GitHub tick.
+                                                         --idle: the board shows no open PR, so never late; with
+                                                         neither flag it is idle while no card has an open PR.
                                                          Then sends the queued pushes, each on its own, unless
                                                          pushes are held (overnight, snoozed, the weekend or off)
-  followup add <wave> --id <id> --title <t> [--from <item id>] [--ticket <id>]
-  followup done <wave> <id> [--force]                    closes the follow-up's card as item set --status done does
-  followup set <wave> <id> --ticket <id>                links the follow-up's ticket in the board's source
-  tickets backfill [--dry-run]                           gives every open card and follow-up without a ticket one: the first
+  lineup create <slug> --title <t> --goal <t>            a wave, in the owner's words: a named set of cards in
+         --phase <wave>/<id>,\u2026 [--phase \u2026]               phases, all from one wave file, one --phase per phase
+         (--note <t> | --file <f>)                       in build order. Each card is then blocked by every card
+                                                         of the phase before (its other deps stay), so one
+                                                         phase's cards build side by side, and the note goes to
+                                                         lineup-<slug>.md beside the wave file.
+                                                         Todo shows it as a band of its cards in order, numbered
+                                                         by phase, its goal on its name, and Notes opens the
+                                                         goal, the order and the note. Refuses a card already in
+                                                         another open wave. Prints the order by card label, one
+                                                         phase's cards by commas and the phases by arrows
+  lineup add <slug> <wave>/<id> [--after <wave>/<id>]    puts a card in the wave as a phase of its own, last
+                                                         unless --after's phase, and links the phases again
+  lineup remove <slug> <wave>/<id>                       takes a card out: it loses its links to the wave's cards,
+                                                         its phase goes if it held only that card, and the phases
+                                                         are linked again
+  lineup set <slug> [--title <t>] [--goal <t>]           renames the wave, sets its goal, rewrites its note or
+         [--note <t> | --file <f>]                       puts its cards in new phases (--phase per phase, every
+         [--phase <wave>/<id>,\u2026 \u2026]                       card once) and links them again. A card's \u22EF in its
+                                                         band swaps it with the Todo card before or after it,
+                                                         each taking the other's phase
+  lineup finish <slug>                                   the wave's band leaves Todo; its cards keep their
+                                                         links. A wave whose cards are all Done leaves it too
+         A band's Triage sends wave-triage {lineup}, or {wave} for a wave file's band; it reads
+         Triaging\u2026 until you reply to that event, then "Triage: N open questions" while questions on topic
+         lineup:<slug> or wave:<slug> are open or answered
+  tickets backfill [--dry-run]                           gives every open card without a ticket one: the first
                                                          id in its title (or legacy linear list) from the board's
                                                          source is linked, else a new ticket is made. Done cards are
                                                          left alone. Prints each card's result; --dry-run changes and
@@ -137,6 +224,31 @@ creating the issue and running item set <wave>/<id> --ticket <id> (followup set
                                                          The settings page lists them; new waves copy them
   reviewers add --file <json>                            one reviewer or an array; replaces the same name
   reviewers remove <name>...                             refuses a name the board doesn't have
+  slack                                                 Slack identity as JSON; imports slack-bridge config once
+  slack set [--self-dm D..] [--user U..]                 sets hub Slack identity in ~/.claude/kickflip/slack.json
+            [--domain x] [--timezone Area/City]
+  review sent <wave>/<id> <reviewer> --ts <ts>           records the PR link's message in the item
+              --channel <dm>
+  review react <wave>/<id> <reviewer> <emoji>            records a reaction once on that reviewer's link
+  integrations                                          readiness rows as one JSON line
+  integrations report --slack yes|no                    with --site: reports whether this session has Claude's
+                                                         Slack connector, in ~/.claude/kickflip/integrations.json
+  review due                                            one JSON line of the Slack sends owed, from local state:
+                                                         {dms: [{key, reviewer, channel, text, record}], reactions:
+                                                         [{key, reviewer, channel, ts, emoji, record}], digest:
+                                                         review digest's answer while due (with record), else null}.
+                                                         dms: a PR link to each reviewer of an open, non-draft PR with
+                                                         no link recorded; reactions: git_merged on each recorded link
+                                                         of a merged card. record is the command to run once sent.
+                                                         While Slack isn't ready: {waiting} and nothing owed
+  review record <pr> --state posted|needs               the session's review of an incoming PR, after a pr-review
+         --text <markdown> | --file <path>               event, in data/reviews.json: posted once it is on GitHub
+         [--url <review link>]                           (--url its link), needs while it waits on the owner, which
+                                                         puts it in Needs you and pushes. The PR must be one the hub
+                                                         listed in data/incoming.json or reviewed before
+  review digest                                         pending reviews as JSON; due weekday mornings from 09:00
+  review digest sent <reviewer> --ts <ts>               records a digest in data/review-digests.json;
+              --channel <dm> --items <key,key>           marks today sent in the Slack identity timezone
   rules list                                             the hub rules, then with --site the board's, one
                                                          "<hub|board> <id> <owner|claude> <text>" line each
   rules add --text <t> [--hub] [--by claude]             a rule in board.json, or with --hub in the hub's
@@ -144,64 +256,241 @@ creating the issue and running item set <wave>/<id> --ticket <id> (followup set
                                                          --by claude when you codify one on the owner's word
   rules edit <id> --text <t> [--hub]                     rewords a rule, keeping who added it
   rules remove <id> [--hub]                              refuses an id the list doesn't have
-  settings                                               the board's settings as JSON, each false when board.json
-                                                         leaves it out: {"auto_merge": false, "auto_build": false}
-  settings set auto-merge on|off                         on: monitor merges an approved PR once CI is green and
+  settings                                               the board's settings as JSON; flags default off, optional
+                                                         settings appear when set: {"auto_merge": false,
+                                                         "auto_build": false, "auto_pull": false,
+                                                         "max_implementers": 10,
+                                                         "auto_triage": false, "auto_review": false,
+                                                         "headless_builders": false,
+                                                         "idle_notification": false, "skip_draft": false,
+                                                         "github_login": "owner"}
+  settings set auto-merge on|off                         on: the session merges an approved PR once CI is green and
                                                          the merge state is CLEAN. off (the default): the card
-                                                         shows the owner a Merge button, and monitor merges on its
+                                                         shows the owner a Merge button, and the session merges on its
                                                          card-merge event. Board Settings' toggle writes it too
+  settings set skip-draft on|off                         on: the hub's poll marks a card's draft PR ready for
+                                                         review once its CI passes. off (the default): the draft
+                                                         waits in In Review on the owner's review and Ready
   build <wave>/<id> --site <route>                       asks the hub to run this card's .kickflip/build; prints
-                                                         started and exits. install is an alias. The hub records
-                                                         data/try/<id>.log and writes failures to the thread
+         --asked "<owner's words>"                       started and exits. install is an alias. Only the owner's
+                                                         Serve / Build and Auto-build start a card run, so --asked
+                                                         must quote the owner's ask, card message or answer note on
+                                                         this board that asked for it; the words go in a thread
+                                                         line on the card. The hub records data/try/<id>.log and
+                                                         writes failures to the thread. Web Visit opens
+                                                         https://<host>:<try port>/ at its root
   main set --install <url> [--install-sha <sha>]          publishes main's app install to data/main.json
+  settings set github-login <login>                      the GitHub account Claude posts as on this board. Its
+                                                         comments carrying <!-- claude-bridge --> are Claude\u2019s own
+                                                         and dropped; its other comments are the owner\u2019s. Unset,
+                                                         the hub asks gh api user. Pass "" to clear it
   settings set auto-build on|off                         on: each push builds its card. Off by default.
                                                          Main builds after every merge either way
-  builder start <wave>/<id> [--agent <name>] [--kind <opus|codex|sonnet|install|\u2026>] [--label <who>]
-         [--progress <text>] [--eta <ISO time>]          one record per agent on the item; --agent defaults to main.
+  settings set auto-pull on|off                          Auto implement Todo cards. on: on every board change the
+                                                         board server sends card-pull {key} for the top ready Todo
+                                                         cards nothing blocks, holds or asks about, one per free
+                                                         implementer slot (see max-implementers), each once; with
+                                                         none ready and nothing building, card-plan {key} for the
+                                                         top unready card to grill or prototype. Off by default.
+                                                         Only on the owner's word
+  settings set max-implementers <1..99>                  Maximum parallel implementers, 10 by default: the cards
+                                                         building or waiting in Orchestrator review the pull fills
+                                                         up to. Planners and cards waiting on the owner don't count.
+                                                         Only on the owner's word
+  settings set auto-review on|off                        on: while the board is idle and nothing is pulled, the board
+                                                         server sends pr-review {pr, head, repo, title, author, url,
+                                                         touches, asked} for one incoming PR at a time that touches
+                                                         this board's cards or asks the owner for review. Off by
+                                                         default. Only on the owner's word
+  settings set headless-builders on|off                  on: the board server launches each Claude build itself, as
+                                                         claude -p in the card's worktree with a brief built from the
+                                                         card's notes and rules, for the Implement tap, a queued start
+                                                         and Auto implement's pull, instead of waking you with
+                                                         card-build or card-pull; a codex pick, or a launch that
+                                                         fails, still sends card-build. The builder lands its own
+                                                         work; once you verify a handed-back build's calls and its
+                                                         card has no open question, the server launches a headless
+                                                         lander. item set --state ready then refuses a card without
+                                                         --size, a notes file, or the id of each answered question in
+                                                         that file. Off by default. Only on the owner's word
+  settings set auto-triage on|off                       on: once a night, from the middle of the hub's quiet hours
+                                                         to their end, when two or more cards wait on open
+                                                         questions, nothing builds and something changed since the
+                                                         last triage, the board server declares topic
+                                                         overnight-triage-<date> ("Overnight triage <date>") and
+                                                         sends overnight-triage {date, topic, cards}; the pull
+                                                         waits until you reply to it. Off by default. Only on the
+                                                         owner's word
+  settings set tickets <json>                            the board's ticket source, as Board Settings' Tickets row
+                                                         saves it: {"source":"internal","prefix":"OPS"},
+                                                         {"source":"github","account":"<gh login>"} or
+                                                         {"source":"linear","workspace","team","project"}. A
+                                                         GitHub account runs the board's issue calls as that gh
+                                                         login; without one they run as gh's active account
+  builder start <wave>/<id> [--agent <name>] [--kind <claude|codex|prototype|grill|install|\u2026>] [--label <who>]
+         [--model <opus|sonnet>]                         the Claude model running the builder, recorded and printed as
+                                                         "model: Claude Sonnet" (kind claude takes builder pick's model;
+                                                         codex prints "model: Codex"). The thread's agent line reads it: "Claude
+                                                         Sonnet builder started"; the label carries no model word. A
+                                                         build refuses the model the hub's Claude model rules out.
+                                                         A prototype defaults to sonnet and a grill to opus:
+                                                         "Claude Sonnet prototype started"
+         [--phase <phase> --progress <detail>]           one record per agent on the item; --agent defaults to main.
+         [--eta <ISO time>]                              --phase and --progress take what builder progress takes.
                                                          --kind install: a build of the card's install, whose
-                                                         Install badge reads Building\u2026 meanwhile
+                                                         Install badge reads Building\u2026 meanwhile. --kind claude or
+                                                         codex refuses the one builder pick rules out; --kind build
+                                                         records the pick's kind and prints "kind: <kind>. <reason>";
+                                                         on the open record a Build tap started or --dispatch
+                                                         opened, it keeps that record's kind and worktree.
+         [--dispatch]                                    --dispatch: the session runs this right before it launches
+                                                         an agent of any kind (build, prototype, grill) so the record
+                                                         is open at launch and the card reads preheating; the agent's
+                                                         own builder start takes it up. On a record the Build tap
+                                                         opened it changes nothing and prints "already open". The
+                                                         record keeps dispatched: tap or session, whoever opened it.
+                                                         --agent <other name> refuses while the tap's main record
+                                                         is open and not taken up.
+                                                         A build's start clears the card's Next.
+                                                         A build (--kind build, claude or codex) on an open card sets
+                                                         --status building first, refusing what that refuses;
+                                                         Prints "ref: <ref>", the card's label, which commit subjects start with.
+                                                         Resolves the card's answered questions, noting "Acted on:
+                                                         builder started"
          [--worktree [--repo <dir>]]                     --worktree: a git worktree for the builder at
                                                          ~/.claude/kickflip/worktrees/<id> on a new branch <id> from
                                                          the board's branch of its clone (--repo overrides the clone), kept on
                                                          the record and printed as "worktree: <path>". Refuses when
-                                                         that path or branch exists
-  builder progress <wave>/<id> (<text> | --text <t>)     one short present-tense line
-         [--agent <name>]
+                                                         that path or branch exists, unless it is a leftover
+                                                         holding no work, which it remakes. A build's main record
+                                                         on a board makes it without --worktree when it keeps none
+                                                         (a taken-up or resumed record's, or the worktree the
+                                                         card's last record left while it is still there)
+  builder progress <wave>/<id> --phase <phase>           one status line: a phase, reading, building, testing,
+         (<detail> | --text <d>) [--agent <name>]        checking or landing, and a present-tense detail of at most
+                                                         80 characters in plain words, which the owner reads at a
+                                                         glance; a longer detail is refused with its length. Hashes,
+                                                         test counts and file names go in the hand-back. The thread
+                                                         line reads "Testing: <detail>", "Codex testing: <detail>"
+                                                         for another agent, and the card "Testing \xB7 <detail>"
          [--eta <ISO time> | --clear-eta]                an ETA shows as a line under the card's status
          A progress line, --progress included, needs --site: it is a status line in the item's thread, and
-         the card's status shows the newest one from an agent still working
+         the card's status shows the newest one from an agent still working. builder progress refuses
+         without an open record for that agent, as builder call does
   builder done <wave>/<id> [--agent <name>]              marks that agent's record done; the item's thread
-                                                         shows when it started and finished; clears building/fixing
-                                                         when the card has no open builder records left
+         [--next <t>] [--text <what you checked>]        shows when it started and finished; clears building/fixing
+                                                         when the card has no open builder records left. On a
+                                                         record with unverified judgment calls it hands the card
+                                                         back: --status checking with Next "Answer the builder's
+                                                         questions" when a call starts "Question:", else "Verify
+                                                         the builder's judgment calls"; --next is refused there.
+                                                         Else, on a board, the main build's record that keeps a
+                                                         worktree finishes the card, as land does, --text its
+                                                         closing line: lands it, closes the card and its ticket
+                                                         and, with the board's "Push main after a land" on, pushes
+                                                         the branch to origin; on a GitHub board it pushes the
+                                                         card's branch, opens a draft PR and moves the card to it,
+                                                         and on a plain git remote pushes the branch for the
+                                                         owner's merge (item set --pushed). A finish that fails
+                                                         refuses with the reason and leaves the record open; one
+                                                         refused while another agent's record is open names it.
+                                                         --next stops a build without finishing it. Closing the
+                                                         last record of a card left In Progress with no Next is
+                                                         refused without --next, which sets it
+         [--owner-step <t>]                              a step only the owner can do once the code lands: the card
+                                                         then waits in In Review with it as its Next, its ticket
+                                                         open, until the owner's Done; refused on a card already
+                                                         done, merged or dropped. land takes it too
          builder takes --dir <dir> for a wave file in <dir>; its records go in <dir>/agents
-  land <wave>/<id> [--repo <dir>] [--dir <dir>]          brings the worktree its builder record keeps (else
-                                                         ~/.claude/kickflip/worktrees/<id> of --repo) into main, one line
-                                                         per step: refuses while it has uncommitted changes or adds no
-                                                         commit; rebases onto main when main moved, refusing on a
-                                                         conflict with the rebase undone; refuses unless its full
-                                                         node --test suite passes, naming each failing test and
-                                                         saving the TAP output under ~/.claude/kickflip/logs;
-                                                         fast-forwards main in the repo;
+  builder pick <wave>/<id>                               who builds the card, from the hub's Codex share and the pause
+                                                         line, and for claude which model, from the hub's Claude model
+                                                         and the card's --size and --model: "codex: <reason>" or
+                                                         "claude sonnet: <reason>". Pass that kind to builder start
+                                                         --kind, and launch that model
+  builder call <wave>/<id> <judgment call>             appends one line to the agent's open builder record: a
+         [--agent <name>]                                judgment call as the builder makes it, or a "Question: \u2026"
+                                                         for the session; refused with no open record. A builder start
+                                                         on a record with unverified calls resumes that build, keeping
+                                                         its calls and worktree. The thread shows them, collapsed
+  builder calls <wave>/<id> [--agent <name>]             prints the record's calls, numbered, then "verified <time>"
+                                                         or "not verified yet"
+  builder ask <wave>/<id> <question> [--agent <name>]    a running builder's one-line question for the board's session,
+                                                         which it asks at any point and carries on meanwhile: a thread
+                                                         line named by its model ("Claude Opus builder"), never unread,
+                                                         and a builder-ask {key, ask, agent, text} event. Prints its
+                                                         id, ask<n>. Needs --site and an open builder record
+  builder answer <wave>/<id> <ask> --text <t>            the session's answer to that ask, a thread line named
+                                                         Orchestrator that leaves the card quiet
+  builder defer <wave>/<id> <ask> --text <t>             the session's deferral of an ask it can't answer confidently:
+                                                         the same thread line, and a "Question: <ask> (deferred to the
+                                                         owner)" call on the asking agent's record. After its review the
+                                                         session puts it to the owner as a card question with
+                                                         "ask": "<ask>"; builder verified refuses until then
+  builder asks <wave>/<id>                               prints each ask, then its answer, its deferral or "waiting on
+                                                         the orchestrator"
+  builder verified <wave>/<id> [--agent <name>]          the session's mark that it checked the record's calls; land
+         [--note <t>]                                    refuses while any record on the card has a call after it.
+                                                         On a handed-back build (checking, no builder open, every
+                                                         call verified) it finishes the card in the same step, as
+                                                         builder done does, --note its closing line (else "Judgment
+                                                         calls verified."). While a question on the card is open it
+                                                         says so and the card waits; a finish that fails keeps the
+                                                         mark, the card checking, and says why
+  land <wave>/<id> --text <t> [--repo <dir>]             brings the worktree its builder record keeps (else
+         [--dir <dir>]
+                                                         ~/.claude/kickflip/worktrees/<id> of --repo) into the board's
+                                                         branch (the one its builders branch from, else main), one
+                                                         line per step: refuses unless the repo has that branch
+                                                         checked out, naming it, or while the worktree has uncommitted
+                                                         changes or adds no commit; rebases onto the branch when it
+                                                         moved, refusing on a conflict with the rebase undone; refuses
+                                                         a new ADR named with a number instead of a timestamp; refuses
+                                                         unless its full node --test suite passes, naming each failing
+                                                         test and saving the TAP output under ~/.claude/kickflip/logs;
+                                                         fast-forwards the branch in the repo;
                                                          restarts the hub when its code changed, else each board
                                                          server when board/ changed; removes the worktree and its
-                                                         branch. Never pushes. KICKFLIP_RESTART_CMD='["<cmd>"]' replaces
+                                                         branch. Without --site it never pushes. One land runs at a time on the host: a
+                                                         second refuses, naming the card landing. With --site, --text <what was checked>
+                                                         is required, and once it lands the card closes as item set
+                                                         --status done --text does; it refuses first what that close
+                                                         would. With --site it is builder done's finish: the push
+                                                         after a land, and on a GitHub or plain-remote board the
+                                                         branch push (and draft PR) instead of the fast-forward.
+                                                         --owner-step <t>, as builder done takes it, keeps the
+                                                         landed card in In Review on that step until the owner's
+                                                         Done. KICKFLIP_RESTART_CMD='["<cmd>"]' replaces
                                                          the restarts, called with hub or board <route>
-  push --kind action|prompt|fault --title <t>            runs kickflip push with these flags, adding
+  merge <wave>/<id> [--after-approval "<why trivial>"]   merges the card's PRs (gh pr merge --squash) in its order and
+         [--confirmed "<owner's words>"]                 records it merged, once GitHub reads every open one approved,
+                                                         its checks green with none pending and its merge state CLEAN,
+                                                         the test the Merge button uses; a merged or closed PR is left
+                                                         as it is. Refuses, naming each reason ("pending: 2 checks"),
+                                                         commits after the newest approval unless --after-approval
+                                                         says why they're trivial (its closing line says so), and a
+                                                         card with manual steps unless --confirmed quotes the owner.
+                                                         A refusal also goes in the thread while the owner's Merge waits
+  arch file <wave>/<id>                                  turns the architecture review audit card's answered findings
+                                                         into cards in the review's wave: titled with the picked
+                                                         option's label, its detail, practice and the owner's note as
+                                                         notes, each after the wave's last card, its question resolved
+                                                         "Filed as <ref>."; a Skip pick resolves its question alone.
+                                                         Prints "filed: <ref> from <id>", "skipped: <id>", and
+                                                         "waiting: <ids>" while any are unanswered; once none is, it
+                                                         closes the audit card as done
+  push --kind fault|reminder --title <t>                 runs kickflip push with these flags, adding
        [--body <b>] [--url </route/path>]                "\xB7 and N replies" to the body for the replies
        [--tag <tag>] [--now | --urgent]                  written since the site's last push through this
-                                                         command (none before its first). For an item, tag it
-                                                         ask-<eventId> or item-<wave>/<id>; a card whose action
-                                                         changes pushes again under its tag. It records the
+                                                         command (none before its first). A session pushes only a
+                                                         fault, what only the owner can fix, or a reminder the
+                                                         owner asked for in words ("push me when it's all done"):
+                                                         the board server pushes each card's Action needed and the
+                                                         hub a session's prompt, so any other --kind is refused. It records the
                                                          push in data/push-state.json only when kickflip push
-                                                         succeeds, and exits with kickflip push's code.
-                                                         --kind: action when a card's Action needed appears or
-                                                         changes, fault for what only the owner can fix. Refused
-                                                         without one: news stays on the board.
-                                                         Without --now it queues until the tick ends (checked) or
-                                                         the hub's next check: drafts on Ready, Merge. --now sends
-                                                         at once unless pushes are held (overnight, snoozed or the
-                                                         weekend): questions, steps only the owner can run,
-                                                         prototypes asked for. --urgent: a production fault only;
-                                                         it beats those holds. While notifications are off every
-                                                         push is dropped, urgent too
-         KICKFLIP_PUSH_CMD='["<cmd>","<arg>"]' replaces \`node ../../bin/kickflip.mjs push\`; the flags follow it`;class r extends Error{static{l(this,"UsageError")}}const W=new Set(["clear-status","clear-next","urgent","now","clear-eta","held","unheld","idle","hub","clear-install","force","worktree","dry-run"]),J=new Set(["take"]),G=f.join(f.dirname(C(import.meta.url)),"..","..","bin","kickflip.mjs");function z(){if(!process.env.KICKFLIP_PUSH_CMD)return[process.execPath,G,"push"];try{const e=JSON.parse(process.env.KICKFLIP_PUSH_CMD);if(Array.isArray(e)&&e.length&&e.every(s=>typeof s=="string"))return e}catch{}throw new n.BoardError("KICKFLIP_PUSH_CMD must be a JSON array of strings")}l(z,"pushCommand");async function Q(e,s){const t=B(s.kind);if(t)throw new r(t);if(s.title===void 0)throw new r("push needs --title");const a=new Date,i=await n.repliesSincePush(e,a),o=n.withReplies(s.body,i),d={kind:s.kind,title:s.title,body:o||void 0,url:n.pushUrl(s.url),tag:s.tag},[c,...p]=z(),u=[...p,...Object.entries(d).flatMap(([v,m])=>m===void 0?[]:[`--${v}`,m]),...s.urgent?["--urgent"]:[],...s.now?["--now"]:[]],h=O(c,u,{stdio:"inherit"});if(h.status!==0)throw Object.assign(new n.BoardError(`kickflip push failed (${h.error?.message||`exit ${h.status??h.signal}`}); the push was not recorded`),{exitCode:h.status||1});return n.recordPush(e,a)}l(Q,"push");function X(e){const s=Object.create(null),t=[];for(let a=0;a<e.length;a++){const i=e[a];if(!i.startsWith("--")){t.push(i);continue}const o=i.slice(2);if(J.has(o)){if(a+1>=e.length)throw new r(`--${o} needs a value`);(s[o]||=[]).push(e[++a]);continue}if(Object.hasOwn(s,o))throw new r(`--${o} is given twice`);if(W.has(o))s[o]=!0;else if(a+1<e.length)s[o]=e[++a];else throw new r(`--${o} needs a value`)}return{flags:s,rest:t}}l(X,"parse");const V=["html","text","note","notes","summary","title","body","next","progress","install-label","confirmed"],Y=/^(?:\/|~\/|\.{1,2}\/)\S*\.(?:html?|md|json|txt)$/;function Z(e){const s=e.trim();if(!s||/\s/.test(s))return!1;if(Y.test(s))return!0;try{return g.statSync(s).isFile()}catch{return!1}}l(Z,"looksLikePath");function ee(e,s){for(const t of V){if(typeof s[t]!="string"||!Z(s[t]))continue;const a=e.includes("file")?`; for a file use --file ${s[t].trim()}`:"";throw new r(`--${t} takes text, not a file path (${s[t].trim()})${a}`)}if(typeof s.file=="string"&&s.file!=="-"&&!g.existsSync(s.file))throw new r(`--file ${s.file}: no such file`)}l(ee,"checkInputs");const A=l(e=>g.readFileSync(e==="-"?0:e,"utf8"),"readInput");function x(e){if(!e)throw new r("--file <path> is required");try{return JSON.parse(A(e))}catch(s){throw new n.BoardError(`${e}: ${s.message}`)}}l(x,"readJSONInput");function P(e){if(e.plan!==void 0&&e["notes-file"]!==void 0)throw new r("pass --notes-file or --plan, not both");return e["notes-file"]??e.plan}l(P,"notesFileOf");const b={reply:[["eventId"],["html","file"],(e,[s],t)=>{if(t.html===void 0==(t.file===void 0))throw new r("reply takes --html or --file");return n.writeReply(e,s,t.html??A(t.file))}],thread:[["wave/id"],["text","link","who","via"],(e,[s],t)=>n.appendThread(e,s,t)],"topic add":[["id"],["title","summary"],(e,[s],t)=>n.addTopic(e,{id:s,...t})],"question add":[[],["file"],(e,s,t)=>n.addQuestions(e,x(t.file))],"question resolve":[["id"],["note"],(e,[s],t)=>n.resolveQuestion(e,s,t.note)],"prototype add":[["topic"],["title","take","card"],(e,[s],t)=>n.addPrototype(e,{topic:s,title:t.title,card:t.card,takes:t.take})],"prototype list":[[],[],e=>n.listPrototypes(e)],"prototype rm":[["topic"],[],(e,[s])=>n.removePrototype(e,s)],"item set":[["wave/id"],["status","clear-status","next","clear-next","pr","from-ask","held","unheld","notes-file","plan","deps","install","install-sha","install-label","clear-install","title","force","ticket","confirmed"],(e,[s],t,a)=>n.setItem(e,s,{status:t.status,clearStatus:t["clear-status"],next:t.next,clearNext:t["clear-next"],pr:t.pr,fromAsk:t["from-ask"],held:t.held,unheld:t.unheld,notesFile:P(t),deps:t.deps,install:t.install,installSha:t["install-sha"],installLabel:t["install-label"],clearInstall:t["clear-install"],title:t.title,force:t.force,ticket:t.ticket,confirmed:t.confirmed},a)],"item add":[["wave/id"],["title","notes","deps","notes-file","plan","ticket"],(e,[s],t,a)=>n.addItem(e,s,{title:t.title,notes:t.notes,deps:t.deps,notesFile:P(t),ticket:t.ticket},a)],"item relate-ask":[["eventId","wave/id"],["summary"],(e,[s,t],a)=>n.relateAsk(e,s,t,a.summary)],"ask progress":[["eventId"],["next"],(e,[s],t)=>n.markAsk(e,s,"progress",t.next)],"ask done":[["eventId"],[],(e,[s])=>n.markAsk(e,s,"done")],"ask unfold":[["eventId"],[],(e,[s])=>n.unfoldAsk(e,s)],"ask move":[["eventId"],["to"],(e,[s],t)=>n.moveAsk(e,s,t.to)],"followup add":[["wave"],["id","title","from","ticket"],(e,[s],t,a)=>n.addFollowup(e,s,t,a)],"tickets backfill":[[],["dry-run"],(e,s,t,a)=>n.backfillTickets(e,{dryRun:t["dry-run"]},a)],"followup done":[["wave","id"],["force"],(e,[s,t],a)=>n.finishFollowup(e,s,t,{force:a.force})],"followup set":[["wave","id"],["ticket"],(e,[s,t],a)=>n.setFollowupTicket(e,s,t,a.ticket)],"reviewers set":[[],["file"],(e,s,t)=>n.setReviewers(e,x(t.file))],"reviewers add":[[],["file"],(e,s,t)=>n.addReviewers(e,x(t.file))],"reviewers remove":[["...name"],[],(e,s)=>n.removeReviewers(e,s)],"rules list":[[],[],e=>n.listRules(e)],"rules add":[[],["text","hub","by"],(e,s,t)=>n.addRuleTo(e,t)],"rules edit":[["id"],["text","hub"],(e,[s],t)=>n.editRuleIn(e,s,t)],"rules remove":[["id"],["hub"],(e,[s],t)=>n.removeRuleFrom(e,s,t)],settings:[[],[],async e=>({lines:[JSON.stringify(await n.readBoardSettings(e))]})],build:[["wave/id"],[],async(e,[s])=>{if(!e)throw new n.BoardError("build needs --site <route>");n.parseKey(s);try{const t=await fetch(`http://127.0.0.1:${process.env.KICKFLIP_HUB_PORT||4500}/_hub/build`,{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({route:f.basename(e),key:s}),signal:AbortSignal.timeout(1e4)}),a=await t.json();if(!t.ok)throw new n.BoardError(a.error||"The hub refused the build.");return{lines:["started"]}}catch(t){throw t instanceof n.BoardError?t:new n.BoardError(`Could not start the build: ${t.message}`)}}],"main set":[[],["install","install-sha"],(e,s,t)=>n.setMainInstall(e,{install:t.install,installSha:t["install-sha"]})],"settings set":[["name","on|off"],[],(e,[s,t])=>n.setBoardSetting(e,s,t)],"builder start":[["wave/id"],["label","progress","dir","agent","kind","eta","worktree","repo"],(e,[s],{worktree:t,repo:a,...i})=>{if(a!==void 0&&!t)throw new r("--repo goes with --worktree");const o=M(),d=e?K(e,o):null,c=d?D(d.route,o):{},p=!!c.github,u=a??(p&&c.repo||void 0),h=p&&c.branch||"main";return n.startBuilder(e,s,{...i,worktree:t&&(()=>q(s.split("/")[1],{repo:u,base:h,remote:p}))})}],"builder progress":[["wave/id","...text?"],["text","dir","agent","eta","clear-eta"],(e,[s,...t],a)=>{if(t.length&&a.text!==void 0)throw new r("builder progress takes its text once: as words or as --text");if(!t.length&&a.text===void 0)throw new r("builder progress needs its text, as words or as --text");return n.builderProgress(e,s,a.text??t.join(" "),{...a,clearEta:a["clear-eta"]})}],"builder done":[["wave/id"],["dir","agent"],(e,[s],t)=>n.stopBuilder(e,s,t)],land:[["wave/id"],["repo","dir"],async(e,[s],t)=>{const a=s.split("/")[1],i=await n.recordedWorktree(e,s,{dir:t.dir}),o=f.resolve(t.repo??i?.repo??L());return T({path:i?.path??f.join(N(),a),branch:i?.branch??a,repo:o}),{lines:[]}}],working:[["eventId"],[],(e,[s])=>n.setWorking(e,s)],"hello-ack":[["eventId"],[],(e,[s])=>n.ackHello(e,s)],checked:[[],["every","idle"],(e,s,t)=>n.writeChecked(e,t.every,{idle:t.idle})],push:[[],["kind","title","body","url","tag","urgent","now"],(e,s,t)=>Q(e,t)]};b.install=b.build;async function te(e,s={}){try{const{flags:t,rest:a}=X(e),i=S(b,`${a[0]} ${a[1]}`)?`${a[0]} ${a[1]}`:a[0],o=S(b,i);if(!o)throw new r(a.length?`unknown command "${a.slice(0,2).join(" ")}"`:"no command given");const[d,c,p]=o,u=a.slice(i.split(" ").length),h=d.at(-1)?.startsWith("..."),v=d.at(-1)?.endsWith("?")?d.length-1:d.length;if(h?u.length<v:u.length!==d.length)throw new r(`${i} takes ${d.map(w=>`<${w.replace(/^\.\.\.|\?$/g,"")}>`).join(" ")||"no arguments"}`);const{site:m,...y}=t,I=Object.keys(y).filter(w=>!c.includes(w));if(I.length)throw new r(`${i} does not take ${I.map(w=>"--"+w).join(", ")}`);ee(c,y);const $=m===void 0?null:await n.siteDir(m),k=await p($,u,y,s),{file:j,lines:R=[]}=typeof k=="object"&&k?k:{file:k};i.startsWith("builder ")?console.log(`${i.slice(8)} ${u[0]}`):j!==void 0&&console.log(`${i} \u2192 ${j}`);for(const w of R)console.log(w);return 0}catch(t){if(t instanceof r)return console.error(`${t.message} (node board.mjs --help lists the commands)`),2;if(t instanceof n.BoardError)return console.error(t.message),t.exitCode??1;throw t}}if(l(te,"main"),process.argv[1]&&import.meta.url===E(g.realpathSync(process.argv[1])).href){H();const e=process.argv.slice(2);!e.length||e.includes("--help")||e[0]==="help"?console.log(U):process.exitCode=await te(e)}export{U as USAGE,te as main};
+                                                         succeeds, and exits with kickflip push's code. Without --now
+                                                         it queues until the tick ends (checked) or the hub's
+                                                         next check; --now sends at once unless pushes are held
+                                                         (overnight, snoozed or the weekend). --urgent: a
+                                                         production fault only; it beats those holds. While
+                                                         notifications are off every push is dropped, urgent too
+         KICKFLIP_PUSH_CMD='["<cmd>","<arg>"]' replaces \`node ../../bin/kickflip.mjs push\`; the flags follow it`;class d extends Error{static{i(this,"UsageError")}}const Z=new Set(["clear-status","clear-next","urgent","now","clear-eta","held","unheld","idle","hub","clear-install","force","worktree","dry-run","dispatch"]);function Y(e){const s=Object.create(null),t=[];for(let a=0;a<e.length;a++){const r=e[a];if(!r.startsWith("--")){t.push(r);continue}const l=r.slice(2);if(Z.has(l)){if(Object.hasOwn(s,l))throw new d(`--${l} is given twice`);s[l]=!0}else if(a+1<e.length)(s[l]||=[]).push(e[++a]);else throw new d(`--${l} needs a value`)}return{flags:s,rest:t}}i(Y,"parse");function ee(e,s,t){const a=new Set(s.filter(o=>o.startsWith("...")).map(o=>o.slice(3))),r=new Set(s.map(o=>o.replace(/^\.\.\./,""))),l=Object.keys(t).filter(o=>!r.has(o));if(l.length)throw new d(`${e} does not take ${l.map(o=>"--"+o).join(", ")}`);return Object.fromEntries(Object.entries(t).map(([o,c])=>{if(c===!0||a.has(o))return[o,c];if(c.length>1)throw new d(`--${o} is given twice`);return[o,c[0]]}))}i(ee,"flagsOf");const te=["html","text","note","notes","summary","title","body","next","progress","install-label","confirmed","asked"],se=/^(?:\/|~\/|\.{1,2}\/)\S*\.(?:html?|md|json|txt)$/;function ae(e){const s=e.trim();if(!s||/\s/.test(s))return!1;if(se.test(s))return!0;try{return w.statSync(s).isFile()}catch{return!1}}i(ae,"looksLikePath");function ne(e,s){for(const t of te){if(typeof s[t]!="string"||!ae(s[t]))continue;const a=e.includes("file")?`; for a file use --file ${s[t].trim()}`:"";throw new d(`--${t} takes text, not a file path (${s[t].trim()})${a}`)}if(typeof s.file=="string"&&s.file!=="-"&&!w.existsSync(s.file))throw new d(`--file ${s.file}: no such file`)}i(ne,"checkInputs");const f=i(e=>w.readFileSync(e==="-"?0:e,"utf8"),"readInput");function $(e){if(!e)throw new d("--file <path> is required");try{return JSON.parse(f(e))}catch(s){throw new n.BoardError(`${e}: ${s.message}`)}}i($,"readJSONInput");function A(e){if(e.plan!==void 0&&e["notes-file"]!==void 0)throw new d("pass --notes-file or --plan, not both");return e["notes-file"]??e.plan}i(A,"notesFileOf");function P(e){if(e.note!==void 0&&e.file!==void 0)throw new d("pass --note or --file, not both");return e.file===void 0?e.note:f(e.file)}i(P,"noteOf");const g={pr:[["wave/id"],[],async(e,[s])=>({lines:(await n.prReport(e,s)).map(t=>JSON.stringify(t))})],"pr comment":[["pr"],["body"],(e,[s],t)=>{if(t.body===void 0)throw new d('pr comment needs --body "<what Claude says>"');return n.postPR(e,s,{body:t.body})}],"pr reply":[["pr","comment-id"],["body"],(e,[s,t],a)=>{if(a.body===void 0)throw new d('pr reply needs --body "<what Claude says>"');return n.postPR(e,s,{replyTo:t,body:a.body})}],reply:[["eventId"],["html","file"],(e,[s],t)=>{if(t.html===void 0==(t.file===void 0))throw new d("reply takes --html or --file");return n.writeReply(e,s,t.html??f(t.file))}],thread:[["wave/id"],["text","link","who","via"],(e,[s],t)=>n.appendThread(e,s,t)],"topic add":[["id"],["title","summary"],(e,[s],t)=>n.addTopic(e,{id:s,...t})],"question add":[[],["file"],async(e,s,t)=>{const a=$(t.file);return{...await n.addQuestions(e,a),asked:[a].flat()}}],"question resolve":[["id"],["note"],(e,[s],t)=>n.resolveQuestion(e,s,t.note)],"prototype add":[["topic"],["title","...take","card"],(e,[s],t)=>n.addPrototype(e,{topic:s,title:t.title,card:t.card,takes:t.take})],"prototype list":[[],[],e=>n.listPrototypes(e)],"prototype rm":[["topic"],[],(e,[s])=>n.removePrototype(e,s)],"item set":[["wave/id"],["status","clear-status","next","clear-next","...pr","pushed","gh-since","from-ask","state","held","unheld","pick-up-at","notes-file","plan","deps","parent","related","install","install-sha","install-label","clear-install","title","size","model","force","ticket","text"],async(e,[s],t,a)=>(t.status==="done"&&e&&await n.checkNotReopened(e,s),n.setItem(e,s,{status:t.status,clearStatus:t["clear-status"],next:t.next,clearNext:t["clear-next"],pr:t.pr,pushed:t.pushed,ghSince:t["gh-since"],fromAsk:t["from-ask"],state:t.state,held:t.held,unheld:t.unheld,pickUpAt:t["pick-up-at"],notesFile:A(t),deps:t.deps,parent:t.parent,related:t.related,install:t.install,installSha:t["install-sha"],installLabel:t["install-label"],clearInstall:t["clear-install"],title:t.title,size:t.size,model:t.model,force:t.force,ticket:t.ticket,text:t.text},a))],"item add":[["wave[/id]"],["title","notes","deps","notes-file","plan","ticket","pick-up-at","parent","size","model"],(e,[s],t,a)=>n.addItem(e,s,{title:t.title,notes:t.notes,deps:t.deps,notesFile:A(t),ticket:t.ticket,pickUpAt:t["pick-up-at"],parent:t.parent,size:t.size,model:t.model},a)],"item relate-ask":[["eventId","wave/id"],["summary"],(e,[s,t],a)=>n.relateAsk(e,s,t,a.summary)],"ask progress":[["eventId"],["next"],(e,[s],t)=>n.markAsk(e,s,"progress",t.next)],"ask done":[["eventId"],[],(e,[s])=>n.markAsk(e,s,"done")],"ask unfold":[["eventId"],[],(e,[s])=>n.unfoldAsk(e,s)],"ask move":[["eventId"],["to"],(e,[s],t)=>n.moveAsk(e,s,t.to)],"tickets backfill":[[],["dry-run"],(e,s,t,a)=>n.backfillTickets(e,{dryRun:t["dry-run"]},a)],"lineup create":[["slug"],["title","goal","...phase","note","file"],(e,[s],t)=>n.createLineup(e,s,{title:t.title,goal:t.goal,phases:t.phase,note:P(t)})],"lineup add":[["slug","wave/id"],["after"],(e,[s,t],a)=>n.changeLineup(e,s,{add:t,after:a.after})],"lineup remove":[["slug","wave/id"],[],(e,[s,t])=>n.changeLineup(e,s,{remove:t})],"lineup set":[["slug"],["title","goal","note","file","...phase"],(e,[s],t)=>n.changeLineup(e,s,{title:t.title,goal:t.goal,note:P(t),phases:t.phase})],"lineup finish":[["slug"],[],(e,[s])=>n.finishLineup(e,s)],slack:[[],[],()=>({lines:[JSON.stringify(L())]})],"slack set":[[],["self-dm","user","domain","timezone"],async(e,s,t)=>{const a={"self-dm":"self_dm",user:"owner_slack_user",domain:"slack_domain",timezone:"timezone"};try{return{lines:[JSON.stringify(await D(Object.fromEntries(Object.entries(t).map(([r,l])=>[a[r],l]))))]}}catch(r){throw new n.BoardError(r.message)}}],integrations:[[],[],async()=>({lines:[JSON.stringify(await B.rows())]})],"integrations report":[[],["slack"],async(e,s,t)=>{if(!["yes","no"].includes(t.slack))throw new d("integrations report takes --slack yes|no");if(!e)throw new n.BoardError("integrations report needs --site <route>");const a=m.basename(e);return H(t.slack==="yes",{route:a,title:V().sites?.[a]?.title||(await n.boardConfig(e)).title}),{lines:[`Slack connector reported: ${t.slack}.`]}}],"review sent":[["wave/id","reviewer"],["ts","channel"],(e,[s,t],a)=>n.reviewSent(e,s,t,a)],"review react":[["wave/id","reviewer","emoji"],[],(e,[s,t,a])=>n.reviewReact(e,s,t,a)],"review record":[["pr"],["state","text","file","url"],(e,[s],t)=>{if(t.text===void 0==(t.file===void 0))throw new d("review record takes --text or --file");return n.recordReview(e,s,{state:t.state,text:t.text??f(t.file),url:t.url})}],"review digest":[[],[],async(e,s,t,a)=>({lines:[JSON.stringify(await n.reviewDigest(e,a))]})],"review due":[[],[],async(e,s,t,a)=>({lines:[JSON.stringify(await n.reviewDue(e,a))]})],"review digest sent":[["reviewer"],["ts","channel","items"],(e,[s],t,a)=>n.reviewDigestSent(e,s,t,a)],"reviewers set":[[],["file"],(e,s,t)=>n.setReviewers(e,$(t.file))],"reviewers add":[[],["file"],(e,s,t)=>n.addReviewers(e,$(t.file))],"reviewers remove":[["...name"],[],(e,s)=>n.removeReviewers(e,s)],"rules list":[[],[],e=>n.listRules(e)],"rules add":[[],["text","hub","by"],(e,s,t)=>n.addRuleTo(e,t)],"rules edit":[["id"],["text","hub"],(e,[s],t)=>n.editRuleIn(e,s,t)],"rules remove":[["id"],["hub"],(e,[s],t)=>n.removeRuleFrom(e,s,t)],settings:[[],[],async e=>({lines:[JSON.stringify(await n.readBoardSettings(e))]})],build:[["wave/id"],["asked"],async(e,[s],t)=>{if(!e)throw new n.BoardError("build needs --site <route>");n.parseKey(s);const a=await n.askedGate(e,s,t.asked);try{const r=await fetch(`http://127.0.0.1:${process.env.KICKFLIP_HUB_PORT||4500}/_hub/build`,{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({route:m.basename(e),key:s}),signal:AbortSignal.timeout(1e4)}),l=await r.json();if(!r.ok)throw new n.BoardError(l.error||"The hub refused the build.");return{lines:["started",...(await n.appendThread(e,s,{text:a})).lines]}}catch(r){throw r instanceof n.BoardError?r:new n.BoardError(`Could not start the build: ${r.message}`)}}],"main set":[[],["install","install-sha"],(e,s,t)=>n.setMainInstall(e,{install:t.install,installSha:t["install-sha"]})],"settings set":[["name","value"],[],(e,[s,t])=>n.setBoardSetting(e,s,t)],"builder start":[["wave/id"],["label","phase","progress","dir","agent","kind","model","eta","worktree","repo","dispatch"],(e,[s],{worktree:t,repo:a,dispatch:r,...l})=>{if(a!==void 0&&!t)throw new d("--repo goes with --worktree");const o=i(b=>z(e,s.split("/")[1],{repo:a,...b}),"make"),c=e&&l.dir===void 0&&Q(e);return n.startBuilder(e,s,{...l,dispatch:r?"session":void 0,worktree:t?o:void 0,ownWorktree:c?o:void 0})}],"builder progress":[["wave/id","...text?"],["phase","text","dir","agent","eta","clear-eta"],(e,[s,...t],a)=>{if(t.length&&a.text!==void 0)throw new d("builder progress takes its text once: as words or as --text");if(!t.length&&a.text===void 0)throw new d("builder progress needs its text, as words or as --text");return n.builderProgress(e,s,a.text??t.join(" "),{...a,clearEta:a["clear-eta"]})}],"builder done":[["wave/id"],["dir","agent","next","owner-step","text"],async(e,[s],{"owner-step":t,text:a,...r})=>{if(t!==void 0&&(!e||r.dir))throw new d("--owner-step goes on a board card: pass --site, not --dir");t!==void 0&&await n.setItem(e,s,{ownerStep:t});const l=e&&!r.dir,o=l&&await n.handBackCalls(e,s,r);if(o)return o;if(l&&r.next===void 0&&await n.finishesCard(e,s,r)){if(a===void 0)throw new n.BoardError(`builder done finishes ${s}: pass --text "<what you checked>", or --next "<what happens next>" to stop without finishing`);return x(e,s,{text:a,ownerStep:t})}if(a!==void 0)throw new d("--text goes on a builder done that finishes the card: the main build, with a worktree and no --next");return n.stopBuilder(e,s,{...r,requireNext:!0})}],"builder pick":[["wave/id"],[],(e,[s])=>n.pickBuilder(e,s)],"builder call":[["wave/id","...text"],["dir","agent"],(e,[s,...t],a)=>n.recordCall(e,s,t.join(" "),a)],"builder calls":[["wave/id"],["dir","agent"],(e,[s],t)=>n.listCalls(e,s,t)],"builder ask":[["wave/id","...text"],["agent"],(e,[s,...t],a)=>n.askOrchestrator(e,s,t.join(" "),a)],"builder answer":[["wave/id","ask"],["text"],(e,[s,t],a)=>n.answerBuilder(e,s,t,a.text)],"builder defer":[["wave/id","ask"],["text"],(e,[s,t],a)=>n.answerBuilder(e,s,t,a.text,{deferred:!0})],"builder asks":[["wave/id"],[],(e,[s])=>n.listAsks(e,s)],"builder verified":[["wave/id"],["dir","agent","note"],async(e,[s],t)=>{await n.verifyCalls(e,s,t);const a=e&&!t.dir?await n.verifiedFinish(e,s):null;if(!a)return{};if(a.waits.length)return{lines:[`${await n.cardName(e,s)} finishes once the owner answers ${a.waits.join(", ")}`]};try{return await x(e,s,{text:t.note??"Judgment calls verified."})}catch(r){throw r instanceof n.BoardError?Object.assign(new n.BoardError(`judgment calls verified, but ${await n.cardName(e,s)} didn't finish: ${r.message}`),{exitCode:r.exitCode}):r}}],land:[["wave/id"],["repo","dir","text","owner-step"],async(e,[s],t)=>{const a=s.split("/")[1];if(e&&t.text===void 0)throw new d(`land needs --text "<what was checked>", which closes ${s} as done once it lands`);if(!e&&t.text!==void 0)throw new d("--text closes the card, which needs --site");if(!e&&t["owner-step"]!==void 0)throw new d("--owner-step keeps a board card open, which needs --site");return e&&t.dir===void 0?x(e,s,{text:t.text,ownerStep:t["owner-step"],repo:t.repo}):M(e?await n.cardName(e,s):s,async()=>{e&&await n.checkClose(e,s,t.text,t["owner-step"]),await n.checkCallsVerified(e,s,{dir:t.dir});const r=await n.recordedWorktree(e,s,{dir:t.dir}),{repo:l,base:o}=G(e,{repo:t.repo??r?.repo});return J({path:r?.path??m.join(F(),a),branch:r?.branch??a,repo:m.resolve(l),base:o,ref:e?await n.cardName(e,s):void 0}),e?n.setItem(e,s,{status:"done",text:t.text,ownerStep:t["owner-step"]}):{lines:[]}})}],merge:[["wave/id"],["after-approval","confirmed"],(e,[s],t)=>n.mergeCard(e,s,{afterApproval:t["after-approval"],confirmed:t.confirmed})],"arch file":[["wave/id"],[],(e,[s])=>e?U(e,s):Promise.reject(new n.BoardError("arch file needs --site <route>"))],checked:[[],["every","idle"],(e,s,t)=>n.writeChecked(e,t.every,{idle:t.idle})],push:[[],["kind","title","body","url","tag","urgent","now"],(e,s,t)=>{if(t.kind!=="fault"&&t.kind!=="reminder")throw new d(`a session pushes only --kind fault or reminder${t.kind===void 0||t.kind===!0?"":`, not "${t.kind}"`}: the board server pushes Action needed, and news goes on the board`);if(t.title===void 0)throw new d("push needs --title");return n.sendPush(e,t)}]};g.install=g.build;const h=i((e,s)=>n.cardName(e,s),"card"),C=i((e,s)=>`${s}${e.length===1?"":"s"} ${e.join(", ")}`,"plural"),q=i(e=>e.agent===void 0||e.agent==="main"?"builder":`builder ${e.agent}`,"builderOf");function ie(e){const s=e["pick-up-at"];return[e.status,e["clear-status"]&&"status cleared",e.next!==void 0&&(e.next.trim()?"next line set":"next line cleared"),e["clear-next"]&&"next line cleared",e.pr!==void 0&&`PR #${e.pr}`,e.pushed!==void 0&&`pushed ${e.pushed}`,e["gh-since"]&&`GitHub read to ${e["gh-since"]}`,e["from-ask"]&&`from task ${e["from-ask"]}`,e.state,e.held&&"held",e.unheld&&"resumed",s!==void 0&&(s?`held until ${s}`:"resumed"),A(e)!==void 0&&"notes recorded",e.deps!==void 0&&(e.deps?`blocked by ${e.deps}`:"deps cleared"),e.parent!==void 0&&(e.parent?`parent ${e.parent}`:"parent cleared"),e.related!==void 0&&(e.related?`related to ${e.related.split(",").join(", ")}`:"related cleared"),e.install!==void 0&&"install published",e["clear-install"]&&"install cleared",e.title!==void 0&&"renamed",e.ticket!==void 0&&`ticket ${e.ticket}`].filter(Boolean).join(", ")}i(ie,"itemChanges");const re={reply:i(async(e,[s])=>`reply written to ${await n.eventCard(e,s)}`,"reply"),thread:i(async(e,[s])=>`thread line on ${await h(e,s)}`,"thread"),"topic add":i((e,[s])=>`topic ${s} added`,"topic add"),"question add":i(async(e,s,t,{asked:a})=>{const r=[...new Set(a.map(o=>o.topic))],l=r.length!==1?"":r[0].startsWith("item:")?` on ${await h(e,r[0].slice(5))}`:` on topic ${r[0]}`;return`${C(a.map(o=>o.id),"question")} added${l}`},"question add"),"question resolve":i((e,[s])=>`question ${s} resolved`,"question resolve"),"prototype add":i(async(e,[s],t)=>`prototype ${s} recorded${t.card?` for ${await h(e,t.card)}`:""}`,"prototype add"),"prototype rm":i((e,[s])=>`prototype ${s} removed`,"prototype rm"),"item set":i(async(e,[s],t)=>`${await h(e,s)}: ${ie(t)}`,"item set"),"item add":i(async(e,s,t,{key:a})=>`${await h(e,a)} added as ${a}`,"item add"),"item relate-ask":i(async(e,[s,t])=>`task ${s} folded into ${await h(e,t)}`,"item relate-ask"),"ask progress":i(async(e,[s])=>`${await h(e,`ask:${s}`)}: in progress`,"ask progress"),"ask done":i(async(e,[s])=>`${await h(e,`ask:${s}`)}: done`,"ask done"),"ask unfold":i((e,[s])=>`task ${s} back on a card of its own`,"ask unfold"),"ask move":i((e,[s],t)=>`task ${s} moved to /${t.to}`,"ask move"),checked:i((e,s,t,{every:a})=>a===null?"GitHub checked; no open PR":`GitHub checked; next in ${a} min`,"checked"),"lineup create":i((e,[s])=>`lineup ${s} created`,"lineup create"),"lineup add":i(async(e,[s,t])=>`${await h(e,t)} added to lineup ${s}`,"lineup add"),"lineup remove":i(async(e,[s,t])=>`${await h(e,t)} taken out of lineup ${s}`,"lineup remove"),"lineup set":i((e,[s])=>`lineup ${s} updated`,"lineup set"),"lineup finish":i((e,[s])=>`lineup ${s} finished`,"lineup finish"),"review sent":i(async(e,[s,t])=>`review link to ${t} recorded on ${await h(e,s)}`,"review sent"),"review react":i(async(e,[s,t,a])=>`${a} on ${t}'s review link recorded on ${await h(e,s)}`,"review react"),"review digest sent":i((e,[s])=>`digest to ${s} recorded`,"review digest sent"),"review record":i((e,[s],t)=>`review of PR #${s} recorded: ${t.state==="needs"?"needs you":"posted"}`,"review record"),"reviewers set":i(()=>"reviewers replaced","reviewers set"),"reviewers add":i(()=>"reviewers added","reviewers add"),"reviewers remove":i((e,s)=>`${C(s,"reviewer")} removed`,"reviewers remove"),"rules add":i((e,s,t)=>`${t.hub?"hub":"board"} rule added`,"rules add"),"rules edit":i((e,[s],t)=>`${t.hub?"hub":"board"} rule ${s} reworded`,"rules edit"),"rules remove":i((e,[s],t)=>`${t.hub?"hub":"board"} rule ${s} removed`,"rules remove"),"builder start":i(async(e,[s],t,a)=>`${await h(e,s)}: ${a.alreadyOpen?"already open: the Implement tap opened its record; launch the agent, whose own builder start takes it up":`${q(t)} started`}`,"builder start"),"builder progress":i(async(e,[s])=>`progress line on ${await h(e,s)}`,"builder progress"),"builder done":i(async(e,[s],t,a)=>`${await h(e,s)}: ${a?.said??`${q(t)} done${t["owner-step"]===void 0?"":`; owner step "${t["owner-step"].trim()}"`}`}`,"builder done"),"builder call":i(async(e,[s])=>`judgment call recorded on ${await h(e,s)}`,"builder call"),"builder ask":i(async(e,[s],t,{id:a})=>`${await h(e,s)}: asked the orchestrator, ${a}`,"builder ask"),"builder answer":i(async(e,[s,t])=>`${await h(e,s)}: ${t} answered`,"builder answer"),"builder defer":i(async(e,[s,t])=>`${await h(e,s)}: ${t} deferred to the owner`,"builder defer"),"builder verified":i(async(e,[s],t,a)=>`${await h(e,s)}: judgment calls verified${a?.said?`; ${a.said}`:""}`,"builder verified"),land:i(async(e,[s],t,a)=>e?a?.said?`${await h(e,s)}: ${a.said}`:t["owner-step"]===void 0?`${await h(e,s)}: landed and done`:`${await h(e,s)}: landed; waits on the owner step "${t["owner-step"].trim()}"`:null,"land"),merge:i(async(e,[s])=>`${await h(e,s)}: merged`,"merge"),"arch file":i(async(e,[s])=>`findings of ${await h(e,s)} filed`,"arch file")};async function oe(e,s={}){try{const{flags:t,rest:a}=Y(e),r=[3,2,1].map(u=>a.slice(0,u).join(" ")).find(u=>y(g,u)),l=y(g,r);if(!l)throw new d(a.length?`unknown command "${a.slice(0,2).join(" ")}"`:"no command given");const[o,c,b]=l,p=a.slice(r.split(" ").length),_=o.at(-1)?.startsWith("..."),N=o.at(-1)?.endsWith("?")?o.length-1:o.length;if(_?p.length<N:p.length!==o.length)throw new d(`${r} takes ${o.map(u=>`<${u.replace(/^\.\.\.|\?$/g,"")}>`).join(" ")||"no arguments"}`);const{site:S,...T}=t;if(S?.length>1)throw new d("--site is given twice");const O=S?.[0],k=ee(r,c,T);ne(c,k);const R=O===void 0?null:await n.siteDir(O),v=await b(R,p,k,s),I=y(re,r),j=I&&await I(R,p,k,v);j&&console.log(j);for(const u of typeof v=="object"&&v?.lines||[])console.log(u);return 0}catch(t){if(t instanceof d)return console.error(`${t.message} (node board.mjs --help lists the commands)`),2;if(t instanceof n.BoardError)return console.error(t.message),t.exitCode??1;throw t}}if(i(oe,"main"),process.argv[1]&&import.meta.url===W(w.realpathSync(process.argv[1])).href){const e=process.argv.slice(2);!e.length||e.includes("--help")||e[0]==="help"?console.log(X):process.exitCode=await oe(e)}export{X as USAGE,oe as main};