quoxcli 0.4.0 → 0.6.0

package/lib/core/confirm.js

@@ -17,6 +17,51 @@
  * @param {string} message - confirmation prompt text
  * @returns {Promise<boolean>}
  */
+import { QuoxUserError } from './errors.js';
+
+/**
+ * Ask y/N, but treat a closed stdin (EOF) as "no answer" (resolves false)
+ * instead of leaving the prompt pending, which Node reports as a leaked
+ * "Detected unsettled top-level await" warning.
+ */
+async function askConfirm(message) {
+  const { default: inquirer } = await import('inquirer');
+  let onEnd;
+  const eof = new Promise((resolve) => {
+    onEnd = () => resolve(false);
+    process.stdin.once('end', onEnd);
+    process.stdin.once('close', onEnd);
+  });
+  try {
+    const ans = await Promise.race([
+      inquirer.prompt([{ type: 'confirm', name: 'confirm', message, default: false }]),
+      eof,
+    ]);
+    return ans === false ? false : ans.confirm;
+  } finally {
+    process.stdin.off('end', onEnd);
+    process.stdin.off('close', onEnd);
+  }
+}
+
+/**
+ * y/N for verbs that have their own non-interactive flag (e.g. `--i-accept`).
+ * With no terminal it does not open a prompt: it throws a one-line
+ * QuoxUserError naming the flag, exit code 2.
+ * @param {string} message
+ * @param {{ flag?: string, purpose?: string }} [opts]
+ * @returns {Promise<boolean>}
+ */
+export async function confirmInteractive(message, { flag = '--yes', purpose = 'confirm' } = {}) {
+  if (!process.stdin.isTTY) {
+    throw new QuoxUserError(
+      `No terminal to answer y/N here. Read the output above, then re-run with ${flag} to ${purpose}.`,
+      { exitCode: 2, code: 'no_terminal' },
+    );
+  }
+  return askConfirm(message);
+}
+
 export async function confirmDestructive(program, options, message) {
   if (options.force === true || program.opts().yes === true) {
     return true;
@@ -26,12 +71,28 @@ export async function confirmDestructive(program, options, message) {
     throw new Error(`${message} — this needs confirmation; re-run with --force (or -y) in a non-interactive shell`);
   }
 
+  return askConfirm(message);
+}
+
+/**
+ * Ask for a typed line (e.g. the name of the object about to be deleted). EOF settles as null.
+ * Callers check the terminal first; this never opens a prompt without one.
+ * @param {string} message
+ * @returns {Promise<string|null>}
+ */
+export async function askTyped(message) {
   const { default: inquirer } = await import('inquirer');
-  const ans = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirm',
-    message,
-    default: false,
-  }]);
-  return ans.confirm;
+  let onEnd;
+  const eof = new Promise((resolve) => {
+    onEnd = () => resolve(null);
+    process.stdin.once('end', onEnd);
+    process.stdin.once('close', onEnd);
+  });
+  try {
+    const ans = await Promise.race([inquirer.prompt([{ type: 'input', name: 'typed', message }]), eof]);
+    return ans === null ? null : String(ans.typed ?? '');
+  } finally {
+    process.stdin.off('end', onEnd);
+    process.stdin.off('close', onEnd);
+  }
 }

package/lib/core/crossOrgApprovals.js

@@ -0,0 +1,69 @@
+/**
+ * crossOrgApprovals: "N more waiting in <org>" for the orgs the user belongs to OTHER than the active one.
+ *
+ * Read-only and counts only. orgs.list is scoped to the caller, and each count is the user's own
+ * GET /api/orgs/:orgId/inbox/stats (server: active membership of THAT org, owner/admin see the whole org,
+ * members only their own items), read with the caller's OWN token: the server checks membership of the URL org
+ * in the database, not the token's org claim, so no per-org token is minted (a mint is an auth.org_switch audit
+ * event and ~2s each). No card content crosses orgs and nothing here can decide anything; deciding in another org
+ * is an explicit `--org <id>` on the verb. Counts (never tokens) are cached 60s in-process.
+ */
+import { resolveEndpoint } from '../api/endpoints.js';
+
+const listOf = (d) => (Array.isArray(d) ? d : (d?.organizations || d?.orgs || d?.data || []));
+
+const CACHE_MS = 60 * 1000;
+const cache = new Map(); // `${userScope}|${currentOrgId}` -> { at, res }
+export const _clearCrossOrgCache = () => cache.clear();
+
+/**
+ * @param {object} a
+ * @param {object} a.client                     the caller's client (lists memberships, reads each org's counts)
+ * @param {string|null} a.currentOrgId
+ * @param {()=>number} [a.now]
+ * @returns {Promise<{ waiting: {id:string,name:string,count:number}[], failed: number, checked: boolean }>}
+ *   failed counts orgs that could not be read: an unreadable org is NOT "nothing waiting".
+ */
+export async function otherOrgsWaiting({ client, currentOrgId, now = Date.now }) {
+  if (!client) return { waiting: [], failed: 0, checked: false };
+  const key = `${currentOrgId}`;
+  const hit = cache.get(key);
+  if (hit && now() - hit.at < CACHE_MS) return hit.res;
+  let orgs;
+  try { const ep = resolveEndpoint('orgs.list'); orgs = listOf(await client.get(ep.path, { service: ep.service })); }
+  catch { return { waiting: [], failed: 1, checked: true }; }
+  const others = orgs.filter((o) => o?.id && o.id !== currentOrgId);
+  const waiting = []; let failed = 0;
+  await Promise.all(others.map(async (o) => {
+    try {
+      const ep = resolveEndpoint('inbox.stats.list', { orgId: o.id });
+      const d = await client.get(ep.path, { service: ep.service, retries: 0 });
+      const count = Number(d?.awaiting_human ?? d?.pending_approvals ?? 0);
+      if (count > 0) waiting.push({ id: o.id, name: o.name || o.slug || o.id, count });
+    } catch { failed += 1; }
+  }));
+  waiting.sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  const res = { waiting, failed, checked: true };
+  if (!failed) cache.set(key, { at: now(), res }); // a partial answer is never cached
+  return res;
+}
+
+/** One line per org (plain terminal): the exact command to run. */
+export function crossOrgLines(res, verb = 'list') {
+  const out = (res?.waiting || []).map((w) => `${w.count} more waiting in ${w.name}: quox approvals ${verb} --org ${w.id}`);
+  if (res?.failed) out.push(`Could not check ${res.failed} other org${res.failed === 1 ? '' : 's'} for waiting approvals; that does not mean nothing is waiting there.`);
+  return out;
+}
+
+/** TUI wording: switching is the TUI's own move. */
+export function crossOrgTuiLines(res) {
+  const out = (res?.waiting || []).map((w) => `${w.count} more waiting in ${w.name}: /org switch ${w.name}`);
+  if (res?.failed) out.push(`Could not check ${res.failed} other org${res.failed === 1 ? '' : 's'} for waiting approvals; that does not mean nothing is waiting there.`);
+  return out;
+}
+
+/** The client for a verb: the profile client for the session org, a minted same-user token client for another. */
+export async function clientForTarget({ client, clientForOrg, sessionOrgId, orgId }) {
+  if (!orgId || orgId === sessionOrgId || typeof clientForOrg !== 'function') return client;
+  return clientForOrg(orgId);
+}

package/lib/core/errors.js

@@ -214,6 +214,14 @@ export function explainError(err, ctx = null) {
   const raw = RAW_HEADLINE.test(String(err.message || '').split('\n')[0]) || err.reasonFromError === true;
   const reason = serverReason(err);
 
+  // SKILLRIGHTS #478: require-acceptance refusal is not a generic 409 conflict.
+  if (status === 409 && (code === 'acceptance_required' || body.error === 'acceptance_required')) {
+    const pack = typeof body.packId === 'string' && body.packId ? body.packId : 'quox-core-dev-pack';
+    return {
+      headline: sentence(reason || `This org's distribution policy is require-acceptance, and nobody has accepted the current terms for pack '${pack}'`),
+      next: `accept the terms as yourself: quox dev skills accept ${pack} (add --i-accept with no terminal), then re-run the sync.`,
+    };
+  }
   // #8 service-key fallback: the real problem is "no stored session", say it once.
   if (err.serviceKeyFallback && (status === 401 || status === 403)) {
     return {
@@ -268,6 +276,28 @@ export function explainError(err, ctx = null) {
   if (status === 404 && /^approval not found$/i.test(reason || '')) {
     return { headline: 'No approval with that id in this org; it may belong to another org or be past retention.', next: notFoundNext(ctx) || '`quox approvals --help` shows how to list what exists.' };
   }
+  // DS-010 / #1335: a step-up refusal is about WHO is at the keyboard, not about org or role. The old fall-through
+  // sent people to "switch org / ask an admin", which cannot help: only the approver's own PIN does.
+  if (status === 403 && /step_up_required/.test(all)) {
+    if (body.reason === 'non_human') {
+      return { headline: 'This approval needs a person, and this login is an agent or service identity.', next: 'approve it from a person\'s own login (the dashboard, or `quox` in their terminal).' };
+    }
+    return {
+      headline: 'This approval needs your step-up PIN.',
+      next: body.pin_set === false
+        ? 'set a PIN in the dashboard (Settings > Account > Approval PIN), then run this again in a terminal.'
+        : 'run this command in an interactive terminal; it will ask for the PIN with hidden input. The PIN cannot be passed as a flag or environment variable.',
+    };
+  }
+  // the auth service's requireInstanceAdmin refusal (code instance_admin_required): instance admin is instance-wide,
+  // so neither switching org nor asking an org admin can help
+  if (status === 403 && /instance_admin_required|instance administrator access required/i.test(all)) {
+    return { headline: sentence(reason || 'Instance administrator access required'), next: 'this needs an instance administrator account. Run it with a profile that is one (quox -p <profile> ...), or ask your instance admin.' };
+  }
+  // an instance-admin gate: switching org cannot help, only an instance admin can
+  if (status === 403 && /instance admin required/i.test(all)) {
+    return { headline: 'This needs an instance admin, and this login is not one.', next: 'ask an instance admin of this Quox server to run it, or to make your login an instance admin.' };
+  }
   // #5 a role refusal is not an org-context problem
   if (status === 403 && /insufficient permissions?|lacks?[ _]capability|requires? (an? |the )?(admin|owner) role|not an? (org )?(admin|owner)/i.test(all)) {
     return { headline: sentence(reason || 'Your role does not allow this'), next: 'your role in this org does not allow this; ask an org owner or admin to do it or to raise your role.' };
@@ -332,6 +362,7 @@ function fallbackExplain(err, ctx) {
 }
 
 // CLI-ERRORS: an instruction sentence (the step the user takes) vs the rest (what happened).
+const TLS_HINT_CODES = ['DEPTH_ZERO_SELF_SIGNED_CERT', 'SELF_SIGNED_CERT_IN_CHAIN', 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY', 'ERR_TLS_CERT_ALTNAME_INVALID', 'CERT_HAS_EXPIRED'];
 const INSTRUCTION = /^(run|check|use|retry|try|pass|fix|set|pick|switch|ask|log ?in|re-?run|please)\b/i;
 
 function splitInstruction(text) {
@@ -351,6 +382,10 @@ function splitInstruction(text) {
  * CLI-ERRORS: errors the CLI raises itself (auth, network, validation, anything else) in the same
  * contract as API errors: one headline, at most one Next, the rest (`more`) only with --verbose.
  */
+function connectUrl(u) {
+  try { return new URL(u).origin; } catch { return '<url>'; }
+}
+
 export function explainLocal(err) {
   if (!err || err instanceof QuoxApiError || err instanceof QuoxUserError) return null;
   const message = String(err.message || '');
@@ -362,7 +397,7 @@ export function explainLocal(err) {
     const more = message.split('\n').slice(1).map((l) => l.trim()).filter(Boolean);
     if (m && code && /CERT|SELF_SIGNED|UNABLE_TO_VERIFY/.test(code)) {
       return { headline: `Could not reach the ${svc} service at ${url}: its certificate is not trusted (${code}).`,
-        next: 'trust it with export NODE_EXTRA_CA_CERTS=<path to quox.crt> (on the server: ~/quox-install/quox/ssl/quox.crt); never disable TLS verification.', more };
+        next: `trust this server for one profile with quox connect ${connectUrl(url)} --profile <name> (it shows the certificate SHA256 and asks y/N; with no terminal add --fingerprint <sha256>); never disable TLS verification.`, more };
     }
     if (m && (code === 'ERR_SSL_WRONG_VERSION_NUMBER' || code === 'EPROTO')) {
       return { headline: `The ${svc} service at ${url} speaks plain http, but this profile's URL says https://.`,
@@ -389,6 +424,20 @@ export function explainLocal(err) {
     return sp;
   }
   if (err instanceof QuoxValidationError) return splitInstruction(message);
+  // H4: a bare fetch (login, MFA, refresh) that died on a certificate this machine does not trust. undici reports it
+  // as "fetch failed"; name the problem and the exact next command. Never auto-trust, never TLS-off.
+  const tlsCode = TLS_HINT_CODES.find((c) => c === (err.cause?.cause?.code || err.cause?.code || err.code));
+  if (tlsCode && err.quoxUrl) {
+    const profile = err.quoxProfile ? ` --profile ${err.quoxProfile}` : '';
+    const expired = tlsCode === 'CERT_HAS_EXPIRED' || tlsCode === 'ERR_TLS_CERT_ALTNAME_INVALID';
+    return { headline: expired
+        ? `The server at ${err.quoxUrl} presents a certificate that ${tlsCode === 'CERT_HAS_EXPIRED' ? 'has expired' : 'does not name the address you used'} (${tlsCode}).`
+        : `The server at ${err.quoxUrl} uses a certificate this machine does not trust yet.`,
+      next: expired
+        ? 'the server needs a certificate that is current and names this address; trusting it would not help. Never disable TLS verification.'
+        : `run quox connect ${err.quoxUrl}${profile} (it shows the SHA256 fingerprint and asks y/N); with no terminal use quox connect ${err.quoxUrl}${profile} --trust-cert, or --fingerprint <sha256> to pin it. Never disable TLS verification.`,
+      more: [`TLS error: ${tlsCode}`] };
+  }
   const first = message.split('\n')[0];
   return { headline: sentence(first || 'Something went wrong'), next: null, more: message.split('\n').slice(1), stack: true };
 }
@@ -404,6 +453,7 @@ function renderContract(err, ex, ctx) {
   }
   if (err.detail) console.error(chalk.dim(`  Detail: ${renderDetail(err.detail)}`));
   if (isVerbose(ctx)) {
+    if (err.debug) console.error(chalk.dim(`  Debug: ${renderDetail(err.debug)}`));
     if (err.status) console.error(chalk.dim(`  Status: ${err.status} ${typeof err.code === 'object' && err.code ? renderDetail(err.code) : (err.code || '')}`));
     if (err instanceof QuoxApiError && err.message && err.message !== ex.headline) console.error(chalk.dim(`  Server said: ${err.message}`));
     for (const line of ex.more || []) if (line) console.error(chalk.dim(`  More: ${line}`));
@@ -420,6 +470,7 @@ export function handleError(err, outputFormat = 'table', ctx = null) {
     };
     if (err.status) obj.status = err.status;
     if (err.detail) obj.detail = err.detail;
+    if (err.debug) obj.debug = err.debug; // plumbing kept out of the headline, still there for scripts
     // LL-3d: scripts parsing --json get the server's own body verbatim, not
     // our prose rendering of it.
     if (err.body && typeof err.body === 'object') obj.body = err.body;

package/lib/core/governedSession.js

@@ -12,7 +12,18 @@ import os from 'node:os';
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync as realSpawnSync } from 'node:child_process';
-import { qArt, colorOn } from './banner.js';
+import { colorOn } from './banner.js';
+import { qLines, qDims } from '../quoxon/qart.js';
+
+/**
+ * The session banner's Q is quoxon's settled vector horned-Q (the face of the app, same mark as
+ * bare `quox` and cli.quox.ai), not the old half-block bitmap. 'small' for a narrow terminal, 'mid'
+ * otherwise. Returns the art rows and their visible width (used to pad the text column alignment).
+ */
+function introArt(color, cols) {
+  const size = cols && cols < 72 ? 'small' : 'mid';
+  return { lines: qLines(size, { color }), width: qDims(size).cols };
+}
 import { startHeartbeat as realStartHeartbeat } from './sessionHeartbeat.js';
 
 const NAME_RE = /^[A-Za-z0-9._-]{1,48}$/;
@@ -160,10 +171,10 @@ export function howItWorksLines({ name, program = 'claude', bare }) {
   ];
 }
 
-export function renderIntro({ name, host, mode, tmuxSession, note, program = 'claude', preattach }, { color = false } = {}) {
+export function renderIntro({ name, host, mode, tmuxSession, note, program = 'claude', preattach }, { color = false, cols = process.stdout?.columns } = {}) {
   const b = (s) => (color ? `\x1b[1m${s}\x1b[0m` : s);
   const d = (s) => (color ? `\x1b[2m${s}\x1b[0m` : s);
-  const art = qArt(color);
+  const { lines: art, width: artW } = introArt(color, cols);
   const modeText = {
     NEW: 'NEW',
     REATTACH: 'REATTACH (same process, no context reload)',
@@ -182,7 +193,7 @@ export function renderIntro({ name, host, mode, tmuxSession, note, program = 'cl
     b('How this works'),
     ...howItWorksLines({ name, program }).map(([k, v]) => `${d(k.padEnd(19))}${v}`),
   ];
-  const w = art[0] ? 14 : 0;
+  const w = art[0] ? artW : 0;
   const lines = [];
   for (let i = 0; i < Math.max(art.length, text.length); i++) {
     lines.push(`  ${art[i] || ' '.repeat(w)}   ${text[i] || ''}`);
@@ -254,7 +265,108 @@ export function ensureHelpBinding(d) {
   return r && r.status === 0 ? 'bound' : 'failed';
 }
 
-export function runGoverned({ program = 'claude', name, args = [], resume = false, noTmux = false, bin, preattach }, over) {
+/**
+ * SESSION-LAUNCH-DEDUPE: tmux session names are case-sensitive but conversation names are not, so
+ * `--resume quoxon` must find `quox-QUOXON`. Returns the real session name or null.
+ */
+export function findSessionCI(d, wanted) {
+  const r = d.spawnSync('tmux', ['list-sessions', '-F', '#{session_name}'], { encoding: 'utf8' });
+  if (!r || r.error || r.status !== 0) return null;
+  const w = String(wanted).toLowerCase();
+  const names = String(r.stdout || '').split('\n').map((l) => l.split('\t')[0].trim()).filter(Boolean);
+  return names.find((n) => n.toLowerCase() === w) || null;
+}
+
+const PS_RE = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/;
+const base = (t) => String(t || '').split('/').pop();
+
+/** True when argv is a claude process resuming `name` (case-insensitive), also via `node .../claude`. */
+export function resumesName(args, name) {
+  const t = String(args).trim().split(/\s+/);
+  let i = 0;
+  if (base(t[0]) === 'node' && base(t[1]) === 'claude') i = 1;
+  else if (base(t[0]) !== 'claude') return false;
+  const want = String(name).toLowerCase();
+  for (let k = i + 1; k < t.length; k++) {
+    if ((t[k] === '--resume' || t[k] === '-r') && String(t[k + 1] || '').toLowerCase() === want) return true;
+    if (t[k].startsWith('--resume=') && t[k].slice(9).toLowerCase() === want) return true;
+  }
+  return false;
+}
+
+/** Live claude processes already holding conversation `name`: [{ pid, tty, tmux }]. */
+export function findLiveHolders(d, name) {
+  const ps = d.spawnSync('ps', ['-eo', 'pid=,ppid=,tty=,args='], { encoding: 'utf8' });
+  if (!ps || ps.error || ps.status !== 0) return [];
+  const procs = new Map();
+  for (const line of String(ps.stdout || '').split('\n')) {
+    const m = PS_RE.exec(line);
+    if (m) procs.set(Number(m[1]), { pid: Number(m[1]), ppid: Number(m[2]), tty: m[3], args: m[4] });
+  }
+  const self = d.pid ?? process.pid;
+  const hits = [...procs.values()].filter((p) => p.pid !== self && p.pid !== process.ppid && resumesName(p.args, name));
+  if (!hits.length) return [];
+  const panes = new Map();
+  const lp = d.spawnSync('tmux', ['list-panes', '-a', '-F', '#{pane_pid} #{session_name}'], { encoding: 'utf8' });
+  if (lp && !lp.error && lp.status === 0) {
+    for (const l of String(lp.stdout || '').split('\n')) {
+      const m = /^(\d+)\s+(\S+)$/.exec(l.trim());
+      if (m) panes.set(Number(m[1]), m[2]);
+    }
+  }
+  return hits.map((p) => {
+    let tmux = null;
+    for (let pid = p.pid, hops = 0; pid > 1 && hops < 32 && !tmux; hops++) { tmux = panes.get(pid) || null; pid = procs.get(pid)?.ppid ?? (hops === 0 ? p.ppid : 0); }
+    return { pid: p.pid, tty: p.tty, tmux };
+  });
+}
+
+/** The conversation name a claude argv resumes (`--resume X`, `-r X`, `--resume=X`), or null. */
+function resumedName(args) {
+  const t = String(args).trim().split(/\s+/);
+  let i = 0;
+  if (base(t[0]) === 'node' && base(t[1]) === 'claude') i = 1;
+  else if (base(t[0]) !== 'claude') return null;
+  for (let k = i + 1; k < t.length; k++) {
+    if ((t[k] === '--resume' || t[k] === '-r') && t[k + 1]) return t[k + 1];
+    if (t[k].startsWith('--resume=') && t[k].length > 9) return t[k].slice(9);
+  }
+  return null;
+}
+
+const PS_AGE_RE = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\d+)\s+(.*)$/;
+
+/**
+ * Every live `claude --resume <name>` on this box (same argv detection as findLiveHolders):
+ * [{ name, pid, tty, tmux, ageSec }]. tmux is the enclosing tmux session or null. [] if ps fails.
+ */
+export function listLiveSessions(d) {
+  const ps = d.spawnSync('ps', ['-eo', 'pid=,ppid=,tty=,etimes=,args='], { encoding: 'utf8' });
+  if (!ps || ps.error || ps.status !== 0) return [];
+  const procs = new Map();
+  for (const line of String(ps.stdout || '').split('\n')) {
+    const m = PS_AGE_RE.exec(line);
+    if (m) procs.set(Number(m[1]), { pid: Number(m[1]), ppid: Number(m[2]), tty: m[3], ageSec: Number(m[4]), args: m[5] });
+  }
+  const self = d.pid ?? process.pid;
+  const hits = [...procs.values()].filter((p) => p.pid !== self && resumedName(p.args));
+  if (!hits.length) return [];
+  const panes = new Map();
+  const lp = d.spawnSync('tmux', ['list-panes', '-a', '-F', '#{pane_pid} #{session_name}'], { encoding: 'utf8' });
+  if (lp && !lp.error && lp.status === 0) {
+    for (const l of String(lp.stdout || '').split('\n')) {
+      const m = /^(\d+)\s+(\S+)$/.exec(l.trim());
+      if (m) panes.set(Number(m[1]), m[2]);
+    }
+  }
+  return hits.map((p) => {
+    let tmux = null;
+    for (let pid = p.pid, hops = 0; pid > 1 && hops < 32 && !tmux; hops++) { tmux = panes.get(pid) || null; pid = procs.get(pid)?.ppid ?? (hops === 0 ? p.ppid : 0); }
+    return { name: resumedName(p.args), pid: p.pid, tty: p.tty, tmux, ageSec: p.ageSec };
+  });
+}
+
+export function runGoverned({ program = 'claude', name, args = [], resume = false, noTmux = false, force = false, bin, preattach }, over) {
   const d = defaults(over);
   const n = name || autoName(d.now());
   if (program === 'run') {
@@ -281,6 +393,24 @@ export function runGoverned({ program = 'claude', name, args = [], resume = fals
       return 1;
     }
     alive = r.status === 0;
+    if (!alive && resume && program === 'claude') {
+      const real = findSessionCI(d, PREFIX + full);
+      if (real) {
+        // Same conversation, different case: attach, never start a second Claude.
+        const attach = `tmux attach -t ${real}`;
+        if (!(d.isTTY ?? process.stdout.isTTY)) { d.write(`${n} is already running in tmux ${real}. Attach: ${attach}\n`); return 0; }
+        const a = d.spawnSync('tmux', ['attach-session', '-t', real], { stdio: 'inherit' });
+        return a && typeof a.status === 'number' ? a.status : 0;
+      }
+    }
+  }
+  if (!alive && resume && program === 'claude' && !force) {
+    const [h] = findLiveHolders(d, n);
+    if (h) {
+      const where = h.tmux ? `tmux ${h.tmux}` : `not in tmux on ${h.tty}`;
+      d.write(`${n} is already running (pid ${h.pid}, ${where}). ${h.tmux ? `Attach: tmux attach -t ${h.tmux}. ` : ''}To start a second copy anyway: --force.\n`);
+      return 1;
+    }
   }
   const plan = planLaunch({ name: n, args, env: d.env, alive, resume, noTmux, program, bin, preattach });
   const shown = program === 'run' ? bin : program;

package/lib/core/inboxResolution.js

@@ -41,13 +41,14 @@ export function humanUtc(iso) {
 export function resolutionFromItem(item, requestedAction) {
   if (!item || !item.id) return null;
   const response = item.response || null;
-  const outcome = item.status === 'expired' ? 'expired' : item.status === 'cancelled' ? 'cancelled' : (outcomeOf(response) || 'resolved');
+  const outcome = item.status === 'expired' ? 'expired' : item.status === 'cancelled' ? 'cancelled' : item.status === 'withdrawn' ? 'withdrawn' : (outcomeOf(response) || 'resolved');
   const name = item.resolved_by_name || response?.responded_by_name || null;
   const at = toIso(item.resolved_at) || toIso(response?.responded_at) || null;
   const requested = String(requestedAction || '').trim().toLowerCase() || null;
-  const matches = Boolean(requested) && outcome !== 'expired' && outcome !== 'cancelled' && normalise(requested) === outcome;
+  const matches = Boolean(requested) && outcome !== 'expired' && outcome !== 'cancelled' && outcome !== 'withdrawn' && normalise(requested) === outcome;
   let message;
   if (outcome === 'expired') message = `This approval expired at ${humanUtc(at)}; nothing was approved. Ask for it again.`;
+  else if (outcome === 'withdrawn') message = `This request was withdrawn at ${humanUtc(at)}${name ? ` by ${name}` : ''}; nothing was decided and nothing ran.`;
   else if (outcome === 'cancelled') message = `This item was cancelled at ${humanUtc(at)}${name ? ` by ${name}` : ''}; there is nothing to respond to.`;
   else {
     const head = `Already ${outcome}${name ? ` by ${name}` : ''} at ${humanUtc(at)}`;

package/lib/core/loginGuard.js

@@ -0,0 +1,73 @@
+/**
+ * Login guards shared by `quox login` and the TUI /login.
+ *  - prefill comes ONLY from the active profile's own last_email
+ *  - a non-default profile signing in as an email another profile already holds gets a y/N warning
+ *  - a 429 says how long to wait (or that retrying may extend the limit)
+ */
+
+/** The active profile's own last_email, or ''. Never another profile's, never a global. */
+export function loginPrefillEmail(config) {
+  try { return String(config.getActiveProfile?.()?.last_email || '').trim(); } catch { return ''; }
+}
+
+/** A server URL reduced to scheme://host:port so https://H, https://h/ and https://h:443 compare equal. '' when not a URL. */
+export function normalizeServerUrl(u) {
+  try { const x = new URL(String(u)); return `${x.protocol}//${x.hostname.toLowerCase()}:${x.port || (x.protocol === 'https:' ? '443' : '80')}`; } catch { return ''; }
+}
+
+/**
+ * Name of ANOTHER profile currently signed in as `email` (case-insensitive), else null.
+ * H2: the same email on a DIFFERENT server is a different account. When `url` (the server this sign-in targets) is
+ * given and the other profile has its own server URL that differs, it does not count. A profile with no URL of its
+ * own is unknown, so it still counts (the safe side for an identity guard).
+ */
+export function profileHoldingEmail(config, email, url = null) {
+  const want = String(email || '').trim().toLowerCase();
+  if (!want) return null;
+  const me = config.getActiveProfileName?.();
+  for (const [name, p] of Object.entries(config._data?.profiles || {})) {
+    if (name === me) continue;
+    if (String(p?.auth?.email || '').trim().toLowerCase() !== want) continue;
+    const mine = normalizeServerUrl(url), theirs = normalizeServerUrl(p?.url);
+    if (mine && theirs && mine !== theirs) continue;
+    return name;
+  }
+  return null;
+}
+
+/** Only a non-default profile needs the warning: it is how agent-only profiles become the owner. */
+export function isNonDefaultProfile(config) {
+  return Boolean(config._data?.activeProfile) && config.getActiveProfileName?.() !== config._data.activeProfile;
+}
+
+export function sameIdentityWarning(email, holder, profile) {
+  return `${email} is already signed in as profile '${holder}'. Sign profile '${profile}' in as the same user? y/N`;
+}
+
+/** Plain-language wait guidance for a rate-limited sign-in. */
+export function rateLimitHint({ retryAfterMs } = {}) {
+  if (Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
+    const min = Math.max(1, Math.ceil(retryAfterMs / 60000));
+    return `Too many authentication attempts: try again in ~${min} min; each retry may extend the limit.`;
+  }
+  return 'Too many authentication attempts: wait a few minutes; retrying now may extend the limit.';
+}
+
+/** Retry-After (seconds or HTTP date) header and common body fields -> ms, else null. */
+export function retryAfterMsFrom(res, data) {
+  const h = res?.headers?.get?.('retry-after');
+  if (h != null && h !== '') {
+    const n = Number(h);
+    if (Number.isFinite(n)) return n * 1000;
+    const t = Date.parse(h);
+    if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  }
+  const s = data?.retry_after ?? data?.retryAfter ?? data?.retry_after_seconds;
+  if (Number.isFinite(Number(s)) && s != null) return Number(s) * 1000;
+  const reset = data?.reset_at ?? data?.resetAt ?? data?.reset;
+  if (reset != null) {
+    const t = typeof reset === 'number' ? (reset < 1e12 ? reset * 1000 : reset) : Date.parse(reset);
+    if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  }
+  return null;
+}