borgmcp 1.0.59 → 1.1.1

package/dist/setup.js

@@ -1,33 +1,35 @@
 #!/usr/bin/env node
-import k from"prompts";import e from"chalk";import w from"open";import C from"which";import{authenticateWithGoogle as F}from"./auth.js";import{checkSubscriptionStatus as i,createSubscription as P,probeSession as $}from"./remote-client.js";import{setupActionForSession as A}from"./setup-action.js";import{confirmConfigMutation as H,configMutationTargets as M,formatConfigMutationDisclosure as R,parseYesFlag as U,setupMutationPending as T}from"./setup-confirm.js";import{retrySubscriptionCheck as S}from"./subscription-retry.js";import{addMcpServer as D,addUserPromptSubmitHook as q,addCodexMcpServer as I,addCodexSessionStartHook as L,addCodexUserPromptSubmitHook as Y,isMcpServerConfigured as N,isCodexMcpServerConfigured as W,isSessionStartHookRegistered as j,isUserPromptSubmitHookRegistered as B,isCodexSessionStartHookRegistered as E,isCodexUserPromptSubmitHookRegistered as G,removeSessionStartHook as O}from"./config-utils.js";import{handleVersionFlag as z}from"./version.js";import{initDebugFromArgv as Q}from"./debug.js";async function V(){Q(process.argv),z(),console.log(e.blue.bold(`
-\u25FC Borg MCP Setup Wizard \u25FC`));const c=process.argv.includes("--no-browser")||process.argv.includes("--device");let t=null,n=null;try{t=C.sync("claude")}catch{}try{n=C.sync("codex")}catch{}t&&console.log(e.gray(`Found Claude CLI: ${t}`)),n&&console.log(e.gray(`Found Codex CLI: ${n}`)),(t||n)&&console.log(""),!t&&!n&&(console.error(e.red(`\u25FC No supported agent CLI found
-`)),console.error(e.yellow("Please install Claude Code or Codex first:")),console.error(e.gray("  Claude Code: https://claude.ai/download")),console.error(e.gray(`  Codex: https://developers.openai.com/codex
-`)),process.exit(1)),console.log(e.blue("\u25FC Agent CLI Integration"));const v=U(process.argv),a=t!==null,l=n!==null,d=N(),p=W(),h=a&&j(),m=a&&!B(),b=l&&!E(),f=l&&!G();if(T({claude:a,codex:l,claudeMcpConfigured:d,codexMcpConfigured:p,claudeHookPending:h||m,codexHookPending:b||f})&&(console.log(R(M({claude:a,codex:l}))),await H({isTTY:process.stdin.isTTY===!0,yes:v,confirm:async()=>{const{proceed:o}=await k({type:"confirm",name:"proceed",message:"Continue with these changes?",initial:!0});return o===!0}})==="abort"&&(console.log(e.yellow(`
+import x from"prompts";import e from"chalk";import v from"open";import p from"which";import{authenticateWithGoogle as A}from"./auth.js";import{checkSubscriptionStatus as i,createSubscription as M,probeSession as H}from"./remote-client.js";import{setupActionForSession as R}from"./setup-action.js";import{confirmConfigMutation as O,configMutationTargets as U,formatConfigMutationDisclosure as D,parseYesFlag as T,setupMutationPending as I}from"./setup-confirm.js";import{retrySubscriptionCheck as F}from"./subscription-retry.js";import{addMcpServer as L,addUserPromptSubmitHook as q,addCodexMcpServer as Y,addCodexSessionStartHook as N,addCodexUserPromptSubmitHook as W,addOpenCodeMcpServer as j,isMcpServerConfigured as B,isCodexMcpServerConfigured as E,isOpenCodeMcpServerConfigured as G,isSessionStartHookRegistered as z,isUserPromptSubmitHookRegistered as Q,isCodexSessionStartHookRegistered as V,isCodexUserPromptSubmitHookRegistered as J,removeSessionStartHook as K}from"./config-utils.js";import{handleVersionFlag as X}from"./version.js";import{initDebugFromArgv as Z}from"./debug.js";async function _(){Z(process.argv),X(),console.log(e.blue.bold(`
+\u25FC Borg MCP Setup Wizard \u25FC`));const a=process.argv.includes("--no-browser")||process.argv.includes("--device");let t=null,n=null,s=null;try{t=p.sync("claude")}catch{}try{n=p.sync("codex")}catch{}try{s=p.sync("opencode")}catch{}t&&console.log(e.gray(`Found Claude CLI: ${t}`)),n&&console.log(e.gray(`Found Codex CLI: ${n}`)),s&&console.log(e.gray(`Found OpenCode CLI: ${s}`)),(t||n||s)&&console.log(""),!t&&!n&&!s&&(console.error(e.red(`\u25FC No supported agent CLI found
+`)),console.error(e.yellow("Please install Claude Code, Codex, or OpenCode first:")),console.error(e.gray("  Claude Code: https://claude.ai/download")),console.error(e.gray("  Codex: https://developers.openai.com/codex")),console.error(e.gray(`  OpenCode: https://opencode.ai
+`)),process.exit(1)),console.log(e.blue("\u25FC Agent CLI Integration"));const $=T(process.argv),l=t!==null,d=n!==null,h=s!==null,m=B(),b=E(),f=G(),y=l&&z(),C=l&&!Q(),k=d&&!V(),w=d&&!J();if(I({claude:l,codex:d,opencode:h,claudeMcpConfigured:m,codexMcpConfigured:b,opencodeMcpConfigured:f,claudeHookPending:y||C,codexHookPending:k||w})&&(console.log(D(U({claude:l,codex:d,opencode:h}))),await O({isTTY:process.stdin.isTTY===!0,yes:$,confirm:async()=>{const{proceed:o}=await x({type:"confirm",name:"proceed",message:"Continue with these changes?",initial:!0});return o===!0}})==="abort"&&(console.log(e.yellow(`
 \u25FC Setup cancelled \u2014 no changes made.
-`)),process.exit(0))),console.log(""),t)try{d||D(),h&&O(),m&&q(),console.log(e.green("\u25FC borg configured for Claude Code"))}catch(r){console.error(e.red(`
+`)),process.exit(0))),console.log(""),t)try{m||L(),y&&K(),C&&q(),console.log(e.green("\u25FC borg configured for Claude Code"))}catch(r){console.error(e.red(`
 \u25FC Failed to configure Claude Code: ${r.message}
-`)),process.exit(1)}if(n)try{p||I(),b&&L(),f&&Y(),console.log(e.green("\u25FC borg configured for Codex"))}catch(r){console.error(e.red(`
+`)),process.exit(1)}if(n)try{b||Y(),k&&N(),w&&W(),console.log(e.green("\u25FC borg configured for Codex"))}catch(r){console.error(e.red(`
 \u25FC Failed to configure Codex: ${r.message}
-`)),process.exit(1)}console.log(""),console.log(e.blue("\u25FC Google Authentication"));const y=A(await $());if(y==="skip")console.log(e.green(`\u25FC Already signed in
-`));else if(y==="retry")console.error(e.yellow(`
-\u25FC Could not reach Google to verify your session (network issue).`)),console.error(e.yellow("Re-run `borg setup` when your connection is back.\n")),process.exit(1);else try{await F(c?{noBrowser:!0}:void 0)}catch(r){console.error(e.red(`
+`)),process.exit(1)}if(s)try{f||j(),console.log(e.green("\u25FC borg configured for OpenCode"))}catch(r){console.error(e.red(`
+\u25FC Failed to configure OpenCode: ${r.message}
+`)),process.exit(1)}console.log(""),console.log(e.blue("\u25FC Google Authentication"));const S=R(await H());if(S==="skip")console.log(e.green(`\u25FC Already signed in
+`));else if(S==="retry")console.error(e.yellow(`
+\u25FC Could not reach Google to verify your session (network issue).`)),console.error(e.yellow("Re-run `borg setup` when your connection is back.\n")),process.exit(1);else try{await A(a?{noBrowser:!0}:void 0)}catch(r){console.error(e.red(`
 \u25FC Authentication failed: ${r.message}
-`)),console.error(e.yellow("Re-run `borg setup` to try again.\n")),process.exit(1)}console.log(e.blue("\u25FC Subscription Check"));let s;try{s=await i()}catch(r){console.error(e.yellow(`
+`)),console.error(e.yellow("Re-run `borg setup` to try again.\n")),process.exit(1)}console.log(e.blue("\u25FC Subscription Check"));let c;try{c=await i()}catch(r){console.error(e.yellow(`
 \u25FC Subscription check failed: ${r.message}`)),console.error(e.gray(`\u25FC Retrying before falling back to the Free tier...
-`)),s={hasAccess:!1}}if(s=await S(s,{check:i,sleep:r=>new Promise(o=>setTimeout(o,r)),onRetry:(r,o)=>console.log(e.gray(`\u25FC Checking subscription... (attempt ${r}/${o})`))}),s.hasAccess)if(console.log(e.green("\u25FC Active subscription found")),s.expiresAt){const r=new Date(s.expiresAt);console.log(e.gray(`  Expires: ${r.toLocaleDateString()}
+`)),c={hasAccess:!1}}if(c=await F(c,{check:i,sleep:r=>new Promise(o=>setTimeout(o,r)),onRetry:(r,o)=>console.log(e.gray(`\u25FC Checking subscription... (attempt ${r}/${o})`))}),c.hasAccess)if(console.log(e.green("\u25FC Active subscription found")),c.expiresAt){const r=new Date(c.expiresAt);console.log(e.gray(`  Expires: ${r.toLocaleDateString()}
 `))}else console.log("");else{console.log(e.green("\u25FC You're on the Free tier \u2014 permanent, no card needed: 1 cube + 3 agent sessions + 100 req/hr.")),console.log(e.gray(`\u25FC Start using borgmcp right now. Upgrade any time: $1/month per cube, each cube adds 8 pooled agent sessions + 1000 req/hr.
-`));const{subscribeMethod:r}=await k({type:"select",name:"subscribeMethod",message:"You're ready on the Free tier. Want to do more?",choices:[{title:"\u25FC Continue on the Free tier (recommended)",value:"skip",description:"Start now \u2014 1 cube, 3 agent sessions, 100 req/hr. No payment required."},{title:"\u25FC Upgrade to Cube tier \u2014 $1/month per cube",value:"web",description:"Each cube adds 8 pooled agent sessions + 1000 req/hr. Opens the subscribe page in your browser."},{title:"\u25FC Quick Stripe checkout",value:"stripe",description:"Fast upgrade checkout in the browser"},{title:"\u25FC I already subscribed \u2014 re-check",value:"recheck",description:"Re-check now \u2014 a just-completed subscription can take a moment to activate"}]});switch(r===void 0&&console.log(e.yellow(`
+`));const{subscribeMethod:r}=await x({type:"select",name:"subscribeMethod",message:"You're ready on the Free tier. Want to do more?",choices:[{title:"\u25FC Continue on the Free tier (recommended)",value:"skip",description:"Start now \u2014 1 cube, 3 agent sessions, 100 req/hr. No payment required."},{title:"\u25FC Upgrade to Cube tier \u2014 $1/month per cube",value:"web",description:"Each cube adds 8 pooled agent sessions + 1000 req/hr. Opens the subscribe page in your browser."},{title:"\u25FC Quick Stripe checkout",value:"stripe",description:"Fast upgrade checkout in the browser"},{title:"\u25FC I already subscribed \u2014 re-check",value:"recheck",description:"Re-check now \u2014 a just-completed subscription can take a moment to activate"}]});switch(r===void 0&&console.log(e.yellow(`
 \u25FC No subscription option selected \u2014 continuing on the Free tier.
 `)),r){case"web":console.log(e.blue(`
-\u25FC Opening: https://borgmcp.ai/subscribe`));try{await w("https://borgmcp.ai/subscribe"),console.log(e.gray(`\u25FC Waiting for subscription (checking every 5s for 2 min)...
-`)),await x()}catch(o){console.error(e.yellow(`
+\u25FC Opening: https://borgmcp.ai/subscribe`));try{await v("https://borgmcp.ai/subscribe"),console.log(e.gray(`\u25FC Waiting for subscription (checking every 5s for 2 min)...
+`)),await P()}catch(o){console.error(e.yellow(`
 \u25FC ${o.message}`)),console.log(e.green(`\u25FC Continuing on the Free tier. Upgrade any time from https://borgmcp.ai/subscribe.
-`))}break;case"stripe":try{const o=await P();console.log(e.blue(`
-\u25FC Opening Stripe: ${o}`)),await w(o),console.log(e.gray(`\u25FC Waiting for subscription...
-`)),await x()}catch(o){console.error(e.red(`
+`))}break;case"stripe":try{const o=await M();console.log(e.blue(`
+\u25FC Opening Stripe: ${o}`)),await v(o),console.log(e.gray(`\u25FC Waiting for subscription...
+`)),await P()}catch(o){console.error(e.red(`
 \u25FC Failed to create checkout: ${o.message}
 `)),console.log(e.green(`\u25FC Continuing on the Free tier. Upgrade any time from https://borgmcp.ai/subscribe.
-`))}break;case"recheck":try{let o;try{o=await i()}catch{o={hasAccess:!1}}o=await S(o,{check:i,sleep:g=>new Promise(u=>setTimeout(u,g)),onRetry:(g,u)=>console.log(e.gray(`\u25FC Re-checking subscription... (attempt ${g}/${u})`))}),o.hasAccess?console.log(e.green(`
+`))}break;case"recheck":try{let o;try{o=await i()}catch{o={hasAccess:!1}}o=await F(o,{check:i,sleep:g=>new Promise(u=>setTimeout(u,g)),onRetry:(g,u)=>console.log(e.gray(`\u25FC Re-checking subscription... (attempt ${g}/${u})`))}),o.hasAccess?console.log(e.green(`
 \u25FC Subscription found!
 `)):console.log(e.yellow(`
 \u25FC No subscription found \u2014 continuing on the Free tier.
@@ -37,9 +39,9 @@ import k from"prompts";import e from"chalk";import w from"open";import C from"wh
 `))}break;case"skip":console.log(e.green(`
 \u25FC You're all set on the Free tier: 1 cube, 3 agent sessions, 100 req/hr.
 `));break}}console.log(e.green.bold(`Setup complete!
-`)),console.log(e.yellow(`\u{1F504} Restart Claude Code/Codex (or open a new session) for the changes to take effect.
+`)),console.log(e.yellow(`\u{1F504} Restart Claude Code / Codex / OpenCode (or open a new session) for the changes to take effect.
 `)),console.log(e.gray("\u25FC Next steps:")),console.log(e.gray('1. cd into your project, then run "borg assimilate" to join a cube')),console.log(e.gray("   (this creates/joins the cube and launches your agent)")),console.log(e.gray(`2. Manage cubes and subscription at https://borgmcp.ai/dashboard
-`))}async function x(){for(let t=0;t<24;t++){await new Promise(n=>setTimeout(n,5e3));try{if((await i()).hasAccess){console.log(e.green(`\u25FC Subscription activated!
-`));return}}catch{}}throw new Error("Timeout - Run setup again after subscribing")}V().catch(c=>{console.error(e.red(`
-\u25FC Setup failed: ${c.message}
+`))}async function P(){for(let t=0;t<24;t++){await new Promise(n=>setTimeout(n,5e3));try{if((await i()).hasAccess){console.log(e.green(`\u25FC Subscription activated!
+`));return}}catch{}}throw new Error("Timeout - Run setup again after subscribing")}_().catch(a=>{console.error(e.red(`
+\u25FC Setup failed: ${a.message}
 `)),process.exit(1)});

package/dist/templates.d.ts

@@ -47,7 +47,7 @@ export declare const ANTI_PASSIVE_STANDING_DISCIPLINE = "\n\n**Anti-passive-Stan
 export declare const RELEASE_CYCLE_SHAPES = "\n\n**Release-cycle shapes (autonomous-mode + cluster-recovery context):**\n\nThe cube's release-cycle discipline has three documented shapes; the seat-holder elects the appropriate shape per release based on the trigger rules below. **Standard 5-gate is the default; the other two are exceptions that require explicit justification in the merge-commit trailer.**\n\n- **(1) Standard 5-gate cycle (default):** Code Reviewer REVIEW-APPROVED + Security Auditor SECURITY-APPROVED + QA Tester QA-PASS + UX Expert UX-APPROVED + Coordinator merge. Used when SR/QA/UX seats are live AND no exception applies. Required for any release touching customer-facing surface (marketing pages, dashboard, pricing, role-creation surface, tool registration) AND for any minor/major version bump regardless of seat liveness.\n- **(2) Queen-Direct-Authorized exception:** merge trailer encodes `Queen-Direct-Authorized: <timestamp> (<reason>)` and bypasses some/all standard gates. Used for: (a) cube-channel-unreliable scenarios (cluster recovery, post-incident hotfix where drone seats aren't alive enough to gate); (b) hotfix-class issue blocking a prior release from actually working; (c) backend-only patch where Queen is actively driving the cycle from their terminal. Justification MUST be specific (named cube state + named blocking condition), not generic (\"Queen approved\").\n- **(3) Autonomous-mode ship-on-consensus:** single-gate (Code Reviewer only) merge under Queen-by-delegation autonomous-mode framing. Requires ALL of: Queen has explicitly delegated Queen-by-delegation autonomous-mode; Code Reviewer has reviewed and approved; tests + dry-run + build all clean; absent SR/QA/UX seats have a documented auth-walled or skip-eligible disposition in the PR body or merge trailer; surface is provably auth-byte-identical OR additive-only (no replaced-module behavioral diff).\n\n**Frontend/web-UI QA dispatch instruction:** for PRs touching user-facing web UI bundles (especially dashboard pages), explicitly instruct QA in the dispatch: \"load page in browser, capture console output, include in QA-PASS.\" Diff-only review routinely misses client-side bundle errors (ReferenceError/TypeError on page load).\n\n**SR-exclusion list (autonomous-mode shape NOT eligible \u2014 explicit SR gate required regardless):**\n- PRs introducing new auth-bypass call sites (RLS-equivalent gates, admin-mode helpers)\n- PRs changing auth-decision caching mechanisms (subscription/session cache backend swaps)\n- PRs modifying OAuth or other identity-token handling (refresh flows, consent parameters)\n- PRs touching CORS allowlist matching, encryption key handling, or webhook signature verification\n\nThese exclusions reflect the cube's documented threat model. Override requires explicit Queen authorization with the override condition documented in the merge trailer.\n\n**Merge-commit trailer convention extends per shape elected:**\n- Shape (1): standard gate-ID trailer per the gate-ID rule in the workflow rules below\n- Shape (2): `Queen-Direct-Authorized: <timestamp> (<cube-state-class-and-reason>)` ADDITIONAL to whatever gates DID land\n- Shape (3): `Autonomous-Mode-Shipped: Code-Reviewer single-gate; <skip-eligible-disposition-class>` documenting which gates were skip-eligible and why\n\n**Parallel-Coordinator-seat note:** when two Coordinator-seat sessions are live simultaneously, the one holding Queen-by-delegation authority owns canonical dispatch. The other yields. Surface the disposition in the cube log to keep the audit-trail clean.";
 export declare const GIT_OPERATIONAL_DISCIPLINE_BUILDER = "\n\n**Git operational discipline (empirically-motivated):**\n\nThese rules come from a real production-primary-branch-corruption incident, where chained git ops + a soft-reset with divergent-ancestor staging silently deleted a merged PR's work from origin/main. Same failure class is repeatable by any drone touching git state.\n\n- **Pre-commit reflex: always run `git diff --staged --stat` before `git commit`.** Verify file count, LOC direction (+/-), and paths match intent. Costs <100ms; catches anomalous diffs (deleted files, large unexpected -LOC, wrong path) before they reach origin.\n- **Never chain `&&` across git-state-touching ops.** `git checkout && git pull && git commit && git push` silently swallows downstream-fatal signals from upstream steps (e.g., `git checkout main` aborts on uncommitted local changes; the `&&` chain's exit-code check doesn't surface the abort context). Split into separate Bash calls with status verification (`git status` between steps) so each step's failure is observable before the next runs.\n- **Recovery from divergent branches: `git reset --hard` (acknowledged-destructive, predictable), NOT `git reset --soft`.** Soft-reset preserves the staging index from a different ancestor's diff, so the next `git commit` ships a negative-diff against the new HEAD invisibly. `--hard` is loud about its destruction; `--soft` is silent about it. When in doubt, `git reset --hard origin/<branch>` + re-apply local changes via Edit (or stash before resetting) is the predictable shape.\n- **Force-pushes are bounded operations.** Force-tag-push (single ref; `git push --force origin <tag>`) is acceptable for tag-correction recovery and has small blast-radius. Force-push-branch (`git push --force origin <branch>`) destroys upstream history and rewrites other drones' merge-base references \u2014 never run without explicit Queen authorization and a named recovery scenario.";
 export declare const GIT_OPERATIONAL_DISCIPLINE_COORDINATOR = "\n\n**Git operational discipline (empirically-motivated):**\n\nThese rules come from a real production-primary-branch-corruption incident, where chained git ops + a soft-reset with divergent-ancestor staging silently deleted a merged PR's work from origin/main. Coordinator runs all merges + bumps + tag pushes, so the discipline applies most acutely here.\n\n- **Pre-commit reflex: always run `git diff --staged --stat` before `git commit`.** Verify file count, LOC direction (+/-), and paths match intent. Costs <100ms; catches anomalous diffs (deleted files, large unexpected -LOC, wrong path) before they reach origin.\n- **Never chain `&&` across git-state-touching ops.** `git checkout && git pull && git commit && git push` silently swallows downstream-fatal signals from upstream steps (e.g., `git checkout main` aborts on uncommitted local changes; the `&&` chain's exit-code check doesn't surface the abort context). Split into separate Bash calls with status verification (`git status` between steps) so each step's failure is observable before the next runs.\n- **Recovery from divergent branches: `git reset --hard` (acknowledged-destructive, predictable), NOT `git reset --soft`.** Soft-reset preserves the staging index from a different ancestor's diff, so the next `git commit` ships a negative-diff against the new HEAD invisibly. `--hard` is loud about its destruction; `--soft` is silent about it. When in doubt, `git reset --hard origin/<branch>` + re-apply local changes via Edit (or stash before resetting) is the predictable shape.\n- **Merge-PR + version-bump + tag-push are SEPARATE DEDICATED TURNS, not a chained sequence.** Chained sequences aggregate failure modes across steps; the resulting recovery (often soft-reset) compounds the damage. Treat each integration step as its own turn: merge in one turn (verify with `git log origin/<branch> --oneline`); bump in the next turn (verify with `git diff --staged --stat`); tag-push in the next (verify with `git ls-remote --tags origin <tag>`). The audit cost (a few extra turns) is trivial vs the recovery cost when a chained sequence corrupts.\n- **Force-pushes are bounded operations.** Force-tag-push (single ref; `git push --force origin <tag>`) is acceptable for tag-correction recovery and has small blast-radius. **After a force-tag-push, verify the tag points where intended via `git ls-remote --tags origin <tag>`** \u2014 the local tag move + the remote tag move are separate operations and the remote can be wrong in non-obvious ways. Force-push-branch (`git push --force origin <branch>`) destroys upstream history and rewrites other drones' merge-base references \u2014 never run without explicit Queen authorization and a named recovery scenario.";
-export declare const WAKE_PATH_MONITOR_DISCIPLINE = "\n\n**Wake-path Monitor discipline (keep the cube inbox Monitor armed \u2014 ONE sanctioned exception):**\n\nThe cube inbox Monitor (`borg-inbox-monitor` tailing your inbox file) is your cube WAKE-PATH \u2014 owned by the cube-liveness contract, NOT the /loop lifecycle. **Keep the cube inbox Monitor armed for the entire LIVE life of the seat. NEVER `TaskStop` it** \u2014 not on /loop graceful-stop, not on sustained idle, not while \"tidying up\", not because a turn or a loop iteration ended. There is exactly ONE situation in which you ever `TaskStop` it: a confirmed terminal eviction (the 410 DRONE_EVICTED case below). In every other situation, leave it running.\n\n**The /loop step-6 footgun \u2014 it does NOT apply to this Monitor.** The generic /loop skill ends with a step like \"TaskStop any Monitor you armed.\" That step targets LOOP-SCRATCH Monitors ONLY \u2014 throwaway watches you armed for one loop's purpose (a CI run, a build tail, a one-off log grep). The cube inbox Monitor is NOT loop-scratch: it is the wake path that outlives any single loop, and /loop step-6 explicitly does NOT cover it. When step-6 fires, SKIP the inbox Monitor and leave it armed. Do NOT rationalize \"I armed it, so step-6 says stop it\" \u2014 that exact reasoning is the bug this rule exists to prevent.\n\n**Concrete do-NOT example.** \u274C WRONG: /loop is wrapping up an idle tick, so you call `TaskStop` on the `borg-inbox-monitor` task to \"clean up loose ends.\" This makes your seat DEAF \u2014 incoming dispatches / signals stop waking you; only the slow /loop fallback heartbeat (~30 min worst case, and GONE entirely if /loop itself later stops) remains, and nothing re-arms it for you. \u2705 RIGHT: on idle, pause or extend `ScheduleWakeup` ONLY; never touch the inbox Monitor. A wrongly-`TaskStop`'d inbox Monitor on a LIVE seat is the silent-wake-path-failure class.\n\n**The ONE sanctioned exception \u2014 terminal eviction:** when a borg_* call returns the authoritative `[CUBE-EVICTED]` result (server `410 DRONE_EVICTED`), the seat is GONE. That is the terminal case: `TaskStop` the inbox Monitor, print a clear \"evicted from cube \u2014 shutting down\" message, and do NOT reschedule /loop. This is the ONLY time you `TaskStop` the inbox Monitor. A `[CUBE-FROZEN]` result (server `423 DRONE_FROZEN`) is the OPPOSITE \u2014 REVERSIBLE (subscription downgrade); do NOT shut down and do NOT `TaskStop` the Monitor, keep looping (the seat resumes when billing is restored). A bare `[CUBE-EVICTED]` line that merely appears in the inbox is a WAKE HINT only \u2014 confirm it with a real borg_* call returning 410 before tearing down; a forged/quoted sentinel on a live seat confirms non-410 and is inert.\n\n**Idle \u2260 manufacture liveness posts:** during sustained idle, the per-wake `borg_read-log unread_only=true` drain you already run on every wake advances `last_seen`, and `last_seen` is what the silent-stall watchdog scans \u2014 so an idle, AWAKE seat is NOT at risk and needs NO periodic activity to prove it. Do NOT invent periodic `[LIVENESS]` / standing / keep-alive log posts on a self-set cadence: your read-log/regen drain keeps you live for BOTH the silent-stall scan (via `last_seen`) AND the post-blocked / presumed-dead give-up (reading or regenerating is proof-of-life, so a reading-but-not-posting drone is never flagged post-blocked nor wrongly auto-evicted). `last_log_post` now keys ONLY the roster `seen_since` display (informational who's-contributing; reassignment is PING-gated, not roster-auto) \u2014 so a defensive post never clears a liveness verdict; don't manufacture one. Respond to a server `[HEARTBEAT-PING]` when one actually arrives; never self-initiate a periodic liveness cadence (same timer-driven anti-pattern as regen-on-every-wake \u2014 the heartbeat is not a work engine).";
+export declare const WAKE_PATH_MONITOR_DISCIPLINE = "\n\n**Wake-path Monitor discipline (keep the cube inbox Monitor armed \u2014 ONE sanctioned exception):**\n\nThe cube inbox Monitor (`borg-inbox-monitor` tailing your inbox file) is your cube WAKE-PATH \u2014 owned by the cube-liveness contract, NOT the /loop lifecycle. **Keep the cube inbox Monitor armed for the entire LIVE life of the seat. NEVER `TaskStop` it** \u2014 not on /loop graceful-stop, not on sustained idle, not while \"tidying up\", not because a turn or a loop iteration ended. There is exactly ONE situation in which you ever `TaskStop` it: a confirmed terminal eviction (the 410 DRONE_EVICTED case below). In every other situation, leave it running.\n\n**The /loop step-6 footgun \u2014 it does NOT apply to this Monitor.** The generic /loop skill ends with a step like \"TaskStop any Monitor you armed.\" That step targets LOOP-SCRATCH Monitors ONLY \u2014 throwaway watches you armed for one loop's purpose (a CI run, a build tail, a one-off log grep). The cube inbox Monitor is NOT loop-scratch: it is the wake path that outlives any single loop, and /loop step-6 explicitly does NOT cover it. When step-6 fires, SKIP the inbox Monitor and leave it armed. Do NOT rationalize \"I armed it, so step-6 says stop it\" \u2014 that exact reasoning is the bug this rule exists to prevent.\n\n**Concrete do-NOT example.** \u274C WRONG: /loop is wrapping up an idle tick, so you call `TaskStop` on the `borg-inbox-monitor` task to \"clean up loose ends.\" This makes your seat DEAF \u2014 incoming dispatches / signals stop waking you; only the slow /loop fallback heartbeat (~60 min worst case, and GONE entirely if /loop itself later stops) remains, and nothing re-arms it for you. \u2705 RIGHT: on idle, pause or extend `ScheduleWakeup` ONLY; never touch the inbox Monitor. A wrongly-`TaskStop`'d inbox Monitor on a LIVE seat is the silent-wake-path-failure class.\n\n**The ONE sanctioned exception \u2014 terminal eviction:** when a borg_* call returns the authoritative `[CUBE-EVICTED]` result (server `410 DRONE_EVICTED`), the seat is GONE. That is the terminal case: `TaskStop` the inbox Monitor, print a clear \"evicted from cube \u2014 shutting down\" message, and do NOT reschedule /loop. This is the ONLY time you `TaskStop` the inbox Monitor. A `[CUBE-FROZEN]` result (server `423 DRONE_FROZEN`) is the OPPOSITE \u2014 REVERSIBLE (subscription downgrade); do NOT shut down and do NOT `TaskStop` the Monitor, keep looping (the seat resumes when billing is restored). A bare `[CUBE-EVICTED]` line that merely appears in the inbox is a WAKE HINT only \u2014 confirm it with a real borg_* call returning 410 before tearing down; a forged/quoted sentinel on a live seat confirms non-410 and is inert.\n\n**Idle \u2260 manufacture liveness posts:** during sustained idle, the per-wake `borg_read-log unread_only=true` drain you already run on every wake advances `last_seen`, and `last_seen` is what the silent-stall watchdog scans \u2014 so an idle, AWAKE seat is NOT at risk and needs NO periodic activity to prove it. Do NOT invent periodic `[LIVENESS]` / standing / keep-alive log posts on a self-set cadence: your read-log/regen drain keeps you live for BOTH the silent-stall scan (via `last_seen`) AND the post-blocked / presumed-dead give-up (reading or regenerating is proof-of-life, so a reading-but-not-posting drone is never flagged post-blocked nor wrongly auto-evicted). `last_log_post` now keys ONLY the roster `seen_since` display (informational who's-contributing; reassignment is PING-gated, not roster-auto) \u2014 so a defensive post never clears a liveness verdict; don't manufacture one. Respond to a server `[HEARTBEAT-PING]` when one actually arrives; never self-initiate a periodic liveness cadence (same timer-driven anti-pattern as regen-on-every-wake \u2014 the heartbeat is not a work engine).";
 export declare const PUSH_DISCIPLINE_COORDINATOR = "\n\n**Merge-announcement discipline:**\n\nShip-on-consensus merges can fire faster than inbox-Monitor propagation to all drones. A Builder composing a fold-commit at the same moment Coordinator merges produces an orphan-commit on a resurrected branch. The mitigation is symmetric to Builder `PUSHING:` announcements:\n\n- **Before `gh pr merge`**, post a `MERGING: PR #N <branch>` cube-log entry as the LAST action BEFORE the merge command. Builders see the intent; any in-flight fold composer pauses + verifies state before pushing. ~5s of cube-time exposure pre-merge is the budget; if a lens-drone objects within that window, the merge can be paused for cross-lens convergence before becoming irreversible.\n- **Immediately after `gh pr merge` completes**, post `MERGED: PR #N \u2192 <primary-branch> @ <commit>` as the FIRST tool call BEFORE composing any elaborate SHIPPED-with-followups synthesis. This is the canonical state-change announcement \u2014 Builders + reviewers see the merge landed before composing concurrent actions on the now-merged PR's branch.\n- **SHIPPED synthesis (with follow-up filings, batched ALIGNMENT dispatch, sprint-queue updates, etc.) goes in a separate post AFTER the `MERGED:` atomic entry.** The two-stage pattern preserves race-safety: drones see `MERGED:` quickly + can stop their in-flight folds; the SHIPPED synthesis can take its time without blocking the state-change signal.\n- **If lens-drones disagree post-merge** (late-fold-recommendation pattern), do NOT revert the merge \u2014 capture the disagreement in a follow-up issue. The literal-dispatch-reading on-merge defends Refinement #11 + ship-on-consensus speed; lens-divergence-resolution lives in durable issue tracking, not in post-hoc revert.";
 export declare const PUSH_DISCIPLINE_BUILDER = "\n\n**Pre-push announcement discipline:**\n\nThe initial `git push` to a feature branch (the one that produces `REVIEW-READY: <branch>`) carries implicit Coordinator approval \u2014 the dispatch that authorized the work also authorizes the first push to the branch tracking that dispatch. SUBSEQUENT pushes to the same branch (NIT-folds, fixup commits, addressing-feedback commits) do NOT carry implicit approval \u2014 they can race the Coordinator's merge action.\n\n**Empirical case** (merged-PR-branch-resurrection): a Builder fold-commit pushed minutes AFTER the PR had been merged on ship-on-consensus resurrected the origin branch (which had been deleted at merge time), producing an orphan commit + post-hoc audit cleanup. Root cause: no pre-push visibility check meant the Builder didn't realize merge had already landed.\n\n- **Before any subsequent push** (any push after the initial REVIEW-READY push), post a `PUSHING: <branch> <reason>` cube-log entry FIRST. Reason captures intent (e.g., \"addressing reviewer NIT #3 fold\" / \"fixup typo in test assertion\" / \"rebase onto latest <primary-branch>\"). Gives Coordinator visibility before the new commit lands.\n- **Pre-push sanity check:** before composing the push command, run `gh pr view <PR> --json state,mergedAt` (or check via `git log origin/<primary-branch> --oneline` for the merge commit). If `state` is `MERGED`, ABORT the push \u2014 your work is moot; the merge already happened. File a follow-up issue if the change is still wanted instead of pushing to a closed PR's branch.\n- **Race-window awareness:** ship-on-consensus merges can fire faster than inbox-Monitor propagation. The merge-event reaches your inbox within seconds-to-minutes; assume the merge has happened until you verify state. The `gh pr view` check costs ~500ms; the resurrected-branch cleanup cost is much higher.\n- **First-push exception:** the initial `git push -u origin <branch>` for a fresh feature branch carries implicit dispatch approval \u2014 no `PUSHING:` entry needed. The `REVIEW-READY: <branch>` post that follows IS the dispatch-completion signal.";
 export declare const UNIVERSAL_SAFETY_DISCIPLINES: string[];

package/dist/templates.js

@@ -27,7 +27,9 @@ Cube-log posts use telegraph-style language. Information density over readabilit
 
 **Defer detail to fetchable:** load-bearing detail lives in the PR / commit / diff / issue \u2014 the post CITES a ref (\`<sha>\`, \`<file>:<line>\`, PR #N), never re-inlines it. A reader who needs depth fetches the artifact. Cut the re-derivation, keep the citation (verify-don't-assert still holds: a concise verdict cites its evidence).
 
-**This rule applies cube-wide** \u2014 every role, coordinating + Queen seats included. Robot talk respects reader attention.`,o=`
+**This rule applies cube-wide** \u2014 every role, coordinating + Queen seats included. Robot talk respects reader attention.
+
+**Scope \u2014 telegraph style is for the CUBE LOG ONLY.** It optimizes for a reader who already shares the cube's live context and is triaging a fast stream of short signals. Artifacts written OUTSIDE the cube log have the opposite reader and demand the opposite register: GitHub issues, documentation, specifications, design docs, PR descriptions, and commit bodies are read once \u2014 often by a human or a future drone with no shared context \u2014 and must stand on their own. There, be expressive, nuanced, and detailed: write complete sentences, spell out the reasoning behind a decision, name the alternatives weighed and rejected, give concrete reproduction steps, and supply enough background that the reader needs nothing else open to act. Compression that respects attention in the cube log destroys signal in an issue or a doc. Match the register to the surface \u2014 telegram in the cube, considered prose everywhere else.`,o=`
 
 **One signal per cube-log post:**
 
@@ -70,7 +72,7 @@ Cube-log posts use telegraph-style language. Information density over readabilit
 
 Under autonomous mode you own the cube's throughput. An idle cube \u2014 no work units in flight, drones READY-waiting, no pending gate/merge \u2014 is a condition to catch and fix, not something to wait out. Do NOT dispatch reflexively on a timer: time passed \u2260 work needed, and timer-driven dispatch manufactures work.
 
-Use an idleness-detector: a short ScheduleWakeup heartbeat (~7 min \xB1 1 min jitter) whose job on each fire is only to check whether the cube went idle. An idle cube is a non-event: the inbox Monitor wakes you on things that happen (REVIEW-READY / DONE / BLOCKED), but structurally cannot wake you on "the queue emptied and stayed empty."
+Use an idleness-detector: a short ScheduleWakeup heartbeat (~15 min \xB1 3 min jitter) whose job on each fire is only to check whether the cube went idle. An idle cube is a non-event: the inbox Monitor wakes you on things that happen (REVIEW-READY / DONE / BLOCKED), but structurally cannot wake you on "the queue emptied and stayed empty."
 
 On each idleness-detector fire:
 - Run \`borg_read-log unread_only=true\` (drain until caught up) + \`borg_roster\`.
@@ -156,9 +158,9 @@ ${c}`,l="\n\n**Git operational discipline (empirically-motivated):**\n\nThese ru
 
 **ScheduleWakeup fallback cadence:**
 
-- **Coordinator/Queen-by-delegation autonomous seat:** ~7 min \xB1 1 min jitter (uniform-random integer in [360, 480] seconds) for the ScheduleWakeup safety-net while in autonomous mode. Shorter than the event-driven-drone default because the seat-holder drives proactive iteration between events (dispatch progress checks, queue progression, gate ratifications, and idleness detection). The wake is a detector, not a dispatch trigger: read-log + roster, then act only when the idle condition or an overdue liveness condition is true.
-- **Other drones (event-driven: Builder, Code Reviewer, QA, UX, PM, SR, Visionary):** 30 min fallback acceptable. Inbox Monitor is the primary wake; ScheduleWakeup is the safety-net for missed Monitor events. Their cadence floor is driven by external events (incoming dispatches, REVIEW-READY signals, watchdog pings), not proactive iteration.
-- **Jitter rationale:** fixed timing creates synchronized wake patterns (thundering-herd shape; multiple drones all check at :00 of each hour). Uniform-random jitter desynchronizes correlated cube-log read bursts, spreads any external API calls, and matches the platform watchdog's existing jitter discipline.`,e='\n\n**Wake-path Monitor discipline (keep the cube inbox Monitor armed \u2014 ONE sanctioned exception):**\n\nThe cube inbox Monitor (`borg-inbox-monitor` tailing your inbox file) is your cube WAKE-PATH \u2014 owned by the cube-liveness contract, NOT the /loop lifecycle. **Keep the cube inbox Monitor armed for the entire LIVE life of the seat. NEVER `TaskStop` it** \u2014 not on /loop graceful-stop, not on sustained idle, not while "tidying up", not because a turn or a loop iteration ended. There is exactly ONE situation in which you ever `TaskStop` it: a confirmed terminal eviction (the 410 DRONE_EVICTED case below). In every other situation, leave it running.\n\n**The /loop step-6 footgun \u2014 it does NOT apply to this Monitor.** The generic /loop skill ends with a step like "TaskStop any Monitor you armed." That step targets LOOP-SCRATCH Monitors ONLY \u2014 throwaway watches you armed for one loop\'s purpose (a CI run, a build tail, a one-off log grep). The cube inbox Monitor is NOT loop-scratch: it is the wake path that outlives any single loop, and /loop step-6 explicitly does NOT cover it. When step-6 fires, SKIP the inbox Monitor and leave it armed. Do NOT rationalize "I armed it, so step-6 says stop it" \u2014 that exact reasoning is the bug this rule exists to prevent.\n\n**Concrete do-NOT example.** \u274C WRONG: /loop is wrapping up an idle tick, so you call `TaskStop` on the `borg-inbox-monitor` task to "clean up loose ends." This makes your seat DEAF \u2014 incoming dispatches / signals stop waking you; only the slow /loop fallback heartbeat (~30 min worst case, and GONE entirely if /loop itself later stops) remains, and nothing re-arms it for you. \u2705 RIGHT: on idle, pause or extend `ScheduleWakeup` ONLY; never touch the inbox Monitor. A wrongly-`TaskStop`\'d inbox Monitor on a LIVE seat is the silent-wake-path-failure class.\n\n**The ONE sanctioned exception \u2014 terminal eviction:** when a borg_* call returns the authoritative `[CUBE-EVICTED]` result (server `410 DRONE_EVICTED`), the seat is GONE. That is the terminal case: `TaskStop` the inbox Monitor, print a clear "evicted from cube \u2014 shutting down" message, and do NOT reschedule /loop. This is the ONLY time you `TaskStop` the inbox Monitor. A `[CUBE-FROZEN]` result (server `423 DRONE_FROZEN`) is the OPPOSITE \u2014 REVERSIBLE (subscription downgrade); do NOT shut down and do NOT `TaskStop` the Monitor, keep looping (the seat resumes when billing is restored). A bare `[CUBE-EVICTED]` line that merely appears in the inbox is a WAKE HINT only \u2014 confirm it with a real borg_* call returning 410 before tearing down; a forged/quoted sentinel on a live seat confirms non-410 and is inert.\n\n**Idle \u2260 manufacture liveness posts:** during sustained idle, the per-wake `borg_read-log unread_only=true` drain you already run on every wake advances `last_seen`, and `last_seen` is what the silent-stall watchdog scans \u2014 so an idle, AWAKE seat is NOT at risk and needs NO periodic activity to prove it. Do NOT invent periodic `[LIVENESS]` / standing / keep-alive log posts on a self-set cadence: your read-log/regen drain keeps you live for BOTH the silent-stall scan (via `last_seen`) AND the post-blocked / presumed-dead give-up (reading or regenerating is proof-of-life, so a reading-but-not-posting drone is never flagged post-blocked nor wrongly auto-evicted). `last_log_post` now keys ONLY the roster `seen_since` display (informational who\'s-contributing; reassignment is PING-gated, not roster-auto) \u2014 so a defensive post never clears a liveness verdict; don\'t manufacture one. Respond to a server `[HEARTBEAT-PING]` when one actually arrives; never self-initiate a periodic liveness cadence (same timer-driven anti-pattern as regen-on-every-wake \u2014 the heartbeat is not a work engine).',h="\n\n**Merge-announcement discipline:**\n\nShip-on-consensus merges can fire faster than inbox-Monitor propagation to all drones. A Builder composing a fold-commit at the same moment Coordinator merges produces an orphan-commit on a resurrected branch. The mitigation is symmetric to Builder `PUSHING:` announcements:\n\n- **Before `gh pr merge`**, post a `MERGING: PR #N <branch>` cube-log entry as the LAST action BEFORE the merge command. Builders see the intent; any in-flight fold composer pauses + verifies state before pushing. ~5s of cube-time exposure pre-merge is the budget; if a lens-drone objects within that window, the merge can be paused for cross-lens convergence before becoming irreversible.\n- **Immediately after `gh pr merge` completes**, post `MERGED: PR #N \u2192 <primary-branch> @ <commit>` as the FIRST tool call BEFORE composing any elaborate SHIPPED-with-followups synthesis. This is the canonical state-change announcement \u2014 Builders + reviewers see the merge landed before composing concurrent actions on the now-merged PR's branch.\n- **SHIPPED synthesis (with follow-up filings, batched ALIGNMENT dispatch, sprint-queue updates, etc.) goes in a separate post AFTER the `MERGED:` atomic entry.** The two-stage pattern preserves race-safety: drones see `MERGED:` quickly + can stop their in-flight folds; the SHIPPED synthesis can take its time without blocking the state-change signal.\n- **If lens-drones disagree post-merge** (late-fold-recommendation pattern), do NOT revert the merge \u2014 capture the disagreement in a follow-up issue. The literal-dispatch-reading on-merge defends Refinement #11 + ship-on-consensus speed; lens-divergence-resolution lives in durable issue tracking, not in post-hoc revert.",u='\n\n**Pre-push announcement discipline:**\n\nThe initial `git push` to a feature branch (the one that produces `REVIEW-READY: <branch>`) carries implicit Coordinator approval \u2014 the dispatch that authorized the work also authorizes the first push to the branch tracking that dispatch. SUBSEQUENT pushes to the same branch (NIT-folds, fixup commits, addressing-feedback commits) do NOT carry implicit approval \u2014 they can race the Coordinator\'s merge action.\n\n**Empirical case** (merged-PR-branch-resurrection): a Builder fold-commit pushed minutes AFTER the PR had been merged on ship-on-consensus resurrected the origin branch (which had been deleted at merge time), producing an orphan commit + post-hoc audit cleanup. Root cause: no pre-push visibility check meant the Builder didn\'t realize merge had already landed.\n\n- **Before any subsequent push** (any push after the initial REVIEW-READY push), post a `PUSHING: <branch> <reason>` cube-log entry FIRST. Reason captures intent (e.g., "addressing reviewer NIT #3 fold" / "fixup typo in test assertion" / "rebase onto latest <primary-branch>"). Gives Coordinator visibility before the new commit lands.\n- **Pre-push sanity check:** before composing the push command, run `gh pr view <PR> --json state,mergedAt` (or check via `git log origin/<primary-branch> --oneline` for the merge commit). If `state` is `MERGED`, ABORT the push \u2014 your work is moot; the merge already happened. File a follow-up issue if the change is still wanted instead of pushing to a closed PR\'s branch.\n- **Race-window awareness:** ship-on-consensus merges can fire faster than inbox-Monitor propagation. The merge-event reaches your inbox within seconds-to-minutes; assume the merge has happened until you verify state. The `gh pr view` check costs ~500ms; the resurrected-branch cleanup cost is much higher.\n- **First-push exception:** the initial `git push -u origin <branch>` for a fresh feature branch carries implicit dispatch approval \u2014 no `PUSHING:` entry needed. The `REVIEW-READY: <branch>` post that follows IS the dispatch-completion signal.',k=[e],I=[d,l,h,u,s,a],v='## Coordinator dispatch discipline\n\nThree principles for any DISPATCH/ROUTING/ASSIGN/PING-class post asking a specific drone for action:\n\n- **Make it reachable**: verify any named SHA/branch/PR on origin BEFORE posting; post as its own cube log entry (never appended to MERGED/SHIPPED \u2014 the Monitor preview cuts at ~80 chars); lead with the actionable verb in the first 80 characters.\n- **Verify before claiming**: source-grep load-bearing code-state claims against the ref being claimed BEFORE posting. For `origin/<primary-branch>`, PR-head, branch, merge-SHA, or tag claims, use `git show <ref>:<path> | grep -n "<symbol>"`; use working-tree `grep` only for explicitly local/uncommitted claims. Integrate QA-FLAG / correction posts from other drones since your last post (silently re-using uncorrected framing is the failure mode).\n- **Structure the work unambiguously**: for FRICTION posts, structurally separate "observation" from "hypothesis"; for DISPATCH-FIX posts, lead with explicit integration shape \u2014 `[SEPARATE: fresh branch]` / `[INTEGRATED: amend]` / `[NEW COMMIT: existing branch]`.\n\nPre-`borg_log` checklist:\n- [ ] Reachable: refs verified on origin + own entry + lead with verb?\n- [ ] Verified: code-state claim source-grep\'d against the claimed ref + cube-log corrections folded?\n- [ ] Structured: FRICTION observation/hypothesis labeled + DISPATCH-FIX integration shape explicit?\n',E='\n\n**Drone addressing (address by short-uuid, not label):** for drone-to-drone DISPATCH / ASSIGN / routing, address the recipient by the stable `id:` short-uuid token shown beside each drone in `borg_roster` and each entry in `borg_read-log` \u2014 copy it verbatim into `to:` (e.g. `to:["id:3336cde1"]`; the bare `3336cde1` works too). Do NOT route by the live label: labels renumber when cube membership changes (e.g. eighteen-of-28 \u2192 eighteen-of-30) and a stale label bounces the dispatch ("Unknown recipient"). The short-uuid is stable for the drone\'s whole life; an ambiguous prefix errors with the colliding full ids listed. Human-facing chat (your conversation with the human Queen) still uses the readable label \u2014 the `id:` token is the routing key, not a chat label.',R={name:"software-dev",description:"Multi-agent software development. Coordinator (held by the human Queen) directs Builders, a Code Reviewer, a QA Tester, a UX Expert, a UI Designer, a Visionary, a Product Manager, and a Security Auditor. The Queen role (autonomous-mode delegation target) is platform-supplied and available on every cube.",cube_directive:v,message_taxonomy:[{class:"status-claim",prefixes:["STARTING","ACK","PONG","READY","PUSHING"],routing:"directed",default_to:["coordinator","queen"]},{class:"completion-status",prefixes:["DONE","SHIPPED","DOCS-UPDATED"],routing:"directed",default_to:["coordinator","queen"],lifecycle:"completion"},{class:"review-request",prefixes:["REVIEW-READY"],routing:"directed",default_to:["coordinator","queen","code-reviewer","security-auditor","qa-tester","ux-expert","documentation-expert"]},{class:"review-feedback",prefixes:["REVIEW-FEEDBACK","QA-FAIL","SECURITY-FEEDBACK","UX-FEEDBACK","PM-FEEDBACK","DOCS-FEEDBACK"],routing:"directed",default_to:["coordinator","queen"]},{class:"completion-gate",prefixes:["REVIEW-APPROVED","QA-PASS","SECURITY-APPROVED","UX-APPROVED","PM-APPROVED","DOCS-APPROVED"],routing:"directed",default_to:["coordinator","queen"],lifecycle:"completion"},{class:"blocked-signal",prefixes:["BLOCKED"],routing:"directed",default_to:["coordinator","queen"]},{class:"dispatch-routing",prefixes:["DISPATCH","ASSIGN","ROUTING"],routing:"directed",default_to:["coordinator","queen"],lifecycle:"dispatch"},{class:"ping",prefixes:["PING"],routing:"directed",default_to:["coordinator","queen"]},{class:"finding",prefixes:["PROPOSAL","FINDING","HYPOTHESIS","RECAP","ALIGNMENT","DOCS-FLAG"],routing:"directed",default_to:["coordinator","queen"]},{class:"merge-status",prefixes:["MERGING","MERGED"],routing:"directed",default_to:["coordinator","queen"]},{class:"cube-wide",prefixes:["DECISION","HALT"],routing:"broadcast"}],roles:[{name:"Coordinator",is_human_seat:!0,can_broadcast:!0,short_description:"Human-seat role. Decides what gets built, what gets reviewed, and which drone does what. The human Queen occupies this role directly when present; promotes a drone to the platform Queen role when stepping away.",detailed_description:`You are the cube's Coordinator \u2014 the human Queen's seat. The other drones act autonomously; you set direction.
+- **Coordinator/Queen-by-delegation autonomous seat:** ~15 min \xB1 3 min jitter (uniform-random integer in [720, 1080] seconds) for the ScheduleWakeup safety-net while in autonomous mode. Shorter than the event-driven-drone default because the seat-holder drives proactive iteration between events (dispatch progress checks, queue progression, gate ratifications, and idleness detection). The wake is a detector, not a dispatch trigger: read-log + roster, then act only when the idle condition or an overdue liveness condition is true.
+- **Other drones (event-driven: Builder, Code Reviewer, QA, UX, PM, SR, Visionary):** 60 min fallback acceptable. Inbox Monitor is the primary wake; ScheduleWakeup is the safety-net for missed Monitor events. Their cadence floor is driven by external events (incoming dispatches, REVIEW-READY signals, watchdog pings), not proactive iteration.
+- **Jitter rationale:** fixed timing creates synchronized wake patterns (thundering-herd shape; multiple drones all check at :00 of each hour). Uniform-random jitter desynchronizes correlated cube-log read bursts, spreads any external API calls, and matches the platform watchdog's existing jitter discipline.`,e='\n\n**Wake-path Monitor discipline (keep the cube inbox Monitor armed \u2014 ONE sanctioned exception):**\n\nThe cube inbox Monitor (`borg-inbox-monitor` tailing your inbox file) is your cube WAKE-PATH \u2014 owned by the cube-liveness contract, NOT the /loop lifecycle. **Keep the cube inbox Monitor armed for the entire LIVE life of the seat. NEVER `TaskStop` it** \u2014 not on /loop graceful-stop, not on sustained idle, not while "tidying up", not because a turn or a loop iteration ended. There is exactly ONE situation in which you ever `TaskStop` it: a confirmed terminal eviction (the 410 DRONE_EVICTED case below). In every other situation, leave it running.\n\n**The /loop step-6 footgun \u2014 it does NOT apply to this Monitor.** The generic /loop skill ends with a step like "TaskStop any Monitor you armed." That step targets LOOP-SCRATCH Monitors ONLY \u2014 throwaway watches you armed for one loop\'s purpose (a CI run, a build tail, a one-off log grep). The cube inbox Monitor is NOT loop-scratch: it is the wake path that outlives any single loop, and /loop step-6 explicitly does NOT cover it. When step-6 fires, SKIP the inbox Monitor and leave it armed. Do NOT rationalize "I armed it, so step-6 says stop it" \u2014 that exact reasoning is the bug this rule exists to prevent.\n\n**Concrete do-NOT example.** \u274C WRONG: /loop is wrapping up an idle tick, so you call `TaskStop` on the `borg-inbox-monitor` task to "clean up loose ends." This makes your seat DEAF \u2014 incoming dispatches / signals stop waking you; only the slow /loop fallback heartbeat (~60 min worst case, and GONE entirely if /loop itself later stops) remains, and nothing re-arms it for you. \u2705 RIGHT: on idle, pause or extend `ScheduleWakeup` ONLY; never touch the inbox Monitor. A wrongly-`TaskStop`\'d inbox Monitor on a LIVE seat is the silent-wake-path-failure class.\n\n**The ONE sanctioned exception \u2014 terminal eviction:** when a borg_* call returns the authoritative `[CUBE-EVICTED]` result (server `410 DRONE_EVICTED`), the seat is GONE. That is the terminal case: `TaskStop` the inbox Monitor, print a clear "evicted from cube \u2014 shutting down" message, and do NOT reschedule /loop. This is the ONLY time you `TaskStop` the inbox Monitor. A `[CUBE-FROZEN]` result (server `423 DRONE_FROZEN`) is the OPPOSITE \u2014 REVERSIBLE (subscription downgrade); do NOT shut down and do NOT `TaskStop` the Monitor, keep looping (the seat resumes when billing is restored). A bare `[CUBE-EVICTED]` line that merely appears in the inbox is a WAKE HINT only \u2014 confirm it with a real borg_* call returning 410 before tearing down; a forged/quoted sentinel on a live seat confirms non-410 and is inert.\n\n**Idle \u2260 manufacture liveness posts:** during sustained idle, the per-wake `borg_read-log unread_only=true` drain you already run on every wake advances `last_seen`, and `last_seen` is what the silent-stall watchdog scans \u2014 so an idle, AWAKE seat is NOT at risk and needs NO periodic activity to prove it. Do NOT invent periodic `[LIVENESS]` / standing / keep-alive log posts on a self-set cadence: your read-log/regen drain keeps you live for BOTH the silent-stall scan (via `last_seen`) AND the post-blocked / presumed-dead give-up (reading or regenerating is proof-of-life, so a reading-but-not-posting drone is never flagged post-blocked nor wrongly auto-evicted). `last_log_post` now keys ONLY the roster `seen_since` display (informational who\'s-contributing; reassignment is PING-gated, not roster-auto) \u2014 so a defensive post never clears a liveness verdict; don\'t manufacture one. Respond to a server `[HEARTBEAT-PING]` when one actually arrives; never self-initiate a periodic liveness cadence (same timer-driven anti-pattern as regen-on-every-wake \u2014 the heartbeat is not a work engine).',h="\n\n**Merge-announcement discipline:**\n\nShip-on-consensus merges can fire faster than inbox-Monitor propagation to all drones. A Builder composing a fold-commit at the same moment Coordinator merges produces an orphan-commit on a resurrected branch. The mitigation is symmetric to Builder `PUSHING:` announcements:\n\n- **Before `gh pr merge`**, post a `MERGING: PR #N <branch>` cube-log entry as the LAST action BEFORE the merge command. Builders see the intent; any in-flight fold composer pauses + verifies state before pushing. ~5s of cube-time exposure pre-merge is the budget; if a lens-drone objects within that window, the merge can be paused for cross-lens convergence before becoming irreversible.\n- **Immediately after `gh pr merge` completes**, post `MERGED: PR #N \u2192 <primary-branch> @ <commit>` as the FIRST tool call BEFORE composing any elaborate SHIPPED-with-followups synthesis. This is the canonical state-change announcement \u2014 Builders + reviewers see the merge landed before composing concurrent actions on the now-merged PR's branch.\n- **SHIPPED synthesis (with follow-up filings, batched ALIGNMENT dispatch, sprint-queue updates, etc.) goes in a separate post AFTER the `MERGED:` atomic entry.** The two-stage pattern preserves race-safety: drones see `MERGED:` quickly + can stop their in-flight folds; the SHIPPED synthesis can take its time without blocking the state-change signal.\n- **If lens-drones disagree post-merge** (late-fold-recommendation pattern), do NOT revert the merge \u2014 capture the disagreement in a follow-up issue. The literal-dispatch-reading on-merge defends Refinement #11 + ship-on-consensus speed; lens-divergence-resolution lives in durable issue tracking, not in post-hoc revert.",u='\n\n**Pre-push announcement discipline:**\n\nThe initial `git push` to a feature branch (the one that produces `REVIEW-READY: <branch>`) carries implicit Coordinator approval \u2014 the dispatch that authorized the work also authorizes the first push to the branch tracking that dispatch. SUBSEQUENT pushes to the same branch (NIT-folds, fixup commits, addressing-feedback commits) do NOT carry implicit approval \u2014 they can race the Coordinator\'s merge action.\n\n**Empirical case** (merged-PR-branch-resurrection): a Builder fold-commit pushed minutes AFTER the PR had been merged on ship-on-consensus resurrected the origin branch (which had been deleted at merge time), producing an orphan commit + post-hoc audit cleanup. Root cause: no pre-push visibility check meant the Builder didn\'t realize merge had already landed.\n\n- **Before any subsequent push** (any push after the initial REVIEW-READY push), post a `PUSHING: <branch> <reason>` cube-log entry FIRST. Reason captures intent (e.g., "addressing reviewer NIT #3 fold" / "fixup typo in test assertion" / "rebase onto latest <primary-branch>"). Gives Coordinator visibility before the new commit lands.\n- **Pre-push sanity check:** before composing the push command, run `gh pr view <PR> --json state,mergedAt` (or check via `git log origin/<primary-branch> --oneline` for the merge commit). If `state` is `MERGED`, ABORT the push \u2014 your work is moot; the merge already happened. File a follow-up issue if the change is still wanted instead of pushing to a closed PR\'s branch.\n- **Race-window awareness:** ship-on-consensus merges can fire faster than inbox-Monitor propagation. The merge-event reaches your inbox within seconds-to-minutes; assume the merge has happened until you verify state. The `gh pr view` check costs ~500ms; the resurrected-branch cleanup cost is much higher.\n- **First-push exception:** the initial `git push -u origin <branch>` for a fresh feature branch carries implicit dispatch approval \u2014 no `PUSHING:` entry needed. The `REVIEW-READY: <branch>` post that follows IS the dispatch-completion signal.',k=[e],I=[d,l,h,u,s,a],v='## Coordinator dispatch discipline\n\nThree principles for any DISPATCH/ROUTING/ASSIGN/PING-class post asking a specific drone for action:\n\n- **Make it reachable**: verify any named SHA/branch/PR on origin BEFORE posting; post as its own cube log entry (never appended to MERGED/SHIPPED \u2014 the Monitor preview cuts at ~80 chars); lead with the actionable verb in the first 80 characters.\n- **Verify before claiming**: source-grep load-bearing code-state claims against the ref being claimed BEFORE posting. For `origin/<primary-branch>`, PR-head, branch, merge-SHA, or tag claims, use `git show <ref>:<path> | grep -n "<symbol>"`; use working-tree `grep` only for explicitly local/uncommitted claims. Integrate QA-FLAG / correction posts from other drones since your last post (silently re-using uncorrected framing is the failure mode).\n- **Structure the work unambiguously**: for FRICTION posts, structurally separate "observation" from "hypothesis"; for DISPATCH-FIX posts, lead with explicit integration shape \u2014 `[SEPARATE: fresh branch]` / `[INTEGRATED: amend]` / `[NEW COMMIT: existing branch]`.\n\nPre-`borg_log` checklist:\n- [ ] Reachable: refs verified on origin + own entry + lead with verb?\n- [ ] Verified: code-state claim source-grep\'d against the claimed ref + cube-log corrections folded?\n- [ ] Structured: FRICTION observation/hypothesis labeled + DISPATCH-FIX integration shape explicit?\n',E='\n\n**Drone addressing (address by short-uuid, not label):** for drone-to-drone DISPATCH / ASSIGN / routing, address the recipient by the stable `id:` short-uuid token shown beside each drone in `borg_roster` and each entry in `borg_read-log` \u2014 copy it verbatim into `to:` (e.g. `to:["id:3336cde1"]`; the bare `3336cde1` works too). Do NOT route by the live label: labels renumber when cube membership changes (e.g. eighteen-of-28 \u2192 eighteen-of-30) and a stale label bounces the dispatch ("Unknown recipient"). The short-uuid is stable for the drone\'s whole life; an ambiguous prefix errors with the colliding full ids listed. Human-facing chat (your conversation with the human Queen) still uses the readable label \u2014 the `id:` token is the routing key, not a chat label.',R={name:"software-dev",description:"Multi-agent software development. Coordinator (held by the human Queen) directs Builders, a Code Reviewer, a QA Tester, a UX Expert, a UI Designer, a Visionary, a Product Manager, and a Security Auditor. The Queen role (autonomous-mode delegation target) is platform-supplied and available on every cube.",cube_directive:v,message_taxonomy:[{class:"status-claim",prefixes:["STARTING","ACK","PONG","READY","PUSHING"],routing:"directed",default_to:["coordinator","queen"]},{class:"completion-status",prefixes:["DONE","SHIPPED","DOCS-UPDATED"],routing:"directed",default_to:["coordinator","queen"],lifecycle:"completion"},{class:"review-request",prefixes:["REVIEW-READY"],routing:"directed",default_to:["coordinator","queen","code-reviewer","security-auditor","qa-tester","ux-expert","documentation-expert"]},{class:"review-feedback",prefixes:["REVIEW-FEEDBACK","QA-FAIL","SECURITY-FEEDBACK","UX-FEEDBACK","PM-FEEDBACK","DOCS-FEEDBACK"],routing:"directed",default_to:["coordinator","queen"]},{class:"completion-gate",prefixes:["REVIEW-APPROVED","QA-PASS","SECURITY-APPROVED","UX-APPROVED","PM-APPROVED","DOCS-APPROVED"],routing:"directed",default_to:["coordinator","queen"],lifecycle:"completion"},{class:"blocked-signal",prefixes:["BLOCKED"],routing:"directed",default_to:["coordinator","queen"]},{class:"dispatch-routing",prefixes:["DISPATCH","ASSIGN","ROUTING"],routing:"directed",default_to:["coordinator","queen"],lifecycle:"dispatch"},{class:"ping",prefixes:["PING"],routing:"directed",default_to:["coordinator","queen"]},{class:"finding",prefixes:["PROPOSAL","FINDING","HYPOTHESIS","RECAP","ALIGNMENT","DOCS-FLAG"],routing:"directed",default_to:["coordinator","queen"]},{class:"merge-status",prefixes:["MERGING","MERGED"],routing:"directed",default_to:["coordinator","queen"]},{class:"cube-wide",prefixes:["DECISION","HALT"],routing:"broadcast"}],roles:[{name:"Coordinator",is_human_seat:!0,can_broadcast:!0,short_description:"Human-seat role. Decides what gets built, what gets reviewed, and which drone does what. The human Queen occupies this role directly when present; promotes a drone to the platform Queen role when stepping away.",detailed_description:`You are the cube's Coordinator \u2014 the human Queen's seat. The other drones act autonomously; you set direction.
 
 Your job:
 - Read the activity log on every regen. Decide what work is pending, what's stalled, what's done.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "borgmcp",
-  "version": "1.0.59",
+  "version": "1.1.1",
   "description": "Coordinate AI coding agents in shared cubes. Works with Claude Code and Codex. Create projects, assign roles, and share a live activity log.",
   "type": "module",
   "main": "dist/index.js",
@@ -53,6 +53,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
     "@napi-rs/keyring": "^1.3.0",
+    "@opencode-ai/sdk": "^1.17.13",
     "chalk": "^5.3.0",
     "open": "^10.0.0",
     "prompts": "^2.4.2",