agentbox-app 0.1.6

package/shared/analytics-events.mjs

@@ -0,0 +1,63 @@
+// THE WHOLE LIST OF WHAT AGENTBOX MAY SEND. Nothing else can leave.
+//
+// Her eight, approved 2026-08-19 under her 08-18 rule: NO CODE, PROMPTS, KEYS
+// OR PATHS. Seven of them are counts and the eighth is the version pair, which
+// is not an event but a property on every one of them, exactly as
+// `legal/privacy.html` section 5.1 describes it.
+//
+// This file is SHARED so the code and the published promise cannot drift apart.
+// The privacy page lists these sentences; a test reads them from here and fails
+// the build when one of them is missing from the page, and
+// `scripts/shot-legal-pages.mjs` in the store fails from the other side.
+//
+// The naming rule that matters: an event name says THAT something happened. It
+// never carries what it happened to. There is no room in this file for a title,
+// a path, a repo name or a slug, and the property allowlist below is what stops
+// a future caller adding one by accident.
+
+// name -> the sentence the privacy page promises, word for word.
+import { Name } from '../shared/product-name.mjs';
+export const EVENTS = {
+  app_opened: `${Name} was opened`,
+  first_run_finished: 'First run finished',
+  repo_connected: 'A repo was connected',
+  agent_seen: 'An agent was seen',
+  task_opened: 'A task was opened',
+  reply_sent: 'A reply was sent',
+  task_finished: 'A task finished',
+};
+
+export const EVENT_NAMES = Object.keys(EVENTS);
+
+// THE ONLY PROPERTIES A CALLER MAY ATTACH, and every one of them is a number or
+// a boolean. A string is refused outright rather than scrubbed, because a
+// scrubbed string is a promise about a regular expression and this is a promise
+// about a type. The version pair is set by the sender itself (`main/analytics
+// .mjs`), never by a caller, which is why it is not in here.
+export const ALLOWED_PROPS = new Set([
+  'seconds',        // how long something took, rounded
+  'count',          // how many of a thing, never which ones
+  'kind',           // -> KINDS below, an enum and nothing else
+  'fromAgent',      // whether an agent or the founder did it
+]);
+
+// `kind` is the one property that is not a number, so it is a closed list. A
+// value outside it is dropped, not passed through.
+export const KINDS = new Set(['task', 'question', 'review', 'directive', 'agent', 'digest']);
+
+// Refuse an event nobody approved; drop a property nobody approved. Returns the
+// payload that may be sent, or null when the event itself is not one of hers.
+export function sanitize(name, props = {}) {
+  if (!EVENT_NAMES.includes(name)) return null;
+  const out = {};
+  for (const [key, value] of Object.entries(props ?? {})) {
+    if (!ALLOWED_PROPS.has(key)) continue;
+    if (key === 'kind') {
+      if (typeof value === 'string' && KINDS.has(value)) out.kind = value;
+      continue;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) out[key] = value;
+    else if (typeof value === 'boolean') out[key] = value;
+  }
+  return out;
+}

package/shared/answers.d.mts

@@ -0,0 +1,12 @@
+// Types for shared/answers.mjs, which is plain ESM so that main (Node) and the
+// renderer (Vite) can share one copy of the rule.
+
+export interface AnsweredItem {
+  answer?: string;
+  answeredThrough?: number;
+  wrote?: Record<string, { ts: number; source: string } | undefined>;
+}
+
+export function agentSpokeSince(item: AnsweredItem | null | undefined, since: number): boolean;
+export function answerSettled(item: AnsweredItem | null | undefined): boolean;
+export function answerTs(item: AnsweredItem | null | undefined): number;

package/shared/answers.mjs

@@ -0,0 +1,80 @@
+// HAS THE AGENT FINISHED ACTING ON WHAT SHE SAID? One rule, read by the
+// supervisor (Node) and the inbox (Vite), because the two used to answer it
+// differently and both used to answer it wrong.
+//
+// An answer is a fact with two states and the ledger only ever recorded one of
+// them. She writes `answer`, a worker is spawned to carry it, and then the
+// worker finishes and leaves the row exactly as it found it: `open`, her answer
+// still on it, because the thread is alive and closing it is the wrong move
+// (one row was filed on a one-word status question with a whole workstream
+// inside it). Nothing on disk said the answer had been DEALT WITH. The only
+// record was `_handledAnswers`, in supervisor memory, invisible to the
+// renderer and wiped by every "Resume interrupted agents".
+//
+// So a finished thread was indistinguishable from a stranded one, and read as
+// the worse of the two everywhere: out of her inbox, red in In progress, and
+// respawnable forever. Twelve of her ro).
+//
+// `answeredThrough` is that missing fact, written on the item by the supervisor
+// when a session finishes: the ts of the answer it acted on. It is compared
+// against `wrote.answer.ts` rather than stored as a flag, so her NEXT answer
+// carries a later ts and the row goes live again on its own, with nothing to
+// clear and nothing to remember to clear.
+//
+// AND THE SESSION MUST HAVE LEFT A WORD ON THE ROW, which is the half that was
+// missing until 2026-08-14 and is the whole of what she saw.
+//
+// The mark above is written from the SESSION's outcome: its process exited with
+// a result and no error. That is a fact about a child process, not about her
+// row. A session that spawned, read the brief and exited having written nothing
+// satisfies it, and the row is then declared finished-and-delivered while
+// carrying the exact words it carried before she spoke.).
+//
+// It happened five times in her store in two days. On it took 22 seconds: she
+// replied at 12:32:19, a session exited at 12:32:42 having touched nothing, and
+// the row was back in front of her.
+//
+// The delivery this rule was written for always had the word in it. Eleven of
+// the twelve rows that named the original bug had a RESULT written after her
+// answer, and the titles were the reports. So the word is not a new condition,
+// it is the one that was assumed: news is news because somebody wrote it.
+//
+// A WORD IS ONE SHE CAN READ. This branch delivers finished work to her inbox,
+// so the only writes that make it news are the ones the row shows her: the
+// result, and the title and body a session rewrites when the answer changed
+// what they say (instructions.md). Everything else is invisible from where she
+// sits, and a row that comes back with nothing readably new is the whole
+// complaint however busy the session was.
+//
+// A `note` is the checkpoint the NEXT session reads, not something she sees,
+// and it is excluded for that reason. It cost one real row: on (2026-08-13) she
+// answered at 12:32:54, a session wrote a note at 12:57:13 and no result, and
+// the row was handed back to her carrying a result written ten minutes BEFORE
+// she spoke.
+//
+// Status is not a word either. Claiming a row and releasing it writes `status`
+// twice and says nothing, which is exactly the session this catches. The two
+// statuses that would count, `done` and `blocked`, route on their own branches
+// in list-rules.ts and never reach this rule.
+const SPOKEN = ['result', 'title', 'body'];
+
+export function agentSpokeSince(item, since) {
+  return SPOKEN.some((field) => {
+    const w = item?.wrote?.[field];
+    return !!w && w.source === 'agent' && (w.ts ?? 0) > since;
+  });
+}
+
+export function answerSettled(item) {
+  const answer = item?.answer;
+  if (!answer || answer === '(withdrawn)') return false;
+  const ts = item?.wrote?.answer?.ts ?? 0;
+  if (!(ts > 0 && (item?.answeredThrough ?? 0) >= ts)) return false;
+  return agentSpokeSince(item, ts);
+}
+
+// The moment of the answer a session was spawned to carry, which is what gets
+// written down when it finishes. The app for a row nobody has answered.
+export function answerTs(item) {
+  return item?.wrote?.answer?.ts ?? 0;
+}

package/shared/artifact-keys.d.mts

@@ -0,0 +1,28 @@
+// Types for shared/artifact-keys.mjs, which is plain ESM so that main (Node)
+// and the pane (Vite) can share one copy of the rule. The whole reason this
+// rule exists is that it was applied in three places and disagreed in all
+// three; see the module itself for the measurements.
+
+export interface KeyPress {
+  key: string;
+  metaKey?: boolean;
+  ctrlKey?: boolean;
+  altKey?: boolean;
+}
+
+export function theAppKeepsThisKey(e: KeyPress | null | undefined): boolean;
+export function theAppKeepsThisInput(
+  input: { key?: string; meta?: boolean; control?: boolean; alt?: boolean } | null | undefined,
+): boolean;
+export function whatTheFileSentUp(
+  k: { key?: string; meta?: boolean; ctrl?: boolean; alt?: boolean } | null | undefined,
+): 'close' | 'palette' | 'app' | null;
+
+// Her own single-letter shortcuts, which a PAGE has no claim on because there
+// is nothing in a page to type.
+export const HER_LETTERS_IN_A_PAGE: Set<string>;
+export function theAppKeepsThisLetterInAPage(
+  input: { key?: string; meta?: boolean; control?: boolean; alt?: boolean } | null | undefined,
+): boolean;
+// Asked OF the page, by main, because only a frame can see its own focus.
+export const IS_SHE_TYPING_IN_THE_PAGE: string;

package/shared/artifact-keys.mjs

@@ -0,0 +1,140 @@
+// PURE. Which keys still belong to the APP while the keyboard is inside an
+// open artifact.
+//
+// MEASURED BEFORE ANYTHING WAS TOUCHED, on the real renderer with her real
+// cards and her real files (scripts/measure-keys-with-an-artifact.mjs, run
+// 2026-08-24). "Inside the file" is one click in the artifact, which is what a
+// person does with an artifact:
+//
+//   markdown, caret in the file    ⌘K dead    j dead    Escape dead
+//   page, clicked inside it        ⌘K dead    j dead    Escape closes it
+//   change, caret in a line        ⌘K works   j dead    Escape dead
+//
+// THREE MECHANISMS, AND THAT IS WHY THIS FILE EXISTS RATHER THAN THREE PATCHES.
+//
+//   1. The markdown editor swallowed every key it saw. `DocText` stopped
+//      propagation on every keydown so that a letter typed into a file is not
+//      also a shortcut — right intent, and the app already refuses letters by
+//      itself (`inInput` in App.tsx) — but the app's own window listener sits
+//      ABOVE the React root, so the same line also swallowed ⌘K and Escape.
+//   2. A page is its own document in its own origin, so no key crosses into
+//      the app at all. Main forwards from below the page, and it forwarded
+//      exactly one key, Escape.
+//   3. A line of a change is a contentEditable, so `inInput` is true and the
+//      app's guard returns on everything single-letter — including Escape,
+//      which is the one key that has to work from in there.
+//
+// So the rule is written once, here, and applied at all three: A CHORD IS NEVER
+// TEXT, AND ESCAPE IS ALWAYS THE WAY BACK. Everything else typed inside a file
+// is typing, and the app keeps its hands off it, which is the part that was
+// already right.
+
+/**
+ * Does this press belong to the app even though the keyboard is in the file?
+ *
+ * Escape, and any Command or Control chord. NOT Option on its own: on a Mac
+ * option-e is a letter she is typing, and treating it as a chord would take
+ * accented characters away from a file she is editing.
+ *
+ * ⌘S IS DELIBERATELY IN HERE even though it is the file's own save. The save
+ * listener is a window listener too (`DocText`), so it was dead for exactly the
+ * same reason and by exactly the same line: her "Saved." never appeared when
+ * the caret was in the document, which is the only place ⌘S is ever pressed.
+ * Letting the chord through is what makes that one work again as well.
+ */
+export function theAppKeepsThisKey(e) {
+  if (!e || typeof e.key !== 'string') return false;
+  if (e.key === 'Escape') return true;
+  return !!(e.metaKey || e.ctrlKey);
+}
+
+/**
+ * The same question asked from the main process, where a key arrives as an
+ * Electron `input` rather than a DOM event. One rule, two vocabularies.
+ */
+export function theAppKeepsThisInput(input) {
+  if (!input || typeof input.key !== 'string') return false;
+  return theAppKeepsThisKey({ key: input.key, metaKey: !!input.meta, ctrlKey: !!input.control, altKey: !!input.alt });
+}
+
+/**
+ * What the app does with a key that came up from inside a page in the pane.
+ *
+ * 'close' is Escape, which has meant "out of the file" since. 'palette' is ⌘K,
+ * which is the app's own and which a page drawn in a frame has no claim on.
+ * 'app' is one of her letters coming up out of a PAGE, where nothing is text.
+ * The pane hands it straight back to the app's own handler rather than
+ * restating what any letter means, so E archives, J and K walk, R replies, and
+ * each of them keeps every guard the app already puts in front of it. null is
+ * every other chord: ⌘R, ⌘=, ⌘Y and the rest are answered in the main process
+ * already, and the window must not answer them a second time.
+ */
+export function whatTheFileSentUp(k) {
+  if (!k || typeof k.key !== 'string') return null;
+  if (k.key === 'Escape') return 'close';
+  if ((k.meta || k.ctrl) && k.key.toLowerCase() === 'k') return 'palette';
+  if (theAppKeepsThisLetterInAPage({ key: k.key, meta: k.meta, control: k.ctrl, alt: k.alt })) return 'app';
+  return null;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// A PAGE HAS NOTHING TO TYPE IN, SO IT KEEPS NONE OF HER LETTERS.
+//
+// MEASURED BEFORE ANYTHING WAS TOUCHED
+// (scripts/measure-keys-with-an-artifact.mjs, the run recorded in
+// shots//e-before.json). E is not dead the way ⌘K was dead. With the keyboard
+// ON THE MESSAGE it archives the card whether a file is open beside it or not;
+// the app's handler runs, `inInput` is false, and the write goes through. It
+// dies only once she clicks INTO the artifact, and there the three kinds are
+// not the same thing at all:
+//
+//   markdown, caret in the file    E is a letter she is typing.  Correct.
+//   change, caret in a line        E is a letter she is typing.  Correct.
+//   page, clicked inside it        E is nothing at all.          The bug.
+//
+// Escape hands the keyboard back and then E works, which is the idiom the whole
+// of this file is built on.
+//
+// A page is the odd one. There is nothing in it to type, so no key in it is
+// text, and the only reason E was dead is that the list of keys the app asks
+// for from below the page was Escape and chords — the list above. Her letters
+// were never on it. So they go on it, here, once.
+//
+// WHAT IS DELIBERATELY NOT ON IT:
+//   Arrows, Enter, space, Tab   the page's own. Arrows SCROLL a page; taking
+//                               them would break reading the very thing she
+//                               opened. Tab walks the page's own links.
+//   1 through 9                 those APPROVE an option, and approval in this
+//                               app only ever happens deliberately (App.tsx
+//                               says so where E used to approve and burned
+//                               her). A forwarded digit is not deliberate.
+export const HER_LETTERS_IN_A_PAGE = new Set(['e', 'j', 'k', 'r', 'c', 'n', 's', 'z', 'b', 'g', '/', '\\']);
+
+/**
+ * Is this one of her letters, arriving from inside a page where there is
+ * nothing to type?
+ *
+ * Bare or shifted only. A chord is already answered by theAppKeepsThisInput
+ * above, and Option-e is a letter on a Mac, so neither belongs here.
+ */
+export function theAppKeepsThisLetterInAPage(input) {
+  if (!input || typeof input.key !== 'string') return false;
+  if (input.meta || input.control || input.alt) return false;
+  return HER_LETTERS_IN_A_PAGE.has(input.key.toLowerCase());
+}
+
+/**
+ * The one question main cannot answer by itself: is she typing INSIDE the page?
+ *
+ * A page is her own html and 15 of the 406 under her product's designs, reports
+ * and landing folders carry a real text field (counted 2026-08-24). If she is
+ * in one of those, every letter she types is text and none of it is a shortcut
+ * — the same rule the app applies to its own fields, applied one document down.
+ * Main asks the frame this, because only the frame can see its own focus.
+ */
+export const IS_SHE_TYPING_IN_THE_PAGE = `(() => {
+  const a = document.activeElement;
+  if (!a) return false;
+  const t = String(a.tagName || '').toUpperCase();
+  return t === 'INPUT' || t === 'TEXTAREA' || t === 'SELECT' || !!a.isContentEditable;
+})()`;

package/shared/bridge-map.mjs

@@ -0,0 +1,128 @@
+// THE ONE LIST OF WHAT THE SCREEN MAY ASK FOR.
+//
+// preload.cjs is the desktop half of this: it turns each name below into an
+// Electron invoke. renderer/src/browser-bridge.ts is the other half and turns
+// the same name into a POST to the local server. Both doors read this list, so
+// a channel added to one cannot go missing from the other, and
+// tests/both-front-doors-offer-the-same-bridge.test.mjs fails the suite if
+// preload.cjs and this file ever disagree.
+//
+// The keys are the screen's own vocabulary, the values are the channels
+// main/ipc.mjs registered. Nothing here decides anything; it is a phone book.
+
+/** Asked, and the screen waits for the answer. */
+export const REQUEST_CHANNELS = {
+  terminal: 'zero:terminal',
+  snapshot: 'zero:snapshot',
+  dashboard: 'zero:dashboard',
+  commandCatalog: 'zero:command-catalog',
+  remoteControl: 'zero:remote-control',
+  command: 'zero:command',
+  compact: 'zero:compact',
+  compactionStatus: 'zero:compaction-status',
+  answer: 'zero:answer',
+  compose: 'zero:compose',
+  schedule: 'zero:schedule',
+  repeats: 'zero:repeats',
+  composeRepeat: 'zero:compose-repeat',
+  setRepeat: 'zero:set-repeat',
+  endRepeat: 'zero:end-repeat',
+  pauseSupervisor: 'zero:supervisor-pause',
+  createProduct: 'zero:create-product',
+  firstRunAnswer: 'zero:first-run-answer',
+  firstRunExamples: 'zero:first-run-examples',
+  firstRunPractice: 'zero:first-run-practice',
+  firstRunPracticeEnd: 'zero:first-run-practice-end',
+  firstRunWalking: 'zero:first-run-walking',
+  openFreshUser: 'zero:open-fresh-user',
+  openDemo: 'zero:open-demo',
+  chooseFolder: 'zero:choose-folder',
+  listFolders: 'zero:list-folders',
+  folderExists: 'zero:folder-exists',
+  agentFiles: 'zero:agent-files',
+  agentFolders: 'zero:agent-folders',
+  importAgents: 'zero:import-agents',
+  agentThreads: 'zero:agent-threads',
+  importThreads: 'zero:import-threads',
+  badge: 'zero:badge',
+  bootInfo: 'zero:boot-info',
+  updateCheck: 'zero:update-check',
+  updateInstall: 'zero:update-install',
+  notify: 'zero:notify',
+  stopSession: 'zero:stop-session',
+  reopen: 'zero:reopen',
+  instructionRead: 'zero:instruction-read',
+  instructionWrite: 'zero:instruction-write',
+  instructionHistory: 'zero:instruction-history',
+  instructionVersion: 'zero:instruction-version',
+  standingRead: 'zero:standing-read',
+  standingWrite: 'zero:standing-write',
+  messageRulesRead: 'zero:message-rules-read',
+  messageRulesWrite: 'zero:message-rules-write',
+  settingsRead: 'zero:settings-read',
+  claudeRecheck: 'zero:claude-recheck',
+  codexRecheck: 'zero:codex-recheck',
+  codexAddAccount: 'zero:codex-add-account',
+  claudeAddAccount: 'zero:claude-add-account',
+  setProjectSetting: 'zero:settings-set-project',
+  setWorkspaceSetting: 'zero:settings-set-workspace',
+  projectRename: 'zero:project-rename',
+  projectIcon: 'zero:project-icon',
+  projectIconClear: 'zero:project-icon-clear',
+  projectInstructionsRead: 'zero:project-instructions-read',
+  projectInstructionsWrite: 'zero:project-instructions-write',
+  saveAttachments: 'zero:save-attachments',
+  stageAttachment: 'zero:stage-attachment',
+  crash: 'zero:crash',
+  track: 'zero:track',
+  sessionTrace: 'zero:session-trace',
+  itemHistory: 'zero:item-history',
+  openArtifact: 'zero:open-artifact',
+  readDoc: 'zero:read-doc',
+  codeChange: 'zero:code-change',
+  codeFile: 'zero:code-file',
+  saveCodeFile: 'zero:save-code-file',
+  writeDoc: 'zero:write-doc',
+  railNote: 'zero:rail-note',
+  saveRailNote: 'zero:save-rail-note',
+  agentReply: 'zero:agent-reply',
+  agentReveal: 'zero:agent-reveal',
+  agentConversation: 'zero:agent-conversation',
+  scheduleAgent: 'zero:schedule-agent',
+  closeAgent: 'zero:close-agent',
+  unreplyAgent: 'zero:unreply-agent',
+  resumeAgents: 'zero:resume-agents',
+  resumeItems: 'zero:resume-items',
+  redeliver: 'zero:redeliver',
+  setProductOrder: 'zero:set-product-order',
+  setProductHidden: 'zero:set-product-hidden',
+  approve: 'zero:approve',
+};
+
+/** Told rather than asked: the app talks and the screen listens. */
+export const PUSH_CHANNELS = {
+  onApprovalAnswered: 'zero:approval-answered',
+  onChanged: 'zero:changed',
+  onFind: 'zero:find',
+  onZoomPercent: 'zero:zoom-percent',
+  onRecovered: 'zero:recovered',
+  onOpenItem: 'zero:open-item',
+  onScreenDetail: 'zero:screen-detail',
+  onEscapeBrowser: 'zero:escape-browser',
+  onKeyInTheFile: 'zero:key-in-the-file',
+};
+
+// THE FEW THAT ARE NOT A STRAIGHT HANDOVER. Each is called with bare values
+// and the handler on the far side reads an object, so the key each value goes
+// under is part of the contract and belongs here beside the channel.
+export const WRAPPED_ARGS = {
+  notify: ['arrivals'],
+  track: ['name'],
+  instructionWrite: ['id', 'text'],
+  instructionVersion: ['id', 'at'],
+};
+
+// Electron can tell you the real path of a file somebody dropped onto the
+// window. A browser cannot, by design, and no server can answer it either, so
+// this one is absent there rather than wrong. The screen already reads null.
+export const DESKTOP_ONLY = ['pathForFile'];

package/shared/claude-commands.d.mts

@@ -0,0 +1,20 @@
+export interface ClaudeCommand {
+  name: string;
+  description: string;
+  /** Claude Code's own shorter sentence, where they wrote one for a menu. */
+  menuDescription: string | null;
+  /** False when a getter composes the description at run time and we cut it at
+   *  the interpolation, so nothing may present it as a quotation. */
+  whole: boolean;
+  argumentHint: string | null;
+  aliases: string[];
+}
+
+export declare const CLAUDE_COMMANDS: ClaudeCommand[];
+export declare const READ_FROM: string | null;
+export declare const READ_AT: string | null;
+export declare function commandWords(cmd: ClaudeCommand): string[];
+export declare function commandHint(cmd: ClaudeCommand): string;
+export declare function commandMatches(query: string | null): ClaudeCommand[];
+export declare function commandDraft(cmd: ClaudeCommand): string;
+export declare function commandPrompt(reply: unknown, nativeNames?: string[]): string | null;

package/shared/claude-commands.generated.mjs

@@ -0,0 +1,149 @@
+// GENERATED BY scripts/read-claude-commands.mjs. DO NOT EDIT BY HAND.
+//
+// Claude Code's own words for the commands Agentbox's reply box offers,
+// read out of the copy of Claude Code installed on the machine that built
+// this. `npm run build` rewrites it. Committed so a machine with no Claude
+// Code on it can still build, and so a version that renames one of the eight
+// shows up as a diff rather than as a wrong menu.
+//
+// WHY IT IS READ AND NOT TYPED: reading them out of the installed binary at
+// build time, rather than typing them into a file, is the only way the list
+// cannot rot quietly.
+
+export const READ_FROM = "2.1.283";
+export const READ_AT = "2026-09-29";
+export const CLAUDE_COMMANDS = [
+  {
+    "name": "model",
+    "description": "Set the AI model for Claude Code",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": "<model>",
+    "aliases": []
+  },
+  {
+    "name": "effort",
+    "description": "Set effort level for model usage",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": null,
+    "aliases": []
+  },
+  {
+    "name": "fast",
+    "description": "Toggle fast mode",
+    "menuDescription": null,
+    "whole": false,
+    "argumentHint": "[on|off]",
+    "aliases": []
+  },
+  {
+    "name": "goal",
+    "description": "Set a goal — keep working until the condition is met",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": null,
+    "aliases": []
+  },
+  {
+    "name": "context",
+    "description": "Show current context usage",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": null,
+    "aliases": []
+  },
+  {
+    "name": "usage",
+    "description": "Show session cost, plan usage, and what's contributing to your limits",
+    "menuDescription": "Show session cost and plan usage",
+    "whole": true,
+    "argumentHint": null,
+    "aliases": [
+      "cost",
+      "stats"
+    ]
+  },
+  {
+    "name": "mcp",
+    "description": "Manage MCP servers",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": "[reconnect|enable|disable [<server>|all]]",
+    "aliases": []
+  },
+  {
+    "name": "compact",
+    "description": "Free up context by summarizing the conversation so far",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": "<optional custom summarization instructions>",
+    "aliases": []
+  },
+  {
+    "name": "advisor",
+    "description": "Let Claude consult a stronger model at key moments",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": null,
+    "aliases": []
+  },
+  {
+    "name": "autocompact",
+    "description": "Configure the auto-compact window size",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": "[auto|<tokens>]",
+    "aliases": []
+  },
+  {
+    "name": "output-style",
+    "description": "List output styles or switch to one",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": "[style]",
+    "aliases": []
+  },
+  {
+    "name": "recap",
+    "description": "Generate a one-line session recap now",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": null,
+    "aliases": []
+  },
+  {
+    "name": "reload-skills",
+    "description": "Pick up skills added or changed on disk during this session",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": null,
+    "aliases": []
+  },
+  {
+    "name": "list-agents",
+    "description": "List subagents, teammates, and other Claude sessions you can message",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": null,
+    "aliases": [
+      "peers"
+    ]
+  },
+  {
+    "name": "focus",
+    "description": "Toggle focus view: just your prompt, summary, and response",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": "[on|off]",
+    "aliases": []
+  },
+  {
+    "name": "reload-plugins",
+    "description": "Activate pending plugin changes in the current session",
+    "menuDescription": null,
+    "whole": true,
+    "argumentHint": "[--force]",
+    "aliases": []
+  }
+];