@staff0rd/assist 0.772.0 → 0.773.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.772.0",
+  version: "0.773.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -563,7 +563,7 @@ function stripLegacyConfigKeys(config) {
 }
 
 // src/shared/types.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/shared/adviceFragmentNames.ts
 var adviceFragmentTitles = {
@@ -601,47 +601,185 @@ var adviceFragmentNames = [
   "verify"
 ];
 
-// src/shared/runConfigSchema.ts
+// src/shared/hotkeys/hotkeysSchema.ts
 import { z } from "zod";
-var runParamSchema = z.strictObject({
-  name: z.string(),
-  required: z.boolean().optional(),
-  default: z.string().optional(),
-  description: z.string().optional()
+
+// src/shared/hotkeys/hotkeyKeyCode.ts
+var PUNCTUATION_CODES = {
+  "/": "Slash",
+  ".": "Period",
+  ",": "Comma",
+  ";": "Semicolon",
+  "'": "Quote",
+  "[": "BracketLeft",
+  "]": "BracketRight",
+  "\\": "Backslash",
+  "-": "Minus",
+  "=": "Equal",
+  "`": "Backquote"
+};
+var NAMED_KEYS = [
+  "Enter",
+  "Space",
+  "Escape",
+  "Backspace",
+  "Delete",
+  "Insert",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight"
+];
+function hotkeyKeyCode(token) {
+  if (/^[a-z]$/i.test(token)) {
+    const label2 = token.toUpperCase();
+    return { code: `Key${label2}`, label: label2 };
+  }
+  if (/^\d$/.test(token)) return { code: `Digit${token}`, label: token };
+  const punctuation = PUNCTUATION_CODES[token];
+  if (punctuation) return { code: punctuation, label: token };
+  if (/^F([1-9]|1[0-2])$/i.test(token)) {
+    const label2 = token.toUpperCase();
+    return { code: label2, label: label2 };
+  }
+  const named = NAMED_KEYS.find(
+    (name) => name.toLowerCase() === token.toLowerCase()
+  );
+  return named ? { code: named, label: named } : void 0;
+}
+
+// src/shared/hotkeys/parseModifiers.ts
+var MODIFIER_ALIASES = {
+  mod: "Mod",
+  ctrl: "Ctrl",
+  control: "Ctrl",
+  alt: "Alt",
+  option: "Alt",
+  opt: "Alt",
+  shift: "Shift",
+  meta: "Meta",
+  cmd: "Meta",
+  command: "Meta",
+  win: "Meta"
+};
+var MODIFIER_ORDER = [
+  "Mod",
+  "Ctrl",
+  "Alt",
+  "Shift",
+  "Meta"
+];
+function parseModifiers(tokens, text17) {
+  const modifiers = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const modifier = MODIFIER_ALIASES[token.toLowerCase()];
+    if (!modifier)
+      return { ok: false, error: `"${token}" is not a modifier in "${text17}"` };
+    if (modifiers.has(modifier))
+      return { ok: false, error: `"${token}" is repeated in "${text17}"` };
+    modifiers.add(modifier);
+  }
+  if (![...modifiers].some((modifier) => modifier !== "Shift"))
+    return {
+      ok: false,
+      error: `"${text17}" needs at least one of Mod, Ctrl, Alt or Meta`
+    };
+  if (modifiers.has("Mod") && (modifiers.has("Ctrl") || modifiers.has("Meta")))
+    return {
+      ok: false,
+      error: `"${text17}" combines Mod with Ctrl or Meta, which Mod already means`
+    };
+  return {
+    ok: true,
+    modifiers: MODIFIER_ORDER.filter((modifier) => modifiers.has(modifier))
+  };
+}
+
+// src/shared/hotkeys/parseChord.ts
+function parseChord(text17, { modifiersOnly = false } = {}) {
+  const tokens = text17.split("+").map((token) => token.trim());
+  const keyToken = modifiersOnly ? void 0 : tokens.pop();
+  const parsed = parseModifiers(tokens, text17);
+  if (!parsed.ok) return parsed;
+  const { modifiers } = parsed;
+  if (keyToken === void 0) return { ok: true, chord: { modifiers } };
+  const key = hotkeyKeyCode(keyToken);
+  if (!key)
+    return { ok: false, error: `"${keyToken}" is not a key in "${text17}"` };
+  return { ok: true, chord: { modifiers, key } };
+}
+
+// src/shared/hotkeys/hotkeysSchema.ts
+function chordSchema(modifiersOnly) {
+  return z.string().superRefine((value, ctx) => {
+    const parsed = parseChord(value, { modifiersOnly });
+    if (!parsed.ok) ctx.addIssue({ code: "custom", message: parsed.error });
+  });
+}
+var keyChord = chordSchema(false).optional();
+var hotkeysSchema = z.strictObject({
+  navTab: chordSchema(true).optional(),
+  focusSidebar: keyChord,
+  focusTerminal: keyChord,
+  toggleDiff: keyChord,
+  focusRepoPicker: keyChord,
+  openConfig: keyChord,
+  openMenu: keyChord,
+  focusAddAgent: keyChord,
+  focusVsCode: keyChord,
+  focusDone: keyChord,
+  nextWaiting: keyChord,
+  newSession: keyChord,
+  quickOpen: keyChord,
+  save: keyChord,
+  shortcutsSheet: keyChord
 });
-var runConfigSchema = z.strictObject({
-  name: z.string(),
-  command: z.string(),
-  args: z.array(z.string()).optional(),
-  params: z.array(runParamSchema).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  filter: z.string().optional(),
-  pre: z.array(z.string()).optional(),
-  cwd: z.string().optional(),
-  quiet: z.boolean().optional(),
-  server: z.union([z.boolean(), z.string().min(1)]).optional(),
-  port: z.number().optional()
+
+// src/shared/runConfigSchema.ts
+import { z as z2 } from "zod";
+var runParamSchema = z2.strictObject({
+  name: z2.string(),
+  required: z2.boolean().optional(),
+  default: z2.string().optional(),
+  description: z2.string().optional()
+});
+var runConfigSchema = z2.strictObject({
+  name: z2.string(),
+  command: z2.string(),
+  args: z2.array(z2.string()).optional(),
+  params: z2.array(runParamSchema).optional(),
+  env: z2.record(z2.string(), z2.string()).optional(),
+  filter: z2.string().optional(),
+  pre: z2.array(z2.string()).optional(),
+  cwd: z2.string().optional(),
+  quiet: z2.boolean().optional(),
+  server: z2.union([z2.boolean(), z2.string().min(1)]).optional(),
+  port: z2.number().optional()
 });
-var runLinkSchema = z.strictObject({
-  link: z.string(),
-  prefix: z.string()
+var runLinkSchema = z2.strictObject({
+  link: z2.string(),
+  prefix: z2.string()
 });
 
 // src/shared/secretConfigValue.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var SECRET_META_KEY = "assistSecret";
 function secretConfigValue(schema2) {
   return schema2.meta({ [SECRET_META_KEY]: true });
 }
 function isSecretSchemaNode(node) {
-  const meta = z2.globalRegistry.get(node);
+  const meta = z3.globalRegistry.get(node);
   return meta?.[SECRET_META_KEY] === true;
 }
 
 // src/shared/sessionLinkSchema.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var SSH_LINK_RETIRED = "ssh links are no longer supported; relink with `assist sessions nodes link <name> --tailscale <host> --port <port>`";
-var sessionLinkSchema = z3.preprocess(
+var sessionLinkSchema = z4.preprocess(
   (link3, ctx) => {
     if (link3 && typeof link3 === "object" && "ssh" in link3)
       ctx.issues.push({
@@ -651,260 +789,261 @@ var sessionLinkSchema = z3.preprocess(
       });
     return link3;
   },
-  z3.strictObject({ name: z3.string(), url: z3.string() })
+  z4.strictObject({ name: z4.string(), url: z4.string() })
 );
 
 // src/shared/types.ts
-var transcriptConfigSchema = z4.strictObject({
-  vttDir: z4.string(),
-  transcriptsDir: z4.string(),
-  summaryDir: z4.string()
+var transcriptConfigSchema = z5.strictObject({
+  vttDir: z5.string(),
+  transcriptsDir: z5.string(),
+  summaryDir: z5.string()
 });
-var miroExtractSchema = z4.strictObject({
-  board: z4.string().optional(),
-  frame: z4.string().optional(),
-  topLeft: z4.string(),
-  bottomRight: z4.string(),
-  items: z4.string(),
-  ignore: z4.string().optional(),
-  out: z4.string().optional()
+var miroExtractSchema = z5.strictObject({
+  board: z5.string().optional(),
+  frame: z5.string().optional(),
+  topLeft: z5.string(),
+  bottomRight: z5.string(),
+  items: z5.string(),
+  ignore: z5.string().optional(),
+  out: z5.string().optional()
 });
 var DEFAULT_BACKUP_DIR = "~/.assist/backups";
 var DEFAULT_CLONE_DIR = "~/git";
 var assistConfigShape = {
-  advice: z4.strictObject({
-    sections: z4.partialRecord(z4.enum(adviceFragmentNames), z4.boolean()).default({}),
-    extra: z4.string().optional(),
-    verify: z4.string().optional()
+  advice: z5.strictObject({
+    sections: z5.partialRecord(z5.enum(adviceFragmentNames), z5.boolean()).default({}),
+    extra: z5.string().optional(),
+    verify: z5.string().optional()
   }).optional(),
-  backlog: z4.strictObject({
-    previewComments: z4.boolean().default(false)
+  backlog: z5.strictObject({
+    previewComments: z5.boolean().default(false)
   }).optional(),
-  backup: z4.strictObject({
-    dir: z4.string().default(DEFAULT_BACKUP_DIR)
+  backup: z5.strictObject({
+    dir: z5.string().default(DEFAULT_BACKUP_DIR)
   }).default({ dir: DEFAULT_BACKUP_DIR }),
-  clone: z4.strictObject({
-    baseDir: z4.string().default(DEFAULT_CLONE_DIR)
+  clone: z5.strictObject({
+    baseDir: z5.string().default(DEFAULT_CLONE_DIR)
   }).default({ baseDir: DEFAULT_CLONE_DIR }),
-  commit: z4.strictObject({
-    conventional: z4.boolean().default(false),
-    pull: z4.boolean().default(false),
-    push: z4.boolean().default(false),
-    expectedBranch: z4.string().optional()
+  commit: z5.strictObject({
+    conventional: z5.boolean().default(false),
+    pull: z5.boolean().default(false),
+    push: z5.boolean().default(false),
+    expectedBranch: z5.string().optional()
   }).default({ conventional: false, pull: false, push: false }),
-  branch: z4.strictObject({
-    prefix: z4.string().optional(),
-    defaultBranch: z4.string().optional()
+  branch: z5.strictObject({
+    prefix: z5.string().optional(),
+    defaultBranch: z5.string().optional()
   }).optional(),
-  devlog: z4.strictObject({
-    name: z4.string().optional(),
-    ignore: z4.array(z4.string()).optional(),
-    skip: z4.record(z4.string(), z4.array(z4.string())).optional()
+  devlog: z5.strictObject({
+    name: z5.string().optional(),
+    ignore: z5.array(z5.string()).optional(),
+    skip: z5.record(z5.string(), z5.array(z5.string())).optional()
   }).optional(),
-  notify: z4.strictObject({
-    enabled: z4.boolean().default(true)
+  notify: z5.strictObject({
+    enabled: z5.boolean().default(true)
   }).default({ enabled: true }),
-  complexity: z4.strictObject({
-    ignore: z4.array(z4.string()).default(["**/*test.ts*"])
+  complexity: z5.strictObject({
+    ignore: z5.array(z5.string()).default(["**/*test.ts*"])
   }).default({ ignore: ["**/*test.ts*"] }),
-  hardcodedColors: z4.strictObject({
-    ignore: z4.array(z4.string()).default([])
+  hardcodedColors: z5.strictObject({
+    ignore: z5.array(z5.string()).default([])
   }).optional(),
-  blockCodeComments: z4.strictObject({
-    ignore: z4.array(z4.string()).default([])
+  blockCodeComments: z5.strictObject({
+    ignore: z5.array(z5.string()).default([])
   }).optional(),
-  restructure: z4.strictObject({
-    ignore: z4.array(z4.string()).default([]),
-    pin: z4.array(z4.string()).default([]),
-    maxDepth: z4.number().int().positive().default(10)
+  restructure: z5.strictObject({
+    ignore: z5.array(z5.string()).default([]),
+    pin: z5.array(z5.string()).default([]),
+    maxDepth: z5.number().int().positive().default(10)
   }).optional(),
-  jira: z4.strictObject({
-    acField: z4.string().default("customfield_11937")
+  jira: z5.strictObject({
+    acField: z5.string().default("customfield_11937")
   }).optional(),
-  roam: z4.strictObject({
-    clientId: secretConfigValue(z4.string()),
-    clientSecret: secretConfigValue(z4.string()),
-    accessToken: secretConfigValue(z4.string()).optional(),
-    refreshToken: secretConfigValue(z4.string()).optional(),
-    tokenExpiresAt: z4.number().optional()
+  roam: z5.strictObject({
+    clientId: secretConfigValue(z5.string()),
+    clientSecret: secretConfigValue(z5.string()),
+    accessToken: secretConfigValue(z5.string()).optional(),
+    refreshToken: secretConfigValue(z5.string()).optional(),
+    tokenExpiresAt: z5.number().optional()
   }).optional(),
-  slack: z4.strictObject({
-    channel: z4.string().optional()
+  slack: z5.strictObject({
+    channel: z5.string().optional()
   }).optional(),
-  prs: z4.strictObject({
-    slack: z4.string().optional(),
-    required: z4.boolean().default(true),
-    promptJira: z4.boolean().default(false),
-    promptGithub: z4.boolean().default(false),
-    draft: z4.boolean().default(false),
-    readingWordsPerMinute: z4.number().int().positive().optional()
+  prs: z5.strictObject({
+    slack: z5.string().optional(),
+    required: z5.boolean().default(true),
+    promptJira: z5.boolean().default(false),
+    promptGithub: z5.boolean().default(false),
+    draft: z5.boolean().default(false),
+    readingWordsPerMinute: z5.number().int().positive().optional()
   }).optional(),
-  review: z4.strictObject({
-    codexModel: z4.string().optional(),
-    highLevel: z4.strictObject({
-      criticalPaths: z4.array(z4.string()).default([]),
-      uiPaths: z4.array(z4.string()).default([]),
-      descriptionWordCap: z4.number().int().positive().default(300)
+  review: z5.strictObject({
+    codexModel: z5.string().optional(),
+    highLevel: z5.strictObject({
+      criticalPaths: z5.array(z5.string()).default([]),
+      uiPaths: z5.array(z5.string()).default([]),
+      descriptionWordCap: z5.number().int().positive().default(300)
     }).optional()
   }).optional(),
-  readTime: z4.strictObject({
-    wordsPerMinute: z4.number().int().positive().default(200)
+  readTime: z5.strictObject({
+    wordsPerMinute: z5.number().int().positive().default(200)
   }).optional(),
-  releases: z4.strictObject({
-    streams: z4.array(
-      z4.strictObject({
-        name: z4.string(),
-        repo: z4.string(),
-        workflow: z4.string(),
-        nodes: z4.array(
-          z4.strictObject({
-            id: z4.string(),
-            environment: z4.string().optional(),
-            kind: z4.enum(["build", "gate"]).optional(),
-            label: z4.string().optional()
+  releases: z5.strictObject({
+    streams: z5.array(
+      z5.strictObject({
+        name: z5.string(),
+        repo: z5.string(),
+        workflow: z5.string(),
+        nodes: z5.array(
+          z5.strictObject({
+            id: z5.string(),
+            environment: z5.string().optional(),
+            kind: z5.enum(["build", "gate"]).optional(),
+            label: z5.string().optional()
           })
         ),
-        edges: z4.array(z4.tuple([z4.string(), z4.string()])).default([])
+        edges: z5.array(z5.tuple([z5.string(), z5.string()])).default([])
       })
     ).default([])
   }).optional(),
-  worktree: z4.strictObject({
-    enabled: z4.boolean().default(false),
-    watcher: z4.boolean().default(false),
-    trunk: z4.boolean().default(false),
-    includeDrafts: z4.boolean().default(false),
-    root: z4.string().optional(),
-    install: z4.union([z4.boolean(), z4.string(), z4.array(z4.string())]).default(true),
-    commitBeforeManualChecks: z4.boolean().default(false),
-    commitBeforePhaseEnd: z4.boolean().optional(),
-    copy: z4.array(z4.string()).default([
+  worktree: z5.strictObject({
+    enabled: z5.boolean().default(false),
+    watcher: z5.boolean().default(false),
+    trunk: z5.boolean().default(false),
+    includeDrafts: z5.boolean().default(false),
+    root: z5.string().optional(),
+    install: z5.union([z5.boolean(), z5.string(), z5.array(z5.string())]).default(true),
+    commitBeforeManualChecks: z5.boolean().default(false),
+    commitBeforePhaseEnd: z5.boolean().optional(),
+    copy: z5.array(z5.string()).default([
       ".env",
       "settings.local.json",
       ".claude/settings.local.json"
     ])
   }).optional(),
-  run: z4.array(z4.union([runConfigSchema, runLinkSchema])).optional(),
-  subtasks: z4.array(
-    z4.strictObject({
-      title: z4.string(),
-      description: z4.string().optional()
+  run: z5.array(z5.union([runConfigSchema, runLinkSchema])).optional(),
+  subtasks: z5.array(
+    z5.strictObject({
+      title: z5.string(),
+      description: z5.string().optional()
     })
   ).optional(),
   transcript: transcriptConfigSchema.optional(),
-  cliReadVerbs: z4.record(z4.string(), z4.array(z4.string())).optional(),
-  cliHook: z4.strictObject({
-    blockNpmRun: z4.boolean().default(true)
+  cliReadVerbs: z5.record(z5.string(), z5.array(z5.string())).optional(),
+  cliHook: z5.strictObject({
+    blockNpmRun: z5.boolean().default(true)
   }).optional(),
-  dotnet: z4.strictObject({
-    inspect: z4.strictObject({
-      suppress: z4.array(z4.string()).default([])
+  dotnet: z5.strictObject({
+    inspect: z5.strictObject({
+      suppress: z5.array(z5.string()).default([])
     }).default({ suppress: [] })
   }).optional(),
-  litellm: z4.strictObject({
-    baseUrl: z4.string().optional(),
-    apiKey: secretConfigValue(z4.string()).optional()
+  litellm: z5.strictObject({
+    baseUrl: z5.string().optional(),
+    apiKey: secretConfigValue(z5.string()).optional()
   }).optional(),
-  ravendb: z4.strictObject({
-    connections: z4.array(
-      z4.strictObject({
-        name: z4.string(),
-        url: z4.string(),
-        database: z4.string(),
-        apiKeyRef: z4.string()
+  ravendb: z5.strictObject({
+    connections: z5.array(
+      z5.strictObject({
+        name: z5.string(),
+        url: z5.string(),
+        database: z5.string(),
+        apiKeyRef: z5.string()
       })
     ).default([]),
-    defaultConnection: z4.string().optional()
+    defaultConnection: z5.string().optional()
   }).optional(),
-  seq: z4.strictObject({
-    connections: z4.array(
-      z4.strictObject({
-        name: z4.string(),
-        url: z4.string(),
-        apiToken: secretConfigValue(z4.string())
+  seq: z5.strictObject({
+    connections: z5.array(
+      z5.strictObject({
+        name: z5.string(),
+        url: z5.string(),
+        apiToken: secretConfigValue(z5.string())
       })
     ).default([]),
-    defaultConnection: z4.string().optional()
+    defaultConnection: z5.string().optional()
   }).optional(),
-  sql: z4.strictObject({
-    connections: z4.array(
-      z4.strictObject({
-        name: z4.string(),
-        server: z4.string(),
-        port: z4.number(),
-        user: z4.string(),
-        password: secretConfigValue(z4.string()),
-        database: z4.string()
+  sql: z5.strictObject({
+    connections: z5.array(
+      z5.strictObject({
+        name: z5.string(),
+        server: z5.string(),
+        port: z5.number(),
+        user: z5.string(),
+        password: secretConfigValue(z5.string()),
+        database: z5.string()
       })
     ).default([]),
-    defaultConnection: z4.string().optional()
+    defaultConnection: z5.string().optional()
   }).optional(),
-  screenshot: z4.strictObject({
-    outputDir: z4.string().default("./screenshots")
+  screenshot: z5.strictObject({
+    outputDir: z5.string().default("./screenshots")
   }).default({ outputDir: "./screenshots" }),
-  sessions: z4.strictObject({
-    nodeName: z4.string().optional(),
-    links: z4.array(sessionLinkSchema).optional(),
-    linkVersionCheck: z4.enum(["block", "warn", "off"]).default("block"),
-    tailscaleServe: z4.boolean().default(true),
-    includeCommittedChanges: z4.boolean().default(true),
-    topBar: z4.boolean().default(true),
-    floatWaiting: z4.boolean().default(true),
-    floatWaitingAfterMs: z4.number().default(5e3),
-    maxLive: z4.number().default(24),
-    newSessionMode: z4.enum(["draft", "bug", "prompt", "design"]).default("draft")
+  sessions: z5.strictObject({
+    nodeName: z5.string().optional(),
+    links: z5.array(sessionLinkSchema).optional(),
+    linkVersionCheck: z5.enum(["block", "warn", "off"]).default("block"),
+    tailscaleServe: z5.boolean().default(true),
+    includeCommittedChanges: z5.boolean().default(true),
+    topBar: z5.boolean().default(true),
+    floatWaiting: z5.boolean().default(true),
+    floatWaitingAfterMs: z5.number().default(5e3),
+    maxLive: z5.number().default(24),
+    newSessionMode: z5.enum(["draft", "bug", "prompt", "design"]).default("draft"),
+    hotkeys: hotkeysSchema.optional()
   }).optional(),
-  database: z4.strictObject({
-    url: secretConfigValue(z4.string()).optional()
+  database: z5.strictObject({
+    url: secretConfigValue(z5.string()).optional()
   }).default({}),
-  mermaid: z4.strictObject({
-    krokiUrl: z4.string().default("https://kroki.io")
+  mermaid: z5.strictObject({
+    krokiUrl: z5.string().default("https://kroki.io")
   }).default({ krokiUrl: "https://kroki.io" }),
-  miro: z4.strictObject({
-    extracts: z4.record(z4.string(), miroExtractSchema).optional()
+  miro: z5.strictObject({
+    extracts: z5.record(z5.string(), miroExtractSchema).optional()
   }).optional(),
-  news: z4.strictObject({
-    showInNav: z4.boolean().default(false)
+  news: z5.strictObject({
+    showInNav: z5.boolean().default(false)
   }).optional(),
-  next: z4.strictObject({
-    peers: z4.array(z4.string()).optional(),
-    repos: z4.array(z4.string()).optional(),
-    projects: z4.array(
-      z4.string().regex(
+  next: z5.strictObject({
+    peers: z5.array(z5.string()).optional(),
+    repos: z5.array(z5.string()).optional(),
+    projects: z5.array(
+      z5.string().regex(
         /^[^/\s]+\/\d+$/,
         "Use <owner>/<project number>, e.g. my-org/3"
       )
     ).optional(),
-    pickStatuses: z4.array(z4.string()).optional(),
-    excludeLabels: z4.array(z4.string()).optional(),
-    excludeTypes: z4.array(z4.string()).optional()
+    pickStatuses: z5.array(z5.string()).optional(),
+    excludeLabels: z5.array(z5.string()).optional(),
+    excludeTypes: z5.array(z5.string()).optional()
   }).optional(),
-  deny: z4.array(
-    z4.strictObject({
-      pattern: z4.string(),
-      message: z4.string()
+  deny: z5.array(
+    z5.strictObject({
+      pattern: z5.string(),
+      message: z5.string()
     })
   ).optional(),
-  forbiddenStrings: z4.array(
-    z4.strictObject({
-      file: z4.string(),
-      paths: z4.array(z4.string()),
-      disallowed: z4.string()
+  forbiddenStrings: z5.array(
+    z5.strictObject({
+      file: z5.string(),
+      paths: z5.array(z5.string()),
+      disallowed: z5.string()
     })
   ).optional(),
-  sync: z4.strictObject({
-    autoConfirm: z4.boolean().default(false)
+  sync: z5.strictObject({
+    autoConfirm: z5.boolean().default(false)
   }).default({ autoConfirm: false }),
-  harness: z4.strictObject({
-    engine: z4.enum(["claude", "codex", "pi"]).default("claude"),
-    exposeCodexActions: z4.boolean().optional(),
-    exposePiActions: z4.boolean().optional(),
-    codexModel: z4.string().optional()
+  harness: z5.strictObject({
+    engine: z5.enum(["claude", "codex", "pi"]).default("claude"),
+    exposeCodexActions: z5.boolean().optional(),
+    exposePiActions: z5.boolean().optional(),
+    codexModel: z5.string().optional()
   }).default({ engine: "claude" })
 };
-var repoConfigSchema = z4.strictObject(assistConfigShape).partial();
-var assistConfigSchema = z4.strictObject({
+var repoConfigSchema = z5.strictObject(assistConfigShape).partial();
+var assistConfigSchema = z5.strictObject({
   ...assistConfigShape,
-  repos: z4.record(z4.string(), repoConfigSchema).optional()
+  repos: z5.record(z5.string(), repoConfigSchema).optional()
 });
 
 // src/shared/loadConfigFrom.ts
@@ -5085,52 +5224,52 @@ async function loadAllItems(orm, origin) {
 import { readFileSync as readFileSync13 } from "fs";
 
 // src/commands/backlog/types.ts
-import { z as z5 } from "zod";
-var backlogStatusSchema = z5.enum(["todo", "in-progress", "done", "wontdo"]);
-var backlogTypeSchema = z5.enum(["story", "bug"]);
-var planTaskSchema = z5.object({
-  task: z5.string()
+import { z as z6 } from "zod";
+var backlogStatusSchema = z6.enum(["todo", "in-progress", "done", "wontdo"]);
+var backlogTypeSchema = z6.enum(["story", "bug"]);
+var planTaskSchema = z6.object({
+  task: z6.string()
 }).strip();
-var planPhaseSchema = z5.strictObject({
-  name: z5.string(),
-  tasks: z5.array(planTaskSchema),
-  manualChecks: z5.array(z5.string()).optional()
+var planPhaseSchema = z6.strictObject({
+  name: z6.string(),
+  tasks: z6.array(planTaskSchema),
+  manualChecks: z6.array(z6.string()).optional()
 });
-var phaseUsageSchema = z5.strictObject({
-  phaseIdx: z5.number(),
-  tokensUp: z5.number(),
-  tokensDown: z5.number(),
-  activeMs: z5.number(),
-  peakContextPct: z5.number()
+var phaseUsageSchema = z6.strictObject({
+  phaseIdx: z6.number(),
+  tokensUp: z6.number(),
+  tokensDown: z6.number(),
+  activeMs: z6.number(),
+  peakContextPct: z6.number()
 });
-var phaseSessionSchema = z5.strictObject({
-  phaseIdx: z5.number(),
-  claudeSessionId: z5.string(),
-  hostname: z5.string(),
-  osUser: z5.string(),
-  createdAt: z5.string().optional()
+var phaseSessionSchema = z6.strictObject({
+  phaseIdx: z6.number(),
+  claudeSessionId: z6.string(),
+  hostname: z6.string(),
+  osUser: z6.string(),
+  createdAt: z6.string().optional()
 });
-var phaseUsageTotalSchema = z5.strictObject({
-  tokensUp: z5.number(),
-  tokensDown: z5.number(),
-  activeMs: z5.number(),
-  peakContextPct: z5.number()
+var phaseUsageTotalSchema = z6.strictObject({
+  tokensUp: z6.number(),
+  tokensDown: z6.number(),
+  activeMs: z6.number(),
+  peakContextPct: z6.number()
 });
-var subtaskStatusSchema = z5.enum(["todo", "in-progress", "done"]);
-var subtaskSchema = z5.strictObject({
-  title: z5.string(),
-  description: z5.string().optional(),
+var subtaskStatusSchema = z6.enum(["todo", "in-progress", "done"]);
+var subtaskSchema = z6.strictObject({
+  title: z6.string(),
+  description: z6.string().optional(),
   status: subtaskStatusSchema.default("todo")
 });
-var backlogCommentTypeSchema = z5.enum(["comment", "summary"]);
-var backlogCommentSchema = z5.strictObject({
-  id: z5.number().optional(),
-  text: z5.string(),
-  phase: z5.number().optional(),
-  timestamp: z5.string(),
+var backlogCommentTypeSchema = z6.enum(["comment", "summary"]);
+var backlogCommentSchema = z6.strictObject({
+  id: z6.number().optional(),
+  text: z6.string(),
+  phase: z6.number().optional(),
+  timestamp: z6.string(),
   type: backlogCommentTypeSchema
 });
-var gitRefKindSchema = z5.enum([
+var gitRefKindSchema = z6.enum([
   "branch",
   "commit",
   "commit-parent",
@@ -5138,41 +5277,41 @@ var gitRefKindSchema = z5.enum([
   "slack",
   "session"
 ]);
-var gitRefSchema = z5.strictObject({
+var gitRefSchema = z6.strictObject({
   kind: gitRefKindSchema,
-  ref: z5.string(),
-  title: z5.string().optional(),
-  url: z5.string().optional(),
-  state: z5.string().optional(),
-  createdAt: z5.string().optional()
+  ref: z6.string(),
+  title: z6.string().optional(),
+  url: z6.string().optional(),
+  state: z6.string().optional(),
+  createdAt: z6.string().optional()
 });
-var backlogLinkTypeSchema = z5.enum(["relates-to", "depends-on"]);
-var backlogLinkSchema = z5.strictObject({
+var backlogLinkTypeSchema = z6.enum(["relates-to", "depends-on"]);
+var backlogLinkSchema = z6.strictObject({
   type: backlogLinkTypeSchema,
-  targetId: z5.number()
+  targetId: z6.number()
 });
-var backlogItemSchema = z5.strictObject({
-  id: z5.number(),
+var backlogItemSchema = z6.strictObject({
+  id: z6.number(),
   type: backlogTypeSchema.default("story"),
-  name: z5.string(),
-  description: z5.string().optional(),
-  acceptanceCriteria: z5.array(z5.string()),
-  plan: z5.array(planPhaseSchema).optional(),
-  currentPhase: z5.number().optional(),
-  starred: z5.boolean().default(false),
+  name: z6.string(),
+  description: z6.string().optional(),
+  acceptanceCriteria: z6.array(z6.string()),
+  plan: z6.array(planPhaseSchema).optional(),
+  currentPhase: z6.number().optional(),
+  starred: z6.boolean().default(false),
   status: backlogStatusSchema,
-  comments: z5.array(backlogCommentSchema).optional(),
-  subtasks: z5.array(subtaskSchema).optional(),
-  links: z5.array(backlogLinkSchema).optional(),
-  phaseUsage: z5.array(phaseUsageSchema).optional(),
-  phaseSessions: z5.array(phaseSessionSchema).optional(),
+  comments: z6.array(backlogCommentSchema).optional(),
+  subtasks: z6.array(subtaskSchema).optional(),
+  links: z6.array(backlogLinkSchema).optional(),
+  phaseUsage: z6.array(phaseUsageSchema).optional(),
+  phaseSessions: z6.array(phaseSessionSchema).optional(),
   usageTotal: phaseUsageTotalSchema.optional(),
-  gitRefs: z5.array(gitRefSchema).optional(),
-  origin: z5.string().optional(),
-  jiraKey: z5.string().optional(),
-  githubIssue: z5.string().optional()
+  gitRefs: z6.array(gitRefSchema).optional(),
+  origin: z6.string().optional(),
+  jiraKey: z6.string().optional(),
+  githubIssue: z6.string().optional()
 });
-var backlogFileSchema = z5.array(backlogItemSchema);
+var backlogFileSchema = z6.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
 function parseBacklogJsonl(path106) {
@@ -6539,7 +6678,7 @@ ${issues}`);
 }
 
 // src/commands/backlog/propose/proposedItemSchema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/commands/backlog/buildCommentLines.ts
 function buildCommentLines(comments3) {
@@ -6691,20 +6830,20 @@ function buildPhasePrompt(item, phaseNumber, phase) {
 }
 
 // src/commands/backlog/propose/proposedItemSchema.ts
-var proposedPhaseSchema = z6.strictObject({
-  name: z6.string().trim().min(1, "phase name is required").refine(
+var proposedPhaseSchema = z7.strictObject({
+  name: z7.string().trim().min(1, "phase name is required").refine(
     (name) => name.toLowerCase() !== REVIEW_PHASE_NAME.toLowerCase(),
     `"${REVIEW_PHASE_NAME}" is owned by the runner and appended to every plan automatically \u2014 remove this phase`
   ),
-  tasks: z6.array(z6.string().trim().min(1)).min(1, "a phase needs at least one task"),
-  manualChecks: z6.array(z6.string().trim().min(1)).default([])
+  tasks: z7.array(z7.string().trim().min(1)).min(1, "a phase needs at least one task"),
+  manualChecks: z7.array(z7.string().trim().min(1)).default([])
 });
-var proposedItemSchema = z6.strictObject({
-  name: z6.string().trim().min(1, "name is required"),
-  type: z6.enum(["story", "bug"]),
-  description: z6.string().optional(),
-  acceptanceCriteria: z6.array(z6.string().trim().min(1)).default([]),
-  phases: z6.array(proposedPhaseSchema).default([])
+var proposedItemSchema = z7.strictObject({
+  name: z7.string().trim().min(1, "name is required"),
+  type: z7.enum(["story", "bug"]),
+  description: z7.string().optional(),
+  acceptanceCriteria: z7.array(z7.string().trim().min(1)).default([]),
+  phases: z7.array(proposedPhaseSchema).default([])
 });
 
 // src/commands/backlog/propose/readProposedItem.ts
@@ -8229,19 +8368,19 @@ async function persistPhaseSessionId(itemId2, phaseIdx, claudeSessionId) {
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync19, rmSync as rmSync2, writeFileSync as writeFileSync20 } from "fs";
 import { homedir as homedir11 } from "os";
 import { dirname as dirname18, join as join30 } from "path";
-import { z as z7 } from "zod";
-var activitySchema = z7.object({
-  kind: z7.enum(["command", "backlog"]),
-  harness: z7.enum(["claude", "codex", "pi"]).optional(),
-  name: z7.string().optional(),
-  itemId: z7.number().optional(),
-  itemName: z7.string().optional(),
-  phase: z7.number().optional(),
-  phaseName: z7.string().optional(),
-  totalPhases: z7.number().optional(),
-  claudeSessionId: z7.string().optional(),
-  watchState: z7.enum(["waiting", "updating"]).optional(),
-  startedAt: z7.number()
+import { z as z8 } from "zod";
+var activitySchema = z8.object({
+  kind: z8.enum(["command", "backlog"]),
+  harness: z8.enum(["claude", "codex", "pi"]).optional(),
+  name: z8.string().optional(),
+  itemId: z8.number().optional(),
+  itemName: z8.string().optional(),
+  phase: z8.number().optional(),
+  phaseName: z8.string().optional(),
+  totalPhases: z8.number().optional(),
+  claudeSessionId: z8.string().optional(),
+  watchState: z8.enum(["waiting", "updating"]).optional(),
+  startedAt: z8.number()
 });
 function activityPath(sessionId) {
   return join30(homedir11(), ".assist", "activity", `activity-${sessionId}.json`);
@@ -10258,9 +10397,9 @@ async function update(id, options2) {
 import chalk102 from "chalk";
 
 // src/commands/backlog/updatePlan/planUpdateSchema.ts
-import { z as z8 } from "zod";
-var planUpdateSchema = z8.strictObject({
-  phases: z8.array(proposedPhaseSchema).min(1, "a plan needs at least one phase")
+import { z as z9 } from "zod";
+var planUpdateSchema = z9.strictObject({
+  phases: z9.array(proposedPhaseSchema).min(1, "a plan needs at least one phase")
 });
 
 // src/commands/backlog/updatePlan/readPlanUpdate.ts
@@ -13051,6 +13190,53 @@ var nodesConfigHelp = [
   }
 ];
 
+// src/shared/hotkeys/defaultHotkeys.ts
+var defaultHotkeys = {
+  navTab: ["Alt"],
+  focusSidebar: ["Alt+A"],
+  focusTerminal: ["Alt+S"],
+  toggleDiff: ["Alt+D"],
+  focusRepoPicker: ["Alt+R"],
+  openConfig: ["Alt+W"],
+  openMenu: ["Alt+E"],
+  focusAddAgent: ["Alt+Z"],
+  focusVsCode: ["Alt+X"],
+  focusDone: ["Alt+C"],
+  nextWaiting: ["Mod+."],
+  newSession: ["Mod+N", "Alt+N"],
+  quickOpen: ["Mod+P"],
+  save: ["Mod+S"],
+  shortcutsSheet: ["Mod+/"]
+};
+
+// src/commands/sessions/hotkeysConfigHelp.ts
+var ACTIONS = {
+  navTab: "modifier for the top-level tab digits 1\u2013N (modifiers only, e.g. Ctrl+Alt)",
+  focusSidebar: "focus the active sidebar card",
+  focusTerminal: "focus the active terminal",
+  toggleDiff: "open / close the diff panel, or focus the preview pane",
+  focusRepoPicker: "focus the toolbar repo picker",
+  openConfig: "open the config page",
+  openMenu: "open the hamburger menu",
+  focusAddAgent: "focus the top bar's add agent button",
+  focusVsCode: "focus the top bar's VS Code button",
+  focusDone: "focus the top bar's done button",
+  nextWaiting: "jump to the next waiting session",
+  newSession: "open the new-session dialog",
+  quickOpen: "quick open a file",
+  save: "save the open file",
+  shortcutsSheet: "show the keyboard shortcuts sheet"
+};
+var EXAMPLES = {
+  navTab: "Ctrl+Alt",
+  focusTerminal: "Ctrl+Alt+J"
+};
+var hotkeysConfigHelp = Object.keys(ACTIONS).map((name) => ({
+  key: `sessions.hotkeys.${name}`,
+  setter: `assist config set sessions.hotkeys.${name} ${EXAMPLES[name] ?? defaultHotkeys[name][0]} -g`,
+  note: `${ACTIONS[name]}; default ${defaultHotkeys[name].join(" / ")}`
+}));
+
 // src/commands/sessions/sessionsConfigHelp.ts
 var sessionsConfigHelp = [
   {
@@ -13232,6 +13418,7 @@ var configHelpEntries = [
   ...sessionsConfigHelp,
   ...nodesConfigHelp,
   ...webConfigHelp,
+  ...hotkeysConfigHelp,
   ...slackConfigHelp,
   ...sqlConfigHelp,
   ...transcriptConfigHelp,
@@ -13657,6 +13844,21 @@ async function health(_req, res) {
   });
 }
 
+// src/shared/hotkeys/resolveHotkeys.ts
+function resolveHotkeys(overrides) {
+  const bindings = { ...defaultHotkeys };
+  for (const name of Object.keys(defaultHotkeys)) {
+    const override = overrides?.[name];
+    if (override) bindings[name] = [override];
+  }
+  return bindings;
+}
+
+// src/commands/sessions/web/hotkeyBindings.ts
+function hotkeyBindings(_req, res) {
+  respondJson(res, 200, resolveHotkeys(loadConfig().sessions?.hotkeys));
+}
+
 // src/commands/sessions/web/jiraSite.ts
 function jiraSite(_req, res) {
   const config = loadJson("jira.json");
@@ -17205,6 +17407,7 @@ var routes2 = {
   "GET /api/harness": harnessCapabilities,
   "GET /api/session-layout": sessionLayout,
   "GET /api/session-view": sessionView,
+  "GET /api/hotkeys": hotkeyBindings,
   "GET /api/new-session-defaults": newSessionDefaults,
   "GET /api/pr-status": prStatus,
   "GET /api/server-runs": handleServerRuns,
@@ -25731,37 +25934,37 @@ function stringOrUndefined(value) {
 }
 
 // src/commands/sessions/daemon/persistedSessionSchema.ts
-import { z as z9 } from "zod";
-var persistedSessionSchema = z9.object({
-  id: z9.string().optional(),
-  name: z9.string(),
-  title: z9.string().optional(),
-  generatedTitle: z9.string().optional(),
-  subtitle: z9.string().optional(),
-  commandType: z9.enum(["claude", "run", "assist"]),
-  harness: z9.enum(["claude", "codex", "pi"]).optional(),
-  status: z9.enum(["running", "waiting", "done", "error", "stopped"]).optional(),
-  cwd: z9.string(),
-  startedAt: z9.number(),
-  runningMs: z9.number().optional(),
-  claudeSessionId: z9.string().optional(),
-  harnessSessionId: z9.string().optional(),
-  initialPrompt: z9.string().optional(),
-  runName: z9.string().optional(),
-  runArgs: z9.array(z9.string()).optional(),
-  assistArgs: z9.array(z9.string()).optional(),
+import { z as z10 } from "zod";
+var persistedSessionSchema = z10.object({
+  id: z10.string().optional(),
+  name: z10.string(),
+  title: z10.string().optional(),
+  generatedTitle: z10.string().optional(),
+  subtitle: z10.string().optional(),
+  commandType: z10.enum(["claude", "run", "assist"]),
+  harness: z10.enum(["claude", "codex", "pi"]).optional(),
+  status: z10.enum(["running", "waiting", "done", "error", "stopped"]).optional(),
+  cwd: z10.string(),
+  startedAt: z10.number(),
+  runningMs: z10.number().optional(),
+  claudeSessionId: z10.string().optional(),
+  harnessSessionId: z10.string().optional(),
+  initialPrompt: z10.string().optional(),
+  runName: z10.string().optional(),
+  runArgs: z10.array(z10.string()).optional(),
+  assistArgs: z10.array(z10.string()).optional(),
   activity: activitySchema.optional(),
-  starred: z9.boolean().optional(),
-  watcher: z9.boolean().optional(),
-  divergenceEscalation: z9.boolean().optional(),
-  design: z9.boolean().optional(),
-  auto: z9.boolean().optional(),
-  autoRun: z9.boolean().optional(),
-  autoAdvance: z9.boolean().optional(),
-  reviewStarted: z9.boolean().optional(),
-  launchedFrom: z9.string().optional(),
-  interrupted: z9.object({ reason: z9.string(), at: z9.number() }).optional(),
-  undurable: z9.object({ reason: z9.string(), removesTree: z9.boolean().optional() }).optional()
+  starred: z10.boolean().optional(),
+  watcher: z10.boolean().optional(),
+  divergenceEscalation: z10.boolean().optional(),
+  design: z10.boolean().optional(),
+  auto: z10.boolean().optional(),
+  autoRun: z10.boolean().optional(),
+  autoAdvance: z10.boolean().optional(),
+  reviewStarted: z10.boolean().optional(),
+  launchedFrom: z10.string().optional(),
+  interrupted: z10.object({ reason: z10.string(), at: z10.number() }).optional(),
+  undurable: z10.object({ reason: z10.string(), removesTree: z10.boolean().optional() }).optional()
 });
 
 // src/commands/sessions/daemon/toPersistedSession.ts
@@ -38652,16 +38855,16 @@ function selectPassages(sources, selection) {
 }
 
 // src/commands/transcript/selectionSchema.ts
-import { z as z10 } from "zod";
-var selectionSchema = z10.strictObject({
-  keep: z10.array(
-    z10.strictObject({
-      file: z10.string().trim().min(1, "file is required"),
-      from: z10.string().trim().min(1, "from is required"),
-      to: z10.string().trim().min(1, "to is required")
+import { z as z11 } from "zod";
+var selectionSchema = z11.strictObject({
+  keep: z11.array(
+    z11.strictObject({
+      file: z11.string().trim().min(1, "file is required"),
+      from: z11.string().trim().min(1, "from is required"),
+      to: z11.string().trim().min(1, "to is required")
     })
   ).min(1, "a selection needs at least one keep range"),
-  removed: z10.array(z10.string().trim().min(1)).default([])
+  removed: z11.array(z11.string().trim().min(1)).default([])
 });
 
 // src/commands/transcript/widenAudienceInText.ts
@@ -41076,9 +41279,9 @@ function createAutoExit(exit, graceMs = DEFAULT_GRACE_MS) {
 }
 
 // src/commands/sessions/daemon/loadActiveSelection.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var ACTIVE_FILE = "active.json";
-var activeSelectionSchema = z11.record(z11.string(), z11.string());
+var activeSelectionSchema = z12.record(z12.string(), z12.string());
 function loadActiveSelection() {
   const parsed = activeSelectionSchema.safeParse(
     loadJson(ACTIVE_FILE)
@@ -48282,7 +48485,11 @@ function registerSessions(program2) {
   const webCmd = cmd.command("web").description("Start the sessions web dashboard").option("-p, --port <number>", "Port to listen on", "3100").option("--no-open", "Do not open a browser on startup").action(
     (options2, command) => web({ ...options2, open: command.optsWithGlobals().open })
   );
-  configHelp(webCmd, [...nextConfigHelp, ...webConfigHelp]);
+  configHelp(webCmd, [
+    ...nextConfigHelp,
+    ...webConfigHelp,
+    ...hotkeysConfigHelp
+  ]);
   cmd.command("summarise").description("Generate one-line summaries for Claude sessions").option("-f, --force", "Re-generate all summaries, even existing ones").option("-n, --limit <count>", "Maximum number of sessions to summarise").action(summarise2);
   cmd.command("close").description(
     "Dismiss the current daemon-managed session, ending it and reaping its worktree"