ticketlens 0.11.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/SKILL.md

@@ -1,4 +1,4 @@
-<!-- jtb-skill-version: 0.11.0 -->
+<!-- jtb-skill-version: 0.12.0 -->
 ---
 name: jtb
 description: Fetch a Jira ticket's full context (description, comments, linked issues, code references) and assemble a structured TicketBrief for implementation planning. Use when user types /jtb, mentions a Jira ticket key, or wants to plan work from a Jira ticket.

package/skills/jtb/scripts/lib/config-wizard.mjs

@@ -10,7 +10,7 @@ import { existsSync, mkdirSync } from 'node:fs';
 import { createStyler } from './ansi.mjs';
 import { createSession } from './banner.mjs';
 import { classifyError } from './error-classifier.mjs';
-import { fetchCurrentUser, fetchStatuses } from './jira-client.mjs';
+import { fetchCurrentUser, fetchStatuses, fetchProjects } from './jira-client.mjs';
 import { resolveAdapter } from './resolve-adapter.mjs';
 import { loadProfiles, loadCredentials, saveProfile } from './profile-resolver.mjs';
 import { promptSelect } from './select-prompt.mjs';
@@ -20,6 +20,7 @@ import { DEFAULT_CONFIG_DIR, hostnameOf } from './config.mjs';
 import { visLen, SERVER_AUTH_TYPES, promptText, promptSecret, promptYN } from './prompt-helpers.mjs';
 import { isLicensed } from './license.mjs';
 import { siteBase } from './api-utils.mjs';
+import { pickTicketPrefixes, pickTriageStatuses, DEFAULT_TRIAGE_STATUSES } from './wizard-pickers.mjs';
 
 const RETRY_OPTIONS = [
   { label: 'Retry',             sublabel: 'Try again — same credentials (e.g. VPN just connected)', value: 'retry' },
@@ -272,19 +273,39 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
   // ── Optional settings ──────────────────────────────────────────────────────
   stream.write(`\n  ${s.dim('──── Optional ────')}\n\n`);
 
-  // Ticket prefixes
-  const curPrefixes = (profile.ticketPrefixes || []).join(', ');
-  const prefixInput = await promptText(
-    s.dim('Ticket prefixes') + s.dim(curPrefixes ? `  [current: ${curPrefixes}]:` : '  (e.g. PROJ,OPS — press Enter to skip):'),
-    { stream }
-  );
-  const existing = new Set(profile.ticketPrefixes || []);
-  if (prefixInput) {
-    for (const v of prefixInput.split(',').map(v => v.trim().toUpperCase()).filter(Boolean)) {
-      existing.add(v);
+  // Shared env for post-connection Jira lookups (pickers + fallback validation)
+  const jiraEnv = {
+    JIRA_BASE_URL: url,
+    JIRA_EMAIL: email,
+    JIRA_API_TOKEN: auth !== 'pat' ? token : '',
+    JIRA_PAT: auth === 'pat' ? token : '',
+  };
+  const jiraApiVersion = auth === 'cloud' ? 3 : 2;
+
+  // Ticket prefixes — picked from the instance's project list with current
+  // values pre-checked (replace semantics: deselect removes); legacy add-only
+  // free text when the picker can't run (non-TTY, fetch failure, Esc, non-Jira)
+  let ticketPrefixes = isJira
+    ? await pickTicketPrefixes({
+        fetchProjects: () => fetchProjects({ env: jiraEnv, apiVersion: jiraApiVersion, allowPrivateIp: isTrustedForCurrentUrl() }),
+        current: profile.ticketPrefixes || [],
+        stream,
+      })
+    : null;
+  if (ticketPrefixes === null) {
+    const curPrefixes = (profile.ticketPrefixes || []).join(', ');
+    const prefixInput = await promptText(
+      s.dim('Ticket prefixes') + s.dim(curPrefixes ? `  [current: ${curPrefixes}]:` : '  (e.g. PROJ,OPS — press Enter to skip):'),
+      { stream }
+    );
+    const existing = new Set(profile.ticketPrefixes || []);
+    if (prefixInput) {
+      for (const v of prefixInput.split(',').map(v => v.trim().toUpperCase()).filter(Boolean)) {
+        existing.add(v);
+      }
     }
+    ticketPrefixes = [...existing];
   }
-  const ticketPrefixes = [...existing];
 
   // Project path
   const home = homedir();
@@ -318,76 +339,83 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
     }
   }
 
-  // ── Triage statuses (merge semantics) ────────────────────────────────────
+  // ── Triage statuses ────────────────────────────────────────────────────────
   const currentStatuses = profile.triageStatuses?.length
     ? profile.triageStatuses
-    : ['In Progress', 'Code Review', 'QA'];
-  const curStatusesStr = currentStatuses.join(', ');
+    : DEFAULT_TRIAGE_STATUSES;
+
+  // Picked from the instance's status list with current values pre-checked
+  // (replace semantics: deselect removes, stale entries kept unless unchecked);
+  // legacy add-only merge free text when the picker can't run
+  let triageStatuses = isJira
+    ? await pickTriageStatuses({
+        fetchStatuses: () => fetchStatuses({ env: jiraEnv, apiVersion: jiraApiVersion, allowPrivateIp: isTrustedForCurrentUrl() }),
+        current: currentStatuses,
+        stream,
+      })
+    : null;
 
-  const statusInput = await promptText(
-    s.dim('Add triage statuses') + s.dim(`  [current: ${curStatusesStr} — Enter to keep]:`),
-    { stream }
-  );
+  if (triageStatuses === null) {
+    triageStatuses = currentStatuses;
+    const curStatusesStr = currentStatuses.join(', ');
 
-  let triageStatuses = currentStatuses;
+    const statusInput = await promptText(
+      s.dim('Add triage statuses') + s.dim(`  [current: ${curStatusesStr} — Enter to keep]:`),
+      { stream }
+    );
 
-  if (statusInput) {
-    const newEntries = statusInput.split(',').map(v => v.trim()).filter(Boolean);
-    const existingLower = new Set(currentStatuses.map(n => n.toLowerCase()));
-    const toValidate = newEntries.filter(n => !existingLower.has(n.toLowerCase()));
+    if (statusInput) {
+      const newEntries = statusInput.split(',').map(v => v.trim()).filter(Boolean);
+      const existingLower = new Set(currentStatuses.map(n => n.toLowerCase()));
+      const toValidate = newEntries.filter(n => !existingLower.has(n.toLowerCase()));
 
-    if (toValidate.length > 0) {
-      stream.write(`  ${s.dim('Validating new statuses...')}\n`);
-      try {
-        let available;
-        if (isJira) {
-          const validateEnv = {
-            JIRA_BASE_URL: url,
-            JIRA_EMAIL: email,
-            JIRA_API_TOKEN: auth !== 'pat' ? token : '',
-            JIRA_PAT: auth === 'pat' ? token : '',
-          };
-          available = await fetchStatuses({ env: validateEnv, apiVersion: auth === 'cloud' ? 3 : 2, allowPrivateIp: isTrustedForCurrentUrl() });
-        } else {
-          available = await resolveAdapter({ baseUrl: url, auth: trackerType, apiToken: token }).fetchStatuses();
-        }
+      if (toValidate.length > 0) {
+        stream.write(`  ${s.dim('Validating new statuses...')}\n`);
+        try {
+          let available;
+          if (isJira) {
+            available = await fetchStatuses({ env: jiraEnv, apiVersion: jiraApiVersion, allowPrivateIp: isTrustedForCurrentUrl() });
+          } else {
+            available = await resolveAdapter({ baseUrl: url, auth: trackerType, apiToken: token }).fetchStatuses();
+          }
 
-        const lowerMap = new Map(available.map(n => [n.toLowerCase(), n]));
-        stream.write('\x1b[A\r\x1b[2K');
+          const lowerMap = new Map(available.map(n => [n.toLowerCase(), n]));
+          stream.write('\x1b[A\r\x1b[2K');
 
-        const toAdd = [];
-        for (const name of toValidate) {
-          if (available.includes(name)) {
-            toAdd.push(name);
-            stream.write(`  ${s.green('✔')} ${name}\n`);
-          } else {
-            const exact = lowerMap.get(name.toLowerCase());
-            if (exact) {
-              stream.write(`  ${s.yellow('~')} ${s.dim(name)}  →  ${s.cyan(exact)}\n`);
-              toAdd.push(exact);
+          const toAdd = [];
+          for (const name of toValidate) {
+            if (available.includes(name)) {
+              toAdd.push(name);
+              stream.write(`  ${s.green('✔')} ${name}\n`);
             } else {
-              const partial = available.find(a =>
-                a.toLowerCase().includes(name.toLowerCase()) ||
-                name.toLowerCase().startsWith(a.toLowerCase().split(' ')[0])
-              );
-              if (partial) {
-                stream.write(`  ${s.yellow('~')} ${s.dim(name)}  →  ${s.cyan(partial)}\n`);
-                toAdd.push(partial);
+              const exact = lowerMap.get(name.toLowerCase());
+              if (exact) {
+                stream.write(`  ${s.yellow('~')} ${s.dim(name)}  →  ${s.cyan(exact)}\n`);
+                toAdd.push(exact);
               } else {
-                stream.write(`  ${s.red('✖')} ${name}  ${s.dim('(not found — skipped)')}\n`);
+                const partial = available.find(a =>
+                  a.toLowerCase().includes(name.toLowerCase()) ||
+                  name.toLowerCase().startsWith(a.toLowerCase().split(' ')[0])
+                );
+                if (partial) {
+                  stream.write(`  ${s.yellow('~')} ${s.dim(name)}  →  ${s.cyan(partial)}\n`);
+                  toAdd.push(partial);
+                } else {
+                  stream.write(`  ${s.red('✖')} ${name}  ${s.dim('(not found — skipped)')}\n`);
+                }
               }
             }
           }
-        }
 
-        triageStatuses = [...currentStatuses, ...toAdd];
-        if (toAdd.length > 0) {
-          stream.write(`  ${s.dim('Updated list:')} ${triageStatuses.map(n => s.cyan(n)).join(s.dim(', '))}\n`);
+          triageStatuses = [...currentStatuses, ...toAdd];
+          if (toAdd.length > 0) {
+            stream.write(`  ${s.dim('Updated list:')} ${triageStatuses.map(n => s.cyan(n)).join(s.dim(', '))}\n`);
+          }
+        } catch {
+          stream.write('\x1b[A\r\x1b[2K');
+          // Tracker unreachable — add without validation, deduped
+          triageStatuses = [...currentStatuses, ...toValidate.filter(n => !existingLower.has(n.toLowerCase()))];
         }
-      } catch {
-        stream.write('\x1b[A\r\x1b[2K');
-        // Tracker unreachable — add without validation, deduped
-        triageStatuses = [...currentStatuses, ...toValidate.filter(n => !existingLower.has(n.toLowerCase()))];
       }
     }
   }

package/skills/jtb/scripts/lib/init-wizard.mjs

@@ -9,7 +9,7 @@ import { existsSync, mkdirSync } from 'node:fs';
 import { createStyler } from './ansi.mjs';
 import { createSession } from './banner.mjs';
 import { classifyError } from './error-classifier.mjs';
-import { fetchCurrentUser, fetchStatuses } from './jira-client.mjs';
+import { fetchCurrentUser, fetchStatuses, fetchProjects } from './jira-client.mjs';
 import { loadProfiles, saveProfile, saveDefault } from './profile-resolver.mjs';
 import { resolveAdapter } from './resolve-adapter.mjs';
 import { promptSelect } from './select-prompt.mjs';
@@ -18,6 +18,7 @@ import { renderWordmark } from './wordmark.mjs';
 import { printQuickStart } from './quick-start-panel.mjs';
 import { DEFAULT_CONFIG_DIR, hostnameOf } from './config.mjs';
 import { SERVER_AUTH_TYPES, promptText, promptSecret, promptYN } from './prompt-helpers.mjs';
+import { pickTicketPrefixes, pickTriageStatuses, DEFAULT_TRIAGE_STATUSES } from './wizard-pickers.mjs';
 
 const RETRY_OPTIONS = [
   { label: 'Retry',             sublabel: 'Try again — same credentials (e.g. VPN just connected)', value: 'retry' },
@@ -468,13 +469,20 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
       // ── Optional settings ───────────────────────────────────────────────────
       stream.write(`\n  ${s.dim('──── Optional  (press Enter to skip) ────')}\n\n`);
 
-      // Ticket prefixes
-      const prefixInput = await promptText(
-        s.dim('Ticket prefixes') + s.dim('  (e.g. PROJ,OPS):'), { stream }
-      );
-      const ticketPrefixes = prefixInput
-        ? prefixInput.split(',').map(v => v.trim().toUpperCase()).filter(Boolean)
-        : [];
+      // Ticket prefixes — picked from the instance's project list; free-text
+      // fallback when the picker can't run (non-TTY, fetch failure, Esc)
+      let ticketPrefixes = await pickTicketPrefixes({
+        fetchProjects: () => fetchProjects({ env, apiVersion, allowPrivateIp: isTrustedForCurrentUrl() }),
+        stream,
+      });
+      if (ticketPrefixes === null) {
+        const prefixInput = await promptText(
+          s.dim('Ticket prefixes') + s.dim('  (e.g. PROJ,OPS):'), { stream }
+        );
+        ticketPrefixes = prefixInput
+          ? prefixInput.split(',').map(v => v.trim().toUpperCase()).filter(Boolean)
+          : [];
+      }
 
       // Project path (single — used for auto-profile detection from cwd)
       const home = homedir();
@@ -507,45 +515,55 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
         }
       }
 
-      // Triage statuses — validate against Jira's actual status names
-      const DEFAULT_TRIAGE = 'In Progress, Code Review, QA';
-      const statusInput = await promptText(
-        s.dim('Triage statuses') + s.dim(`  [default: ${DEFAULT_TRIAGE}]:`), { stream }
-      );
-      let triageStatuses = statusInput
-        ? statusInput.split(',').map(v => v.trim()).filter(Boolean)
-        : DEFAULT_TRIAGE.split(',').map(v => v.trim());
+      // Triage statuses — picked from the instance's status list with the
+      // defaults pre-checked (stale defaults dropped, not user data); free-text
+      // + validate fallback when the picker can't run (non-TTY, fetch failure, Esc)
+      let triageStatuses = await pickTriageStatuses({
+        fetchStatuses: () => fetchStatuses({ env, apiVersion, allowPrivateIp: isTrustedForCurrentUrl() }),
+        current: DEFAULT_TRIAGE_STATUSES,
+        preserveMissing: false,
+        stream,
+      });
+      if (triageStatuses === null) {
+        const DEFAULT_TRIAGE = DEFAULT_TRIAGE_STATUSES.join(', ');
+        const statusInput = await promptText(
+          s.dim('Triage statuses') + s.dim(`  [default: ${DEFAULT_TRIAGE}]:`), { stream }
+        );
+        triageStatuses = statusInput
+          ? statusInput.split(',').map(v => v.trim()).filter(Boolean)
+          : [...DEFAULT_TRIAGE_STATUSES];
 
-      stream.write(`  ${s.dim('Validating statuses...')}\n`);
-      try {
-        const available = await fetchStatuses({ env, apiVersion, allowPrivateIp: isTrustedForCurrentUrl() });
-        const lowerMap = new Map(available.map(n => [n.toLowerCase(), n]));
-        stream.write('\x1b[A\r\x1b[2K'); // clear "Validating..." line
-        const corrected = [];
-        let hasIssues = false;
-        for (const name of triageStatuses) {
-          if (available.includes(name)) {
-            corrected.push(name);
-          } else {
-            const match = lowerMap.get(name.toLowerCase());
-            if (match) {
-              stream.write(`  ${s.yellow('~')} ${s.dim(name)}  →  ${s.cyan(match)}\n`);
-              corrected.push(match);
-              hasIssues = true;
+        stream.write(`  ${s.dim('Validating statuses...')}\n`);
+        try {
+          const available = await fetchStatuses({ env, apiVersion, allowPrivateIp: isTrustedForCurrentUrl() });
+          const lowerMap = new Map(available.map(n => [n.toLowerCase(), n]));
+          stream.write('\x1b[A\r\x1b[2K'); // clear "Validating..." line
+          const corrected = [];
+          let hasIssues = false;
+          for (const name of triageStatuses) {
+            if (available.includes(name)) {
+              corrected.push(name);
             } else {
-              stream.write(`  ${s.red('✖')} ${name}  ${s.dim('(not found in this Jira instance)')}\n`);
-              hasIssues = true;
+              const match = lowerMap.get(name.toLowerCase());
+              if (match) {
+                stream.write(`  ${s.yellow('~')} ${s.dim(name)}  →  ${s.cyan(match)}\n`);
+                corrected.push(match);
+                hasIssues = true;
+              } else {
+                stream.write(`  ${s.red('✖')} ${name}  ${s.dim('(not found in this Jira instance)')}\n`);
+                hasIssues = true;
+              }
             }
           }
+          if (!hasIssues) {
+            stream.write(`  ${s.green('✔')} Statuses validated\n`);
+          } else if (corrected.length > 0) {
+            stream.write(`  ${s.dim('Using:')} ${corrected.map(n => s.cyan(n)).join(s.dim(', '))}\n`);
+          }
+          triageStatuses = corrected;
+        } catch {
+          stream.write('\x1b[A\r\x1b[2K'); // clear silently if Jira call fails
         }
-        if (!hasIssues) {
-          stream.write(`  ${s.green('✔')} Statuses validated\n`);
-        } else if (corrected.length > 0) {
-          stream.write(`  ${s.dim('Using:')} ${corrected.map(n => s.cyan(n)).join(s.dim(', '))}\n`);
-        }
-        triageStatuses = corrected;
-      } catch {
-        stream.write('\x1b[A\r\x1b[2K'); // clear silently if Jira call fails
       }
 
       // ── Save ──────────────────────────────────────────────────────────────

package/skills/jtb/scripts/lib/jira-client.mjs

@@ -318,6 +318,50 @@ export async function fetchStatuses(opts = {}) {
   return [...new Set(raw.map(s => s.name))].sort();
 }
 
+/**
+ * Lists projects visible to the authenticated user as [{key, name}], key-sorted.
+ * v2 (Server/DC): GET /project returns the full array in one response.
+ * v3 (Cloud): GET /project/search is paginated — walked until isLast, capped
+ * at MAX_PROJECT_PAGES to bound the walk against a misbehaving server.
+ */
+export async function fetchProjects(opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
+
+  async function getJson(url) {
+    const fetchOpts = { headers };
+    if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+    const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
+    if (!response.ok) {
+      const err = new Error(`Jira API error ${response.status} fetching projects`);
+      err.status = response.status;
+      throw err;
+    }
+    return response.json();
+  }
+
+  const projects = [];
+  if (apiVersion >= 3) {
+    const MAX_PROJECT_PAGES = 10;
+    const PAGE_SIZE = 50;
+    let startAt = 0;
+    for (let page = 0; page < MAX_PROJECT_PAGES; page++) {
+      const params = new URLSearchParams({ startAt: String(startAt), maxResults: String(PAGE_SIZE) });
+      const raw = await getJson(`${baseUrl}/rest/api/3/project/search?${params}`);
+      const values = raw.values ?? [];
+      for (const p of values) projects.push({ key: p.key, name: p.name ?? '' });
+      if (raw.isLast || values.length === 0) break;
+      startAt += values.length;
+    }
+  } else {
+    const raw = await getJson(`${baseUrl}/rest/api/2/project`);
+    for (const p of raw) projects.push({ key: p.key, name: p.name ?? '' });
+  }
+  return projects.sort((a, b) => a.key.localeCompare(b.key));
+}
+
 export async function searchTickets(jql, opts = {}) {
   const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), maxResults = 50, apiVersion = 2, timeoutMs = 10_000, expandChangelog = false, allowPrivateIp = false } = opts;
   validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);

package/skills/jtb/scripts/lib/prompt-helpers.mjs

@@ -30,9 +30,8 @@ export const visLen = (str) => str.replace(ANSI_RE, '').length;
  * then drain. Call this — and await it — before starting any new raw-mode
  * prompt.
  */
-export function flushStdin() {
+export function flushStdin(stdin = process.stdin) {
   return new Promise((resolve) => {
-    const stdin = process.stdin;
     if (typeof stdin.read !== 'function' || typeof stdin.resume !== 'function') {
       resolve();
       return;

package/skills/jtb/scripts/lib/select-prompt.mjs

@@ -1,6 +1,7 @@
 /**
- * Reusable raw-mode selector primitive and simple promptSelect helper.
- * Used by profile-picker.mjs, profile-switcher.mjs, and init-wizard.mjs.
+ * Reusable raw-mode selector primitives: single-select and multi-select.
+ * Used by profile-picker.mjs, profile-switcher.mjs, init-wizard.mjs,
+ * config-wizard.mjs, and wizard-pickers.mjs.
  */
 
 import { createStyler } from './ansi.mjs';
@@ -16,10 +17,15 @@ import { flushStdin } from './prompt-helpers.mjs';
  * @param {number} [opts.initialIndex=0]
  * @param {(index: number) => number} opts.renderFn
  * @param {NodeJS.WriteStream} [opts.stream=process.stderr]
+ * @param {NodeJS.ReadStream} [opts.stdin=process.stdin] injectable for tests
+ * @param {(key: string, index: number) => 'veto'|boolean} [opts.onKey]
+ *   Hook for extra keys. Called for Enter before submit — return 'veto' to
+ *   swallow it and keep the selector open. For any other unhandled key,
+ *   return truthy to re-render. Falsy = key ignored.
  * @returns {Promise<number|null>} selected index, or null if cancelled
  */
-export function runRawSelect({ count, initialIndex = 0, renderFn, stream = process.stderr }) {
-  if (!stream.isTTY || !process.stdin.setRawMode) return Promise.resolve(null);
+export function runRawSelect({ count, initialIndex = 0, renderFn, stream = process.stderr, stdin = process.stdin, onKey }) {
+  if (!stream.isTTY || !stdin.setRawMode) return Promise.resolve(null);
 
   let selected = initialIndex;
   let lineCount = 0;
@@ -34,8 +40,7 @@ export function runRawSelect({ count, initialIndex = 0, renderFn, stream = proce
   }
 
   stream.write('\x1b[?25l');
-  return flushStdin().then(() => new Promise((resolve) => {
-    const stdin = process.stdin;
+  return flushStdin(stdin).then(() => new Promise((resolve) => {
     const wasRaw = stdin.isRaw;
 
     function cleanup() {
@@ -52,7 +57,11 @@ export function runRawSelect({ count, initialIndex = 0, renderFn, stream = proce
       }
       if (key === '\x1b[A' && selected > 0) { selected--; render(); return; }
       if (key === '\x1b[B' && selected < count - 1) { selected++; render(); return; }
-      if (key === '\r' || key === '\n') { cleanup(); erase(); resolve(selected); return; }
+      if (key === '\r' || key === '\n') {
+        if (onKey && onKey(key, selected) === 'veto') { render(); return; }
+        cleanup(); erase(); resolve(selected); return;
+      }
+      if (onKey && onKey(key, selected)) { render(); return; }
     }
 
     stdin.setRawMode(true);
@@ -105,3 +114,88 @@ export function promptSelect(items, opts = {}) {
 
   return runRawSelect({ count: items.length, initialIndex, renderFn, stream });
 }
+
+/**
+ * Arrow-key multi-select with checkboxes and a scrolling viewport.
+ * Space toggles the highlighted row, `a` toggles all, Enter confirms,
+ * Esc cancels (returns null — callers treat that as "enter manually").
+ *
+ * @param {Array<{label: string}>} items
+ * @param {object} [opts]
+ * @param {number[]} [opts.initialSelected=[]] pre-checked item indices
+ * @param {number} [opts.minSelected=0] Enter is vetoed below this count
+ * @param {number} [opts.maxVisible=10] viewport height for long lists
+ * @param {string} [opts.hint]
+ * @param {NodeJS.WriteStream} [opts.stream]
+ * @param {NodeJS.ReadStream} [opts.stdin] injectable for tests
+ * @returns {Promise<number[]|null>} checked indices in list order, or null if cancelled
+ */
+export function promptMultiSelect(items, opts = {}) {
+  const {
+    stream = process.stderr,
+    stdin = process.stdin,
+    hint = '↑/↓ move   Space toggle   a all   Enter confirm   Esc manual entry',
+    initialSelected = [],
+    minSelected = 0,
+    maxVisible = 10,
+  } = opts;
+
+  const s = createStyler({ isTTY: stream.isTTY });
+
+  if (!stream.isTTY || !stdin.setRawMode) {
+    for (const item of items) stream.write(`    ${s.cyan('›')} ${item.label}\n`);
+    return Promise.resolve(null);
+  }
+
+  const checked = new Set(initialSelected.filter(i => i >= 0 && i < items.length));
+  let scrollTop = 0;
+  let flash = '';
+
+  function renderFn(selected) {
+    if (selected >= scrollTop + maxVisible) scrollTop = selected - maxVisible + 1;
+    if (selected < scrollTop) scrollTop = selected;
+    const visibleEnd = Math.min(scrollTop + maxVisible, items.length);
+
+    const lines = [];
+    for (let i = scrollTop; i < visibleEnd; i++) {
+      const isSelected = i === selected;
+      const marker = isSelected ? s.blue('❯') : ' ';
+      const box = checked.has(i) ? s.green('◉') : s.dim('○');
+      const label = isSelected ? s.bold(s.blue(items[i].label)) : items[i].label;
+      lines.push(`    ${marker} ${box} ${label}`);
+    }
+    if (items.length > maxVisible) {
+      lines.push(`      ${s.dim(`${scrollTop + 1}-${visibleEnd} of ${items.length}`)}`);
+    }
+    lines.push('');
+    lines.push(`  ${s.dim(hint)}${flash ? '   ' + s.yellow(flash) : ''}`);
+    stream.write(lines.join('\n') + '\n');
+    return lines.length;
+  }
+
+  function onKey(key, selected) {
+    if (key === ' ') {
+      flash = '';
+      if (checked.has(selected)) checked.delete(selected);
+      else checked.add(selected);
+      return true;
+    }
+    if (key === 'a' || key === 'A') {
+      flash = '';
+      if (checked.size === items.length) checked.clear();
+      else for (let i = 0; i < items.length; i++) checked.add(i);
+      return true;
+    }
+    if (key === '\r' || key === '\n') {
+      if (checked.size < minSelected) {
+        flash = `select at least ${minSelected}`;
+        return 'veto';
+      }
+      return false;
+    }
+    return false;
+  }
+
+  return runRawSelect({ count: items.length, renderFn, stream, stdin, onKey })
+    .then(result => (result === null ? null : [...checked].sort((a, b) => a - b)));
+}

package/skills/jtb/scripts/lib/wizard-pickers.mjs

@@ -0,0 +1,132 @@
+/**
+ * Shared prefix/status picker steps for init-wizard.mjs and config-wizard.mjs.
+ * Live-fetched multi-select over the connected Jira instance's projects and
+ * statuses. Every picker returns string[] on confirm, or null when the picker
+ * cannot run (non-TTY, fetch failure, empty server list) or the user hits Esc
+ * — callers treat null as "use the legacy free-text prompt".
+ */
+
+import { createStyler } from './ansi.mjs';
+import { promptMultiSelect } from './select-prompt.mjs';
+
+export const DEFAULT_TRIAGE_STATUSES = ['In Progress', 'Code Review', 'QA'];
+
+/**
+ * Builds picker rows from server values plus the user's current selections.
+ * Matching is case-insensitive; rows echo the server's canonical casing so a
+ * confirm fixes case drift in the profile. Current values missing from the
+ * server are appended as marked, pre-checked rows when preserveMissing is on
+ * (edit flows — user data is never silently dropped) and skipped when off
+ * (init flows — stale defaults are not user data).
+ */
+function buildRows({ serverValues, labels, current, preserveMissing, s }) {
+  const values = [...serverValues];
+  const rows = serverValues.map((v, i) => ({ label: labels[i] }));
+  const serverLower = new Set(serverValues.map(v => v.toLowerCase()));
+
+  const staleSeen = new Set(); // legacy free-text merge never deduped within itself
+  for (const cur of current) {
+    const lower = cur.toLowerCase();
+    if (preserveMissing && !serverLower.has(lower) && !staleSeen.has(lower)) {
+      staleSeen.add(lower);
+      values.push(cur);
+      rows.push({ label: `${cur}  ${s.dim('(not on server)')}` });
+    }
+  }
+
+  const currentLower = new Set(current.map(c => c.toLowerCase()));
+  const initialSelected = values
+    .map((v, i) => (currentLower.has(v.toLowerCase()) ? i : -1))
+    .filter(i => i >= 0);
+
+  return { values, rows, initialSelected };
+}
+
+/**
+ * Fetches via fetchFn behind a clearable progress line. Returns the list, or
+ * null after printing a fallback warning (raw error details stay internal —
+ * the connection already tested fine, so this is a transient/permission issue).
+ */
+async function fetchForPicker(fetchFn, { what, stream, s }) {
+  stream.write(`  ${s.dim(`Fetching ${what}...`)}\n`);
+  try {
+    const list = await fetchFn();
+    stream.write('\x1b[A\r\x1b[2K');
+    return list;
+  } catch {
+    stream.write('\x1b[A\r\x1b[2K');
+    stream.write(`  ${s.yellow('~')} Could not fetch ${what} — enter manually\n`);
+    return null;
+  }
+}
+
+function writeConfirmation(chosen, { stream, s }) {
+  stream.write(`  ${s.green('✔')} ${chosen.length ? chosen.map(v => s.cyan(v)).join(s.dim(', ')) : s.dim('none')}\n`);
+}
+
+/**
+ * Multi-select over the instance's projects; returns the chosen project keys.
+ *
+ * @param {object} opts
+ * @param {() => Promise<Array<{key: string, name: string}>>} opts.fetchProjects
+ *   pre-bound by the caller — env/apiVersion/allowPrivateIp trust stays there
+ * @param {string[]} [opts.current=[]] pre-checked prefixes (edit flow)
+ * @param {boolean} [opts.preserveMissing=true]
+ * @returns {Promise<string[]|null>} chosen keys, or null → free-text fallback
+ */
+export async function pickTicketPrefixes({ fetchProjects, current = [], preserveMissing = true, stream = process.stderr, stdin = process.stdin } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  if (!stream.isTTY || !stdin.setRawMode) return null;
+
+  const projects = await fetchForPicker(fetchProjects, { what: 'projects', stream, s });
+  if (projects === null || projects.length === 0) return null;
+
+  const { values, rows, initialSelected } = buildRows({
+    serverValues: projects.map(p => p.key),
+    labels: projects.map(p => (p.name ? `${p.key} ${s.dim('—')} ${p.name}` : p.key)),
+    current,
+    preserveMissing,
+    s,
+  });
+
+  stream.write(`  ${s.dim('Ticket prefixes')}  ${s.dim('(projects on this instance)')}\n\n`);
+  const picked = await promptMultiSelect(rows, { initialSelected, stream, stdin });
+  if (picked === null) return null;
+
+  const chosen = picked.map(i => values[i]);
+  writeConfirmation(chosen, { stream, s });
+  return chosen;
+}
+
+/**
+ * Multi-select over the instance's status names; at least one required.
+ *
+ * @param {object} opts
+ * @param {() => Promise<string[]>} opts.fetchStatuses pre-bound by the caller
+ * @param {string[]} [opts.current=[]] pre-checked statuses
+ * @param {boolean} [opts.preserveMissing=true]
+ * @returns {Promise<string[]|null>} chosen names, or null → free-text fallback
+ */
+export async function pickTriageStatuses({ fetchStatuses, current = [], preserveMissing = true, stream = process.stderr, stdin = process.stdin } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  if (!stream.isTTY || !stdin.setRawMode) return null;
+
+  const available = await fetchForPicker(fetchStatuses, { what: 'statuses', stream, s });
+  if (available === null || available.length === 0) return null;
+
+  const { values, rows, initialSelected } = buildRows({
+    serverValues: available,
+    labels: available,
+    current,
+    preserveMissing,
+    s,
+  });
+
+  stream.write(`  ${s.dim('Triage statuses')}  ${s.dim('(statuses on this instance)')}\n\n`);
+  const picked = await promptMultiSelect(rows, { initialSelected, minSelected: 1, stream, stdin });
+  if (picked === null) return null;
+
+  const chosen = picked.map(i => values[i]);
+  writeConfirmation(chosen, { stream, s });
+  return chosen;
+}