ticketlens 0.10.18 → 0.12.0

package/README.md

@@ -79,7 +79,7 @@ Tip: `tl` works everywhere `ticketlens` does — running `tl`/`ticketlens config
 | `ticketlens profiles` | List all configured profiles (alias: `ticketlens ls`) |
 | `ticketlens delete <NAME>` | Remove a profile and its credentials (prompts `y/N` in TTY; use `--yes` in scripts/CI) |
 
-`init` collects: profile name, tracker type (Jira / GitHub Issues / Linear), URL or workspace, credentials (masked), and optional ticket prefixes, project paths, and triage statuses. On connection failure, a retry menu lets you fix credentials, URL, or skip — all inputs pre-populated. `config` is tracker-aware and always re-validates the connection after edits.
+`init` collects: profile name, tracker type (Jira / GitHub Issues / Linear), URL or workspace, credentials (masked), and optional ticket prefixes, project paths, and triage statuses. On connection failure, a retry menu lets you fix credentials, URL, or skip — all inputs pre-populated. If your Jira instance sits behind a VPN and resolves to a private/internal address, you'll be asked to confirm you trust that connection before it's allowed through — a one-time confirmation, remembered per profile and scoped to that exact host (changing the URL asks again). `config` is tracker-aware and always re-validates the connection after edits.
 
 `config` uses merge semantics: new ticket prefixes and triage statuses are added to existing lists, never replaced. Partial matching resolves `QA` to `QA Testing` if that's the status in your Jira.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.10.18",
+  "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.10.18 -->
+<!-- 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/fetch-ticket.mjs

@@ -1134,7 +1134,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
       const authHeader = buildAuthHeader(jiraEnv);
       const apiVersion = conn.auth === 'cloud' ? 3 : 2;
       const jiraOrigin = new URL(jiraEnv.JIRA_BASE_URL).origin;
-      const links = await fetchRemoteLinks(ticketKey, { env: jiraEnv, fetcher, apiVersion });
+      const links = await fetchRemoteLinks(ticketKey, { env: jiraEnv, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp });
       const MAX_CONFLUENCE_PAGES = 10;
       const safeLinks = links
         .filter(l => { try { return new URL(l.url).origin === jiraOrigin; } catch { return false; } })
@@ -1189,6 +1189,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
         fetcher,
         noCache: args.includes('--no-cache'),
         onProgress: (msg) => process.stderr.write(msg + '\n'),
+        allowPrivateIp: conn.allowPrivateIp,
       });
       const downloaded = ticket.localAttachments.filter(r => !r.skipped).length;
       const cached = ticket.localAttachments.filter(r => r.skipReason === 'cached').length;

package/skills/jtb/scripts/lib/adapters/jira-adapter.mjs

@@ -11,9 +11,9 @@ export function createJiraAdapter(conn, { fetcher = globalThis.fetch } = {}) {
 
   return {
     type: 'jira',
-    fetchTicket: (key, opts = {}) => fetchTicket(key, { env, fetcher, apiVersion, ...opts }),
-    fetchCurrentUser: (opts = {}) => fetchCurrentUser({ env, fetcher, apiVersion, ...opts }),
-    searchTickets: (query, opts = {}) => searchTickets(query, { env, fetcher, apiVersion, ...opts }),
-    fetchStatuses: (opts = {}) => fetchStatuses({ env, fetcher, apiVersion, ...opts }),
+    fetchTicket: (key, opts = {}) => fetchTicket(key, { env, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp, ...opts }),
+    fetchCurrentUser: (opts = {}) => fetchCurrentUser({ env, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp, ...opts }),
+    searchTickets: (query, opts = {}) => searchTickets(query, { env, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp, ...opts }),
+    fetchStatuses: (opts = {}) => fetchStatuses({ env, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp, ...opts }),
   };
 }

package/skills/jtb/scripts/lib/attachment-downloader.mjs

@@ -20,10 +20,15 @@ const MAX_REDIRECT_HOPS = 2;
  * code-review remediation). Auth headers are only ever sent on the initial
  * request — every hop after that is auth-less, matching Jira Cloud's
  * presigned-URL CDN redirect model.
+ *
+ * `allowPrivateIp` only ever applies to the initial hop (the user's own
+ * trusted Jira origin). A redirect target is server-controlled — a
+ * categorically different trust domain — so it is never passed through,
+ * regardless of the caller's trust level.
  */
-async function followValidatedRedirects(initialUrl, fetcher, lookup, headers) {
+async function followValidatedRedirects(initialUrl, fetcher, lookup, headers, allowPrivateIp = false) {
   let url = initialUrl;
-  await validateResolvedHost(new URL(url).hostname, lookup);
+  await validateResolvedHost(new URL(url).hostname, lookup, allowPrivateIp);
   let response = await fetcher(url, { headers, redirect: 'manual' });
   let hops = 0;
   while (response.status >= 300 && response.status < 400) {
@@ -53,6 +58,7 @@ async function followValidatedRedirects(initialUrl, fetcher, lookup, headers) {
  * @param {string} opts.configDir Base config dir (default: ~/.ticketlens)
  * @param {boolean} opts.noCache  Force re-download even if cached (default: false)
  * @param {Function} opts.onProgress  Optional callback(msg: string) for progress lines
+ * @param {boolean} opts.allowPrivateIp  Skip the private-IP DNS check on the initial hop only (default: false)
  *
  * @returns {Promise<Array<{filename, mimeType, size, localPath, skipped, skipReason, error}>>}
  */
@@ -64,6 +70,7 @@ export async function downloadAttachments(ticket, opts = {}) {
     configDir = DEFAULT_CONFIG_DIR,
     noCache = false,
     onProgress = null,
+    allowPrivateIp = false,
   } = opts;
 
   const attachments = (ticket.attachments ?? []).filter(a => a.content);
@@ -118,7 +125,7 @@ export async function downloadAttachments(ticket, opts = {}) {
       onProgress?.(`  download  ${a.filename}`);
       try {
         const headers = buildAuthHeader(env);
-        const response = await followValidatedRedirects(a.content, fetcher, lookup, headers);
+        const response = await followValidatedRedirects(a.content, fetcher, lookup, headers, allowPrivateIp);
         if (!response.ok) throw new Error(`HTTP ${response.status} (${response.statusText})`);
         const buffer = await response.arrayBuffer();
         fs.writeFileSync(localPath, Buffer.from(buffer));

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

@@ -10,16 +10,17 @@ 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';
 import { parseAge } from './cache-manager.mjs';
 import { DEFAULT_BRIEF_TTL } from './brief-cache.mjs';
-import { DEFAULT_CONFIG_DIR } from './config.mjs';
+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' },
@@ -103,6 +104,10 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
   let email = profile.email || '';
   const existingToken = profileCreds.pat || profileCreds.apiToken || '';
   let token = existingToken;
+  // Trust is bound to the exact hostname it was granted for — never a flat
+  // per-profile boolean. Editing the URL to a different host must re-trigger
+  // the private-IP block and a fresh "Trust this connection?" prompt.
+  let trustedHostname = (profile.allowPrivateIp && hostnameOf(profile.baseUrl)) || null;
 
   // ── URL ───────────────────────────────────────────────────────────────────
   const urlTyped = await promptText(
@@ -158,6 +163,24 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
   let connected = false;
   let startFrom = 'test';
 
+  function isTrustedForCurrentUrl() {
+    return trustedHostname !== null && hostnameOf(url) === trustedHostname;
+  }
+
+  async function attemptConnection() {
+    if (isJira) {
+      const testEnv = {
+        JIRA_BASE_URL: url,
+        JIRA_EMAIL: email,
+        JIRA_API_TOKEN: auth !== 'pat' ? token : '',
+        JIRA_PAT: auth === 'pat' ? token : '',
+      };
+      await fetchCurrentUser({ env: testEnv, apiVersion: auth === 'cloud' ? 3 : 2, allowPrivateIp: isTrustedForCurrentUrl() });
+    } else {
+      await resolveAdapter({ baseUrl: url, auth: trackerType, apiToken: token }).fetchCurrentUser();
+    }
+  }
+
   setupLoop: while (true) {
     // Re-prompt URL + auth (on retry with 'url' option)
     if (startFrom === 'url') {
@@ -216,17 +239,7 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
       session.spin('Testing connection...');
 
       try {
-        if (isJira) {
-          const testEnv = {
-            JIRA_BASE_URL: url,
-            JIRA_EMAIL: email,
-            JIRA_API_TOKEN: auth !== 'pat' ? token : '',
-            JIRA_PAT: auth === 'pat' ? token : '',
-          };
-          await fetchCurrentUser({ env: testEnv, apiVersion: auth === 'cloud' ? 3 : 2 });
-        } else {
-          await resolveAdapter({ baseUrl: url, auth: trackerType, apiToken: token }).fetchCurrentUser();
-        }
+        await attemptConnection();
         session.connected();
         connected = true;
         break setupLoop;
@@ -234,6 +247,15 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
         session.failed();
         const classified = classifyError(err, { baseUrl: url, profileName: target });
         session.footer(classified.message, 'error', classified.hint);
+
+        if (classified.privateIpBlocked) {
+          const trust = await promptYN('Trust this connection?', { stream });
+          if (trust) {
+            trustedHostname = hostnameOf(url);
+            startFrom = 'test';
+            continue setupLoop;
+          }
+        }
       }
 
       stream.write(`\n  ${s.dim('What would you like to do?')}\n\n`);
@@ -251,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();
@@ -297,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 });
-        } 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()))];
       }
     }
   }
@@ -397,6 +446,8 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
   else delete updated.projectPaths;
   if (cacheTtl && cacheTtl !== DEFAULT_BRIEF_TTL) updated.cacheTtl = cacheTtl;
   else delete updated.cacheTtl;
+  if (isTrustedForCurrentUrl()) updated.allowPrivateIp = true;
+  else delete updated.allowPrivateIp;
 
   const credData = (token !== existingToken)
     ? (auth === 'pat' ? { pat: token } : { apiToken: token })

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

@@ -68,6 +68,12 @@ export function stripCr(str) {
   return str.replace(/\r/g, '');
 }
 
+/** Parse a URL's hostname, or null if unparseable. Used to scope trust
+ * grants (e.g. allowPrivateIp) to the exact host they were confirmed for. */
+export function hostnameOf(url) {
+  try { return new URL(url).hostname; } catch { return null; }
+}
+
 /**
  * Build the env-like object expected by jira-client functions.
  * @param {{ baseUrl: string, pat?: string, email?: string, apiToken?: string }} conn

package/skills/jtb/scripts/lib/connection-tester.mjs

@@ -29,6 +29,7 @@ export async function testConnections({
       email: profile.email,
       apiToken: profileCreds.apiToken,
       pat: profileCreds.pat,
+      allowPrivateIp: profile.allowPrivateIp,
     };
 
     const session = createSession(

package/skills/jtb/scripts/lib/error-classifier.mjs

@@ -18,6 +18,15 @@ export function classifyError(err, { baseUrl, profileName } = {}) {
   const profile = profileName || 'your profile';
   const code = getNetworkCode(err);
 
+  if (err.code === 'PRIVATE_IP_BLOCKED') {
+    const address = err.blockedAddress ? ` (${err.blockedAddress})` : '';
+    return {
+      message: `${err.blockedHostname} resolves to a private address${address}`,
+      hint: "This is expected if you're on a VPN connecting to an on-prem Jira instance. It could also mean something is wrong.",
+      privateIpBlocked: true,
+    };
+  }
+
   // Network-level errors (fetch threw before getting an HTTP response)
   if (code === 'ENOTFOUND' || code === 'EAI_AGAIN') {
     return {

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

@@ -9,15 +9,16 @@ 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';
 import { runSwitch } from './profile-switcher.mjs';
 import { renderWordmark } from './wordmark.mjs';
 import { printQuickStart } from './quick-start-panel.mjs';
-import { DEFAULT_CONFIG_DIR } from './config.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' },
@@ -328,6 +329,12 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
     let baseUrl = '', authType = '', email = '', token = '';
     let env = {}, apiVersion = 2;
     let startFrom = 'url';
+    // Trust is bound to the exact hostname it was granted for — never a flat
+    // per-run boolean. Choosing "Edit from URL" after granting trust for one
+    // host must re-trigger the private-IP block and a fresh confirmation
+    // for the new host, not silently inherit trust.
+    let trustedHostname = null;
+    const isTrustedForCurrentUrl = () => trustedHostname !== null && hostnameOf(baseUrl) === trustedHostname;
 
     setupLoop: while (true) {
       // ── URL + auth type ────────────────────────────────────────────────────
@@ -432,7 +439,7 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
       session.spin('Testing connection...');
 
       try {
-        await fetchCurrentUser({ env, apiVersion });
+        await fetchCurrentUser({ env, apiVersion, allowPrivateIp: isTrustedForCurrentUrl() });
         session.connected();
         connected = true;
         break setupLoop;
@@ -440,6 +447,15 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
         session.failed();
         const classified = classifyError(err, { baseUrl, profileName });
         session.footer(classified.message, 'error', classified.hint);
+
+        if (classified.privateIpBlocked) {
+          const trust = await promptYN('Trust this connection?', { stream });
+          if (trust) {
+            trustedHostname = hostnameOf(baseUrl);
+            startFrom = 'retry';
+            continue setupLoop;
+          }
+        }
       }
 
       // ── Retry options ──────────────────────────────────────────────────────
@@ -453,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();
@@ -492,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 });
-        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 ──────────────────────────────────────────────────────────────
@@ -540,6 +573,7 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
         ...(email ? { email } : {}),
         ...(ticketPrefixes.length > 0 ? { ticketPrefixes } : {}),
         ...(projectPaths.length > 0 ? { projectPaths } : {}),
+        ...(isTrustedForCurrentUrl() ? { allowPrivateIp: true } : {}),
         triageStatuses,
       };
       const credData = authType === 'pat' ? { pat: token } : { apiToken: token };

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

@@ -125,7 +125,14 @@ function normalizeHostname(hostname) {
   return hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '');
 }
 
-export function validateBaseUrl(url) {
+/**
+ * @param {string} url
+ * @param {boolean} [allowPrivateIp] - skip the private/internal blocklist check
+ *   for THIS hostname. Set only via explicit interactive user confirmation
+ *   during setup, persisted per-profile — never from synced/network data
+ *   (see team-jira-sync.mjs). HTTPS enforcement is never skippable.
+ */
+export function validateBaseUrl(url, allowPrivateIp = false) {
   let parsed;
   try { parsed = new URL(url); } catch {
     throw new Error(`JIRA_BASE_URL is not a valid URL: ${url}`);
@@ -133,9 +140,14 @@ export function validateBaseUrl(url) {
   if (parsed.protocol !== 'https:') {
     throw new Error(`JIRA_BASE_URL must use HTTPS (got ${parsed.protocol})`);
   }
+  if (allowPrivateIp) return;
   const hostname = normalizeHostname(parsed.hostname);
   if (BLOCKED_PATTERNS.some(re => re.test(hostname))) {
-    throw new Error(`JIRA_BASE_URL hostname is blocked (${hostname})`);
+    const err = new Error(`JIRA_BASE_URL hostname is blocked (${hostname})`);
+    err.code = 'PRIVATE_IP_BLOCKED';
+    err.blockedHostname = hostname;
+    err.blockedAddress = null;
+    throw err;
   }
 }
 
@@ -189,9 +201,17 @@ const dnsValidationCaches = new WeakMap();
  * `lookup` is null when the fetcher is mocked (tests) — no socket opens, so
  * there is nothing to protect. Production always uses globalThis.fetch, which
  * always gets the real resolver (see defaultLookupFor).
+ *
+ * `allowPrivateIp` skips the lookup entirely (not just the block) when a
+ * profile has an explicit, user-confirmed trust exception for this exact
+ * hostname — set only during interactive setup, never from synced/network
+ * data. Skipping the resolution outright (rather than resolving-then-
+ * ignoring) avoids the DNS round-trip and sidesteps any question of how the
+ * per-lookup-fn cache should key on a flag that no real caller varies
+ * concurrently for the same hostname.
  */
-export async function validateResolvedHost(hostname, lookup) {
-  if (!lookup) return;
+export async function validateResolvedHost(hostname, lookup, allowPrivateIp = false) {
+  if (!lookup || allowPrivateIp) return;
   let cache = dnsValidationCaches.get(lookup);
   if (!cache) {
     cache = new Map();
@@ -202,7 +222,11 @@ export async function validateResolvedHost(hostname, lookup) {
       const addresses = await lookup(hostname, { all: true });
       for (const { address } of addresses) {
         if (BLOCKED_PATTERNS.some(re => re.test(address))) {
-          throw new Error(`Hostname ${hostname} resolves to a blocked address (${address}) — refusing to connect`);
+          const err = new Error(`Hostname ${hostname} resolves to a blocked address (${address}) — refusing to connect`);
+          err.code = 'PRIVATE_IP_BLOCKED';
+          err.blockedHostname = hostname;
+          err.blockedAddress = address;
+          throw err;
         }
       }
     })();
@@ -223,8 +247,8 @@ export async function validateResolvedHost(hostname, lookup) {
  * Error message carries the redirect target's HOSTNAME only — Location values
  * can contain presigned tokens in path/query.
  */
-export async function guardedFetch(url, fetchOpts, { fetcher, lookup }) {
-  await validateResolvedHost(new URL(url).hostname, lookup);
+export async function guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp = false }) {
+  await validateResolvedHost(new URL(url).hostname, lookup, allowPrivateIp);
   const response = await fetcher(url, { ...fetchOpts, redirect: 'manual' });
   if (response.status >= 300 && response.status < 400) {
     let target = 'unknown host';
@@ -248,15 +272,15 @@ export function buildAuthHeader(env) {
 }
 
 export async function fetchCurrentUser(opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  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' };
 
   const url = `${baseUrl}/rest/api/${apiVersion}/myself`;
   const fetchOpts = { headers };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
 
   if (!response.ok) {
     const err = new Error(`Jira API error ${response.status} fetching current user`);
@@ -274,15 +298,15 @@ export async function fetchCurrentUser(opts = {}) {
 }
 
 export async function fetchStatuses(opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  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' };
 
   const url = `${baseUrl}/rest/api/${apiVersion}/status`;
   const fetchOpts = { headers };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
 
   if (!response.ok) {
     const err = new Error(`Jira API error ${response.status} fetching statuses`);
@@ -294,9 +318,53 @@ 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 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  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);
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
   const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
 
@@ -307,7 +375,7 @@ export async function searchTickets(jql, opts = {}) {
   const url = `${baseUrl}${endpoint}?${params}`;
   const fetchOpts = { headers };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
 
   if (!response.ok) {
     let detail = '';
@@ -323,15 +391,15 @@ export async function searchTickets(jql, opts = {}) {
 }
 
 export async function fetchRemoteLinks(ticketKey, opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  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 url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}/remotelink`;
 
   const fetchOpts = { headers: { ...buildAuthHeader(env), 'Content-Type': 'application/json' } };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
 
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
   if (!response.ok) return [];
 
   const raw = await response.json();
@@ -341,8 +409,8 @@ export async function fetchRemoteLinks(ticketKey, opts = {}) {
 }
 
 export async function fetchTicket(ticketKey, opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), depth = 1, apiVersion = 2, timeoutMs = 10_000, expandChangelog = false, _visited = new Set(), _currentDepth = 0 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), depth = 1, apiVersion = 2, timeoutMs = 10_000, expandChangelog = false, allowPrivateIp = false, _visited = new Set(), _currentDepth = 0 } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
   const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
 
@@ -350,7 +418,7 @@ export async function fetchTicket(ticketKey, opts = {}) {
   const url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}${expand}`;
   const fetchOpts = { headers };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
 
   if (!response.ok) {
     const err = new Error(`Jira API error ${response.status} fetching ${ticketKey}`);

package/skills/jtb/scripts/lib/profile-resolver.mjs

@@ -233,6 +233,7 @@ export function resolveConnection(ticketKey, opts = {}) {
       ticketPrefixes: profile.ticketPrefixes || null,
       attentionRules: profile.attentionRules ?? null,
       staleRule: profile.staleRule ?? null,
+      allowPrivateIp: profile.allowPrivateIp || false,
       source: 'profile',
       profileName: profile.name,
     };

package/skills/jtb/scripts/lib/profile-switcher.mjs

@@ -118,6 +118,7 @@ export async function runSwitch({ configDir = DEFAULT_CONFIG_DIR, stream = proce
     JIRA_PAT: profileCreds.pat || '',
   };
   const apiVersion = profile.auth === 'cloud' ? 3 : 2;
+  const allowPrivateIp = profile.allowPrivateIp;
 
   let frame = 0;
   const spinLine = () => `  ${s.cyan(SPINNER_FRAMES[frame])} Connecting to ${s.bold(chosen.name)}...`;
@@ -129,7 +130,7 @@ export async function runSwitch({ configDir = DEFAULT_CONFIG_DIR, stream = proce
   }, 80);
 
   try {
-    await fetchCurrentUser({ env, apiVersion });
+    await fetchCurrentUser({ env, apiVersion, allowPrivateIp });
     clearInterval(timer);
     stream.write('\r\x1b[2K\x1b[A\r\x1b[2K');
     await saveDefault(chosen.name, configDir);

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/team-jira-sync.mjs

@@ -9,7 +9,7 @@ import { join } from 'node:path';
 import { readCliToken } from './cli-auth.mjs';
 import { saveProfile, loadProfiles } from './profile-resolver.mjs';
 import { apiBase } from './api-utils.mjs';
-import { DEFAULT_CONFIG_DIR } from './config.mjs';
+import { DEFAULT_CONFIG_DIR, hostnameOf } from './config.mjs';
 
 const META_FILE = 'team-jira-meta.json';
 
@@ -78,11 +78,23 @@ function teamConfigToCliProfile(apiData) {
 
 /**
  * Writes team config to the named profile without touching credentials.
+ * Carries forward `allowPrivateIp` from the existing LOCAL profile only —
+ * never from server data (see teamConfigToCliProfile) — and only when the
+ * synced baseUrl resolves to the SAME hostname the trust was granted for.
+ * A sync that changes the host (legitimate re-point, or a compromised/
+ * malicious sync response) must never inherit trust for a different,
+ * unconfirmed host — the member has to re-confirm via the wizard.
  * Returns { error, message } on failure — never throws.
  */
 async function applyTeamJiraConfig(groupName, profileData, configDir) {
   try {
-    await saveProfile(groupName, profileData, null, configDir);
+    const existing = loadProfiles(configDir)?.profiles?.[groupName];
+    const sameHost = existing?.baseUrl && profileData.baseUrl &&
+      hostnameOf(existing.baseUrl) === hostnameOf(profileData.baseUrl);
+    const merged = (existing?.allowPrivateIp && sameHost)
+      ? { ...profileData, allowPrivateIp: true }
+      : profileData;
+    await saveProfile(groupName, merged, null, configDir);
     return { ok: true };
   } catch (e) {
     return { error: 'save-failed', message: e.message };

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;
+}