skillgauntlet 1.3.1 → 1.3.3

package/bin/skillgauntlet.js

@@ -13,13 +13,17 @@ import { fingerprint, cacheFileFor, readCachedQueries, writeCachedQueries } from
 import { openRun, querySetHash, readRun, readAnswers, validRecords } from '../lib/runs.js';
 import { DEPTHS, minutesFor } from '../lib/depth.js';
 import { ask, choose, select, confirm, say, closeUi, hasTerminal, setBack, Back } from '../lib/ui.js';
-import { hostModels, unknownModel } from '../lib/models.js';
+import { hostModels, unknownModel, codebuddyCatalog } from '../lib/models.js';
 import { browseDir } from '../lib/browse.js';
 import { withTicker } from '../lib/ticker.js';
-import { renderResult, bar } from '../lib/chart.js';
+import { renderResult } from '../lib/chart.js';
+import { makeProgress } from '../lib/progress.js';
 import { setLang, detectLang, errorText, t } from '../lib/i18n.js';
 import { resolveBin, backend, backendFor, usesOwnDeepseek, setNativeModels, HOSTS, checkModel, draftQueries, draftQuality, runTrial, requireHost, pingHost, setHostBin, binInstalled } from '../lib/trial.js';
-import { HOST_CLI, searchHost, installCommand, installHost } from '../lib/findhost.js';
+import { HOST_CLI, searchHost, installCommand, installHost, LOGIN, loginCommand } from '../lib/findhost.js';
+import { launchSpec } from '../lib/spawn.js';
+import { ensureTool } from '../lib/github.js';
+import { spawnSync as runLogin } from 'node:child_process';
 import { runGain } from '../lib/gain.js';
 import { ERROR_STREAK_STOP, executeTrials, finishRun, resumeRun } from '../lib/execute.js';
 import { cmdSubmit } from '../lib/submit.js';
@@ -127,6 +131,13 @@ function notListed(model, known, label) {
   say(`\n${t('modelUnknown', { model, host: label, list: list.slice(0, 8).join(', ') })}`);
   return true;
 }
+// Models in CodeBuddy's cached catalog that its --help does not list for this account right now.
+function catalogOnly(host) {
+  if (host !== 'codebuddy') return [];
+  const listed = new Set(modelsOf('codebuddy', 'CodeBuddy'));
+  return codebuddyCatalog().filter((m) => !listed.has(m) && !m.startsWith('custom-local:'));
+}
+
 function modelsOf(host, label) {
   if (!modelCache.has(host)) {
     const list = withTicker(waitText(t('waitModels', { host: label }), { slowAfter: 600 }), () => hostModels(host, resolveBin(host)));
@@ -137,12 +148,40 @@ function modelsOf(host, label) {
 }
 const HOST_LABEL = { 'claude-code': 'Claude Code', codebuddy: 'CodeBuddy', codewhale: 'Codewhale' };
 
+// The host did not answer its sign-in check. Show why, and let the user sign in with one press of enter: the host's own
+// login runs on this terminal, then the check is made again. True when a sign-in was run (the caller checks again).
+async function offerLogin(host, bin, err) {
+  const label = HOST_LABEL[host] || host;
+  const spec = LOGIN[host];
+  const cmd = loginCommand(host, path.basename(bin).replace(/\.(cmd|exe|bat)$/i, ''));
+  say(`\n${errorText(err)}`);
+  const pick = await choose(t('loginQ'), [
+    { label: t('loginNow', { host: label }), hint: cmd ? t('loginRuns', { cmd }) : '', value: 'now' },
+    { label: t('loginSkip'), value: 'skip' },
+  ], 1);
+  if (pick !== 'now') return false;
+  say(`\n${t(spec.hint)}\n`);
+  closeUi(); // hand the terminal to the host's own login
+  const launch = launchSpec(bin, spec.args, HOSTS[host].bin);
+  const r = runLogin(launch.cmd, launch.args, { stdio: 'inherit', shell: launch.shell });
+  say('');
+  return !r.error;
+}
+
 async function runTriggerLayer({ skillDir, skillName, depth, model, host = 'claude-code' }) {
   requireHost(host);
   const bin = resolveBin(HOSTS[host].bin);
-  if (!hostChecked.has(host)) {
-    withTicker(waitText(t('hostPing', { host: HOST_LABEL[host] || host })), () => pingHost(host, { bin, model }));
-    hostChecked.add(host);
+  while (!hostChecked.has(host)) {
+    try {
+      withTicker(waitText(t('hostPing', { host: HOST_LABEL[host] || host })), () => pingHost(host, { bin, model }));
+      hostChecked.add(host);
+    } catch (err) {
+      // Not signed in is the common reason: offer the sign-in right here, then check again.
+      if (err.messageKey !== 'hostNotReady' || !LOGIN[host] || !hasTerminal() || !(await offerLogin(host, bin, err))) {
+        if (err.messageKey === 'hostNotReady') err.hostDown = true;
+        throw err;
+      }
+    }
   }
   const cacheFile = cacheFileFor(skillDir, depth);
   const want = { perClause: depth.perClause, negatives: depth.negatives, skillFingerprint: fingerprint(skillDir) };
@@ -205,13 +244,15 @@ async function runTriggerLayer({ skillDir, skillName, depth, model, host = 'clau
     queries: { schema: 'skillgauntlet/queries/1', queries: qs.queries },
   });
 
+  const prog = progress(trials.length);
   try {
     const outcome = await executeTrials({
       run,
       trials,
       doTrial: ({ q }) => runTrial({ bin, skillDir, skillName, query: q.query, model, maxExplore: depth.maxExplore, host }),
-      onTrial: progress(),
+      onTrial: prog,
     });
+    prog.finish();
     const result = finishRun(run, { model, backend: backendFor(host, model), host, runs: depth.runs, expected: trials.length }, outcome.stopped);
     say(`  ${t('runSaved', { path: run.dir })}`);
     if (outcome.stopped) reportStopped(outcome.stopped, run.dir, model);
@@ -219,6 +260,7 @@ async function runTriggerLayer({ skillDir, skillName, depth, model, host = 'clau
     else finishedRuns.push(run.dir);
     return result && { ...result, runDir: run.dir, queries: qs.queries };
   } catch (err) {
+    prog.finish();
     run.close(null, { interrupted: true });
     throw err;
   }
@@ -250,17 +292,7 @@ function archiveProbe({ skillDir, skillName, model, probe }) {
   say(`  ${t('runSaved', { path: run.dir })}`);
 }
 
-function progress() {
-  return ({ row, done, total }) => {
-    // On a terminal one line is redrawn in place; the verdicts of single trials belong to the result, not the wait.
-    if (process.stdout.isTTY) {
-      process.stdout.write(`\r\x1b[2K  ${t('progressLine')} ${bar(done / total, 24)} ${done}/${total}${done >= total ? '\n' : ''}`);
-      return;
-    }
-    const mark = { triggered: '✓', not_triggered: '·', other_skill: '↷' }[row.verdict] || '!';
-    say(`  [${done}/${total}] ${mark} ${row.queryId}#${row.run} → ${row.verdict}`);
-  };
-}
+const progress = makeProgress;
 
 function reportIncomplete(n, dir, model) {
   say(`
@@ -286,12 +318,14 @@ async function cmdResume(args) {
   const runMeta = JSON.parse(fs.readFileSync(path.join(full, 'meta.json'), 'utf8'));
   const runHost = runMeta.host || 'claude-code';
   requireHost(runHost);
+  const resumeProgress = progress();
   const result = await resumeRun({
     dir: full,
     bin: resolveBin((HOSTS[runHost] || HOSTS['claude-code']).bin),
     want: { model: flag('--model'), runs: flag('--runs'), maxExplore: flag('--max-explore'), backend: backendFor(runHost, flag('--model') ?? runMeta.model) },
-    onTrial: progress(),
+    onTrial: resumeProgress,
   });
+  resumeProgress.finish();
   if (result.nothing) {
     say(t('resumeNothing'));
     return;
@@ -320,12 +354,14 @@ async function pickInstalled() {
 }
 
 // A model for hosts that have an account default: pick it, a known name, or type one. Returns null for the default.
-async function pickModel(known = []) {
+async function pickModel(known = [], more = []) {
   if (!hasTerminal()) return (await ask(t('modelOptionalQ'), '')).trim() || null;
   const other = '\u0000other';
+  // `known` is what the account can use now; `more` is in the host's catalog but not promised to the account
   const v = await select(t('modelQ'), [
     { label: t('modelDefault'), value: '' },
-    ...known.map((m) => ({ label: m, value: m })),
+    ...known.map((m) => ({ label: m, hint: more.length ? t('modelAccountHint') : '', value: m })),
+    ...more.map((m) => ({ label: m, hint: t('modelCatalogHint'), value: m })),
     { label: t('modelOther'), value: other },
   ], 0);
   if (v === other) return (await ask(t('modelOptionalQ'), '')).trim() || null;
@@ -340,6 +376,8 @@ async function pickRemote() {
       say(`  ${t('needRepo')}`);
       continue;
     }
+    // cloning needs git; a machine without it is offered the install here, not given a raw error
+    if (hasTerminal() && !(await ensureTool('git', { pick: choose, out: say }))) return [];
     let resolved;
     try {
       resolved = withTicker(waitText(t('waitCloning'), { slowAfter: 600 }), () => resolveSpec(parsed.repo));
@@ -540,8 +578,8 @@ async function interactive() {
         { label: t('depthStandard'), hint: t('depthStandardHint'), value: 'standard' },
       ], 1);
       S.depth = DEPTHS[depthId];
-      S.model = await pickModel(modelsOf('codebuddy', 'CodeBuddy'));
-      if (notListed(S.model, modelsOf('codebuddy', 'CodeBuddy'), 'CodeBuddy')) return AGAIN;
+      S.model = await pickModel(modelsOf('codebuddy', 'CodeBuddy'), catalogOnly('codebuddy'));
+      if (notListed(S.model, [...modelsOf('codebuddy', 'CodeBuddy'), ...catalogOnly('codebuddy')], 'CodeBuddy')) return AGAIN;
       if (usesOwnDeepseek('codebuddy', S.model) && !process.env.DEEPSEEK_API_KEY) {
         say(`\n${t('needDeepseekKey')}`);
         return END;
@@ -595,14 +633,16 @@ async function interactive() {
     let probe = null;
 
     if (host === 'claude' || host === 'codebuddy' || host === 'codewhale') {
+      let hostDown = false; // the host did not answer the sign-in check: nothing else will work either
       try {
         trial = await runTriggerLayer({
           skillDir: target.dir, skillName: target.name, depth, model, host: { claude: 'claude-code', codebuddy: 'codebuddy', codewhale: 'codewhale' }[host],
         });
       } catch (err) {
         say(`  ${t('trialFail', { err: errorText(err) })}`);
+        hostDown = Boolean(err.hostDown) || err.messageKey === 'hostNotReady';
       }
-      if (host === 'claude' && depth.layers.includes('gain')) {
+      if (host === 'claude' && depth.layers.includes('gain') && !hostDown) {
         say(`  ${t('gainNote')}`);
         const g = await runGain({
           bin: resolveBin('claude'),

package/lib/findhost.js

@@ -81,3 +81,12 @@ export function installHost(host, run = (cmd) => execSync(cmd, { stdio: 'inherit
   if (!cmd) throw new Error('no installer for this host');
   try { run(cmd); } catch (err) { throw new Error(String(err.message || err).split(/\r?\n/)[0]); }
 }
+
+// How to sign in to a host from this terminal. Claude Code and Codewhale have a login command; CodeBuddy has none, its
+// sign-in is the /login command inside its own interface, so its CLI is opened and the user is told what to type.
+export const LOGIN = {
+  'claude-code': { args: ['auth', 'login'], hint: 'loginHintBrowser' },
+  codewhale: { args: ['login'], hint: 'loginHintBrowser' },
+  codebuddy: { args: [], hint: 'loginHintCodebuddy' },
+};
+export const loginCommand = (host, bin) => (LOGIN[host] ? `${bin} ${LOGIN[host].args.join(' ')}`.trim() : null);

package/lib/github.js

@@ -0,0 +1,143 @@
+// What a machine with nothing installed needs before a result can be submitted, and what happens after the pull request
+// is opened: git and the GitHub CLI (installed when the user presses enter), a GitHub sign-in (the CLI's own browser
+// flow), the one-time CLA the bot asks for, and the wait for the merge. Every outside call goes through `exec`, `pick`
+// and `run`, so the whole thing is tested with fakes.
+import fs from 'node:fs';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { t } from './i18n.js';
+
+const quiet = (cmd, args) => execFileSync(cmd, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, timeout: 120000 });
+// a long-running, interactive command on the user's terminal (an installer, a browser sign-in)
+const live = (cmd, args) => spawnSync(cmd, args, { stdio: 'inherit', shell: process.platform === 'win32', windowsHide: false });
+
+export const TOOLS = {
+  git: { why: 'git', win: 'Git.Git', brew: 'git', url: 'https://git-scm.com/downloads' },
+  gh: { why: 'gh', win: 'GitHub.cli', brew: 'gh', url: 'https://cli.github.com' },
+};
+
+// Where a fresh install lands when the running process was started before it existed (its PATH is out of date).
+export function knownDirs(platform = process.platform) {
+  if (platform === 'win32') return ['C:\\Program Files\\Git\\cmd', 'C:\\Program Files\\GitHub CLI', `${process.env.LOCALAPPDATA || ''}\\Programs\\Git\\cmd`];
+  if (platform === 'darwin') return ['/opt/homebrew/bin', '/usr/local/bin'];
+  return [];
+}
+
+export function addKnownDirsToPath(platform = process.platform, exists = fs.existsSync, env = process.env) {
+  const key = Object.keys(env).find((k) => k.toLowerCase() === 'path') || 'PATH';
+  const sep = platform === 'win32' ? ';' : ':'; // the separator of the system being described, not of the one running
+  const have = String(env[key] || '').split(sep).map((d) => d.toLowerCase());
+  const add = knownDirs(platform).filter((d) => d && exists(d) && !have.includes(d.toLowerCase()));
+  if (add.length) env[key] = `${add.join(sep)}${sep}${env[key] || ''}`;
+  return add;
+}
+
+// The command that installs a tool on this system, or null when it cannot be done without a password or a guess.
+export function installPlan(tool, platform = process.platform) {
+  const spec = TOOLS[tool];
+  if (!spec) return null;
+  if (platform === 'win32') return { cmd: 'winget', args: ['install', '--id', spec.win, '-e', '--accept-source-agreements', '--accept-package-agreements'] };
+  if (platform === 'darwin') return { cmd: 'brew', args: ['install', spec.brew] };
+  return null;
+}
+
+export const has = (tool, exec = quiet) => { try { exec(tool, ['--version']); return true; } catch { return false; } };
+
+const line = (plan) => `${plan.cmd} ${plan.args.join(' ')}`;
+
+// One tool: present, or offered for install with enter. True when it is usable afterwards.
+export async function ensureTool(tool, { exec = quiet, run = live, pick, out, platform = process.platform, exists = fs.existsSync } = {}) {
+  if (has(tool, exec)) return true;
+  addKnownDirsToPath(platform, exists);
+  if (has(tool, exec)) return true;
+  const plan = installPlan(tool, platform);
+  out(`\n${t('toolMissing', { tool })}`);
+  if (!plan) {
+    out(t('toolNoAuto', { tool, url: TOOLS[tool].url }));
+    return false;
+  }
+  const choice = await pick(t('toolQ', { tool }), [
+    { label: t('toolInstallNow', { tool }), hint: t('toolRuns', { cmd: line(plan) }), value: 'now' },
+    { label: t('toolInstallSelf'), value: 'self' },
+  ], 1);
+  if (choice !== 'now') return false;
+  out(`\n${t('toolInstalling', { tool })}\n`);
+  const r = run(plan.cmd, plan.args);
+  if (r?.error || (r && r.status !== 0 && r.status != null)) {
+    out(t('toolInstallFailed', { tool, url: TOOLS[tool].url }));
+    return false;
+  }
+  addKnownDirsToPath(platform, exists);
+  if (has(tool, exec)) {
+    out(t('toolInstalled', { tool }));
+    return true;
+  }
+  out(t('toolStillMissing', { tool }));
+  return false;
+}
+
+export const signedIn = (exec = quiet) => { try { exec('gh', ['auth', 'status']); return true; } catch { return false; } };
+
+// The GitHub sign-in: the CLI's own browser flow (it shows a one-time code and opens the browser after enter).
+export async function ensureSignedIn({ exec = quiet, run = live, pick, out } = {}) {
+  while (!signedIn(exec)) {
+    out(`\n${t('ghLoginNeeded')}`);
+    const choice = await pick(t('ghLoginQ'), [
+      { label: t('ghLoginNow'), hint: t('toolRuns', { cmd: 'gh auth login -h github.com -p https -w' }), value: 'now' },
+      { label: t('ghLoginSkip'), value: 'skip' },
+    ], 1);
+    if (choice !== 'now') return false;
+    out(`\n${t('ghLoginHint')}\n`);
+    run('gh', ['auth', 'login', '-h', 'github.com', '-p', 'https', '-w']);
+  }
+  return true;
+}
+
+// Everything submit needs on a machine with nothing on it. False when the user chose to stop or it cannot be done here.
+export async function ensureGithub(env = {}) {
+  for (const tool of ['git', 'gh']) if (!(await ensureTool(tool, env))) return false;
+  return ensureSignedIn(env);
+}
+
+// ------------------------------------------------------------------------------------------------ after the PR is opened
+
+// The state of the CLA bot's check among a pull request's checks, or null when it has not appeared yet.
+export function claState(rollup) {
+  const e = (rollup || []).find((c) => (c.context || c.name) === 'license/cla');
+  return e ? String(e.state || e.conclusion || '').toUpperCase() : null;
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// Show where the pull request stands until it is merged, needs a person, or the wait runs out. The first time the CLA
+// check is not green the contributor is given the link and asked to come back with enter: signing is a web page that
+// belongs to them and cannot be done for them.
+export async function watchPullRequest(url, { exec = quiet, pick, out, upstream = 'SkillGauntlet/SkillGauntlet', wait = sleep, every = 10000, rounds = 60 } = {}) {
+  const number = String(url).split('/').pop();
+  let askedCla = false;
+  let shown = '';
+  out(`\n${t('prWaiting')}`);
+  for (let i = 0; i < rounds; i += 1) {
+    let view;
+    try { view = JSON.parse(exec('gh', ['pr', 'view', url, '--json', 'state,mergedAt,labels,statusCheckRollup'])); } catch { view = null; }
+    if (view) {
+      if (view.state === 'MERGED' || view.mergedAt) { out(`\n${t('prMerged', { url })}`); return 'merged'; }
+      if (view.state === 'CLOSED') { out(`\n${t('prClosed', { url })}`); return 'closed'; }
+      if ((view.labels || []).some((l) => l.name === 'needs-review')) { out(`\n${t('prNeedsReview', { url })}`); return 'review'; }
+      const cla = claState(view.statusCheckRollup);
+      if (cla && cla !== 'SUCCESS' && !askedCla) {
+        askedCla = true;
+        out(`\n${t('prCla', { url: `https://cla-assistant.io/${upstream}?pullRequest=${number}` })}`);
+        const choice = await pick(t('prClaQ'), [
+          { label: t('prClaDone'), value: 'wait' },
+          { label: t('prLater'), value: 'later' },
+        ], 1);
+        if (choice === 'later') { out(t('prLaterNote', { url })); return 'later'; }
+      }
+      const status = cla ? `${t('prStepCla')} ${cla === 'SUCCESS' ? '✓' : '…'}` : t('prStepChecks');
+      if (status !== shown) { out(`  ${status}`); shown = status; }
+    }
+    await wait(every);
+  }
+  out(`\n${t('prTimeout', { url, m: Math.round((rounds * every) / 60000) })}`);
+  return 'timeout';
+}

package/lib/i18n.js

@@ -95,7 +95,7 @@ const MESSAGES = {
     staticDone: '静态层：{verdicts}',
     drafting: '正在出题（一次模型调用，可能要几分钟）…',
     hostPing: '正在确认 {host} 已登录…',
-    hostNotReady: '{host} 没有响应，多半是还没登录。请先在它的命令行里输入 /login，登录后再重新运行。（{why}）',
+    hostNotReady: '{host} 没能完成一次试调用：{why}\n如果是没登录，请先在它的命令行里输入 /login，登录后再重新运行。',
     drafted: '出了 {q} 道题，{c} 条触发条款（已缓存，下次直接复用）',
     queriesReused: '复用缓存的 {n} 道题（{file}），省一次出题调用',
     negativesChecked: '{n} 条负样本都填出了可核实的借用词',
@@ -131,6 +131,41 @@ const MESSAGES = {
     'chart.otherSkill': '改用别的技能：{name}',
     'chart.more': '…还有 {n} 题，见完整报告',
     'chart.wrongTitle': '不该触发却触发的 {n} 次',
+    modelAccountHint: '你的账号现在可用',
+    modelCatalogHint: 'CodeBuddy 目录里有，账号不一定能用',
+    loginQ: '要现在登录吗？',
+    loginNow: '现在登录 {host}（按回车）',
+    loginRuns: '会运行 {cmd}',
+    loginSkip: '先不登录，跳过触发层',
+    loginHintBrowser: '接下来会运行宿主自己的登录命令，一般在浏览器里完成；登录结束后会自动回到这里并重新检查。',
+    loginHintCodebuddy: '接下来会打开 CodeBuddy 的界面：请在里面输入 /login 完成登录，再输入 /exit 退出，就会回到这里并重新检查。',
+    toolMissing: '这台电脑上没有 {tool}，提交结果需要它。',
+    toolNoAuto: '这个系统没法自动安装 {tool}，请按 {url} 的说明装好，再重新运行。',
+    toolQ: '现在安装 {tool} 吗？',
+    toolInstallNow: '现在安装 {tool}（按回车）',
+    toolRuns: '会运行 {cmd}',
+    toolInstallSelf: '我自己装，稍后重新运行',
+    toolInstalling: '正在安装 {tool}，输出就在下面，请等它结束…',
+    toolInstalled: '{tool} 装好了。',
+    toolInstallFailed: '{tool} 没装成功。请按 {url} 的说明自己装好，再重新运行。',
+    toolStillMissing: '装完之后还是找不到 {tool}，请关掉终端重新打开，再重新运行。',
+    ghLoginNeeded: '还没登录 GitHub。提交结果要用你的 GitHub 账号开一个公开的 PR。',
+    ghLoginQ: '现在登录 GitHub 吗？',
+    ghLoginNow: '现在登录 GitHub（按回车）',
+    ghLoginSkip: '先不登录，只保存结果',
+    ghLoginHint: '接下来会显示一个一次性代码并打开浏览器：在网页里输入代码、点授权，终端会自动继续。',
+    prWaiting: '正在等 PR 的检查和合并…',
+    prStepCla: 'CLA 签署',
+    prStepChecks: '自动检查进行中',
+    prCla: '这是你第一次提交，需要签一次贡献者协议（CLA）。请在浏览器里打开：\n  {url}\n用 GitHub 账号登录并点同意即可。',
+    prClaQ: '签好了吗？',
+    prClaDone: '我已经签好了（按回车继续等）',
+    prLater: '稍后再看（PR 已开，不影响）',
+    prLaterNote: 'PR 还在：{url}。签好 CLA 后会自动检查并合并，之后随时在浏览器里看。',
+    prMerged: '已合并 ✓ 这是你的提交记录：{url}',
+    prClosed: '这个 PR 已被关闭：{url}',
+    prNeedsReview: '没有自动合并，已转给维护者审核（常见原因：GitHub 账号注册不满 30 天，或今天已提交超过 5 条）。你不需要再做什么：{url}',
+    prTimeout: '等了 {m} 分钟还没合并，PR 还在：{url}，之后随时在浏览器里看。',
     modelUnknown: '{host} 的模型清单里没有“{model}”。它现在支持：{list}。请重新选一个，或选“默认模型”。',
     updateAvail: '有新版本 {latest}（你现在用的是 {current}）。',
     updateQ: '要更新吗？',
@@ -491,7 +526,7 @@ const MESSAGES = {
     staticDone: 'Static: {verdicts}',
     drafting: 'Drafting questions (one model call, may take a few minutes)…',
     hostPing: 'Checking that {host} is signed in…',
-    hostNotReady: '{host} did not answer, most likely because it is not signed in. Run /login in its CLI first, then run this again. ({why})',
+    hostNotReady: '{host} could not complete a test call: {why}\nIf it is not signed in, run /login in its CLI first, then run this again.',
     drafted: '{q} queries over {c} trigger clauses (cached for reuse)',
     queriesReused: 'reusing {n} cached questions ({file}), one drafting call saved',
     negativesChecked: 'all {n} negatives name verifiable borrowed wording',
@@ -527,6 +562,41 @@ const MESSAGES = {
     'chart.otherSkill': 'used another skill: {name}',
     'chart.more': '…{n} more, see the full report',
     'chart.wrongTitle': '{n} times it triggered when it should not have',
+    modelAccountHint: 'usable with your account now',
+    modelCatalogHint: 'in CodeBuddy\'s catalog; your account may not have it',
+    loginQ: 'Sign in now?',
+    loginNow: 'Sign in to {host} now (press enter)',
+    loginRuns: 'runs {cmd}',
+    loginSkip: 'Not now, skip the trigger layer',
+    loginHintBrowser: 'The host\'s own login command runs next, usually finishing in your browser; when it ends you come back here and the check is made again.',
+    loginHintCodebuddy: 'CodeBuddy\'s interface opens next: type /login there to sign in, then /exit to leave; you come back here and the check is made again.',
+    toolMissing: '{tool} is not installed on this computer, and submitting needs it.',
+    toolNoAuto: 'This system cannot install {tool} automatically; install it from {url}, then run this again.',
+    toolQ: 'Install {tool} now?',
+    toolInstallNow: 'Install {tool} now (press enter)',
+    toolRuns: 'runs {cmd}',
+    toolInstallSelf: 'I will install it myself and run this again',
+    toolInstalling: 'Installing {tool}; its output is shown below, please wait for it to finish…',
+    toolInstalled: '{tool} is installed.',
+    toolInstallFailed: '{tool} did not install. Install it yourself from {url}, then run this again.',
+    toolStillMissing: '{tool} still was not found after installing. Close this terminal, open a new one and run this again.',
+    ghLoginNeeded: 'You are not signed in to GitHub. Submitting opens a public pull request from your GitHub account.',
+    ghLoginQ: 'Sign in to GitHub now?',
+    ghLoginNow: 'Sign in to GitHub now (press enter)',
+    ghLoginSkip: 'Not now, just keep the results',
+    ghLoginHint: 'A one-time code is shown next and your browser opens: type the code there and authorize, and this terminal carries on by itself.',
+    prWaiting: 'Waiting for the pull request\'s checks and merge…',
+    prStepCla: 'CLA signed',
+    prStepChecks: 'automatic checks running',
+    prCla: 'This is your first submission, so you sign the contributor agreement (CLA) once. Open this in your browser:\n  {url}\nSign in with your GitHub account and agree.',
+    prClaQ: 'Signed?',
+    prClaDone: 'I have signed it (press enter to keep waiting)',
+    prLater: 'Look later (the pull request is open either way)',
+    prLaterNote: 'The pull request is still there: {url}. Once the CLA is signed it is checked and merged automatically; look any time in the browser.',
+    prMerged: 'Merged ✓ Here is your submission record: {url}',
+    prClosed: 'This pull request was closed: {url}',
+    prNeedsReview: 'It was not merged automatically and has gone to a maintainer for review (common reasons: the GitHub account is under 30 days old, or more than 5 submissions today). You need do nothing more: {url}',
+    prTimeout: 'Waited {m} minutes and it is not merged yet. The pull request is still there: {url}; look any time in the browser.',
     modelUnknown: '{host} does not list a model called "{model}". It currently supports: {list}. Pick another, or choose the default model.',
     updateAvail: 'A newer version {latest} is available (you are on {current}).',
     updateQ: 'Update?',
@@ -882,7 +952,7 @@ Layer 0 always runs first: it is free, and it disqualifies most problems before
     staticDone: '静的チェック：{verdicts}',
     drafting: 'テスト用の質問を作成中（モデル呼び出し 1 回、数分かかることがあります）…',
     hostPing: '{host} にサインイン済みか確認中…',
-    hostNotReady: '{host} から応答がありません。サインインしていない可能性が高いです。先にその CLI で /login を実行してから、もう一度実行してください。（{why}）',
+    hostNotReady: '{host} はテスト呼び出しを完了できませんでした：{why}\nサインインしていない場合は、先にその CLI で /login を実行してから、もう一度実行してください。',
     drafted: '{c} 件の発動条項について {q} 問を作成しました（キャッシュ済み、次回は再利用）',
     queriesReused: 'キャッシュ済みの {n} 問（{file}）を再利用、質問作成の呼び出しを 1 回節約',
     negativesChecked: '否定例 {n} 件すべてに検証可能な借用語があります',
@@ -971,6 +1041,41 @@ Layer 0 always runs first: it is free, and it disqualifies most problems before
     'chart.otherSkill': '別のスキルを使用：{name}',
     'chart.more': '…ほか {n} 件は詳細レポートへ',
     'chart.wrongTitle': '発動すべきでないのに発動した {n} 回',
+    modelAccountHint: 'このアカウントで今使えます',
+    modelCatalogHint: 'CodeBuddy のカタログにあります（アカウントで使えるとは限りません）',
+    loginQ: '今すぐサインインしますか？',
+    loginNow: '{host} に今すぐサインイン（Enter）',
+    loginRuns: '{cmd} を実行します',
+    loginSkip: '今はしない（発動率の測定をスキップ）',
+    loginHintBrowser: '次にホスト自身のログインコマンドを実行します（通常はブラウザで完了）。終わるとここに戻り、再度確認します。',
+    loginHintCodebuddy: '次に CodeBuddy の画面が開きます。そこで /login と入力してサインインし、/exit で終了するとここに戻って再度確認します。',
+    toolMissing: 'このコンピューターに {tool} がありません。結果の提出に必要です。',
+    toolNoAuto: 'このシステムでは {tool} を自動インストールできません。{url} の手順でインストールしてから、もう一度実行してください。',
+    toolQ: '今すぐ {tool} をインストールしますか？',
+    toolInstallNow: '{tool} を今すぐインストール（Enter）',
+    toolRuns: '{cmd} を実行します',
+    toolInstallSelf: '自分でインストールして、あとでもう一度実行する',
+    toolInstalling: '{tool} をインストール中です。出力は下に表示されます。終わるまでお待ちください…',
+    toolInstalled: '{tool} をインストールしました。',
+    toolInstallFailed: '{tool} をインストールできませんでした。{url} の手順で自分でインストールしてから、もう一度実行してください。',
+    toolStillMissing: 'インストール後も {tool} が見つかりません。ターミナルを閉じて開き直し、もう一度実行してください。',
+    ghLoginNeeded: 'GitHub にサインインしていません。提出はあなたの GitHub アカウントで公開プルリクエストを作成します。',
+    ghLoginQ: '今すぐ GitHub にサインインしますか？',
+    ghLoginNow: 'GitHub に今すぐサインイン（Enter）',
+    ghLoginSkip: '今はしない（結果は保存のみ）',
+    ghLoginHint: '次にワンタイムコードが表示されブラウザが開きます。そこでコードを入力して承認すると、このターミナルは自動で続行します。',
+    prWaiting: 'プルリクエストのチェックとマージを待っています…',
+    prStepCla: 'CLA 署名',
+    prStepChecks: '自動チェック実行中',
+    prCla: '初めての提出なので、貢献者契約（CLA）に一度だけ署名します。ブラウザで次を開いてください：\n  {url}\nGitHub アカウントでサインインして同意します。',
+    prClaQ: '署名しましたか？',
+    prClaDone: '署名しました（Enter で待機を続ける）',
+    prLater: '後で見る（プルリクエストは作成済みです）',
+    prLaterNote: 'プルリクエストはそのまま残っています：{url}。CLA に署名すると自動でチェック・マージされます。いつでもブラウザで確認できます。',
+    prMerged: 'マージされました ✓ あなたの提出記録：{url}',
+    prClosed: 'このプルリクエストはクローズされました：{url}',
+    prNeedsReview: '自動マージされず、メンテナーのレビューに回りました（主な理由：GitHub アカウントが作成 30 日未満、または本日 5 件を超える提出）。これ以上の操作は不要です：{url}',
+    prTimeout: '{m} 分待ちましたがまだマージされていません。プルリクエストは残っています：{url}。いつでもブラウザで確認できます。',
     modelUnknown: '{host} のモデル一覧に「{model}」はありません。現在対応：{list}。別のものを選ぶか、既定のモデルを選んでください。',
     updateAvail: '新しいバージョン {latest} があります（現在は {current}）。',
     updateQ: '更新しますか？',

package/lib/models.js

@@ -1,5 +1,8 @@
 // Model names a host will accept, read from the host itself so the list is the user's own (it depends on the
 // account and the custom models they set up) and never goes stale inside this package. Any failure gives [].
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { execFileSync, execSync } from 'node:child_process';
 import { launchSpec } from './spawn.js';
 
@@ -44,3 +47,35 @@ export function unknownModel(model, known) {
   if (!model || !known?.length || known.includes(model) || /^deepseek/i.test(model)) return null;
   return known;
 }
+
+// `codebuddy --help` lists only what the account is signed in for right now (it can shrink to two entries), while the
+// model catalog CodeBuddy last fetched stays in its local cache. Every string array called "models" inside those cache
+// files is part of that catalog; the union with the help list is what the user remembers having been offered. A name
+// from the catalog only is not promised to work for the account, so the list marks it and a failure shows the CLI's words.
+export function catalogFromTexts(texts) {
+  const names = new Set();
+  const walk = (node, depth) => {
+    if (!node || depth > 8) return;
+    if (Array.isArray(node)) { node.forEach((n) => walk(n, depth + 1)); return; }
+    if (typeof node !== 'object') return;
+    for (const [k, v] of Object.entries(node)) {
+      if (k === 'models' && Array.isArray(v)) v.filter((x) => typeof x === 'string' && /^[\w.:-]{2,80}$/.test(x)).forEach((x) => names.add(x));
+      else walk(v, depth + 1);
+    }
+  };
+  for (const text of texts) { try { walk(JSON.parse(text), 0); } catch { /* not JSON */ } }
+  return [...names];
+}
+
+export function codebuddyCatalog(dir = path.join(os.homedir(), '.codebuddy', 'local_storage')) {
+  const texts = [];
+  try {
+    for (const f of fs.readdirSync(dir)) {
+      if (!f.endsWith('.info')) continue;
+      const file = path.join(dir, f);
+      if (fs.statSync(file).size > 2 * 1024 * 1024) continue;
+      texts.push(fs.readFileSync(file, 'utf8'));
+    }
+  } catch { /* no cache: only the help list */ }
+  return catalogFromTexts(texts);
+}

package/lib/progress.js

@@ -0,0 +1,48 @@
+// The wait for the trials. On a terminal the bar is drawn at once (0 of N) and redrawn every second with the seconds
+// elapsed, so there is something on screen from the moment the trials start rather than after the first one finishes;
+// a trial can take many seconds. `total` is known when a run starts; a resumed run learns it from its first trial.
+// Without a terminal each finished trial is one line. finish() stops the redraw and ends the line.
+import { t } from './i18n.js';
+import { bar } from './chart.js';
+
+export function makeProgress(total = 0, {
+  tty = Boolean(process.stdout.isTTY),
+  write = (s) => process.stdout.write(s),
+  line = (s) => process.stdout.write(`${s}\n`),
+  now = Date.now,
+  every = setInterval,
+  stopEvery = clearInterval,
+} = {}) {
+  const started = now();
+  let finished = 0;
+  let of = total;
+  let timer = null;
+  let open = false;
+  const draw = () => {
+    open = true;
+    write(`\r\x1b[2K  ${t('progressLine')} ${bar(of ? finished / of : 0, 24)} ${finished}/${of || '?'}  ${t('waitElapsed', { s: Math.floor((now() - started) / 1000) })}`);
+  };
+  const stop = () => {
+    if (timer) stopEvery(timer);
+    timer = null;
+    if (tty && open) { write('\n'); open = false; }
+  };
+  if (tty && total) {
+    draw();
+    timer = every(draw, 1000);
+  }
+  const onTrial = ({ row, done, total: n }) => {
+    finished = done;
+    of = n;
+    if (tty) {
+      if (!timer) timer = every(draw, 1000);
+      draw();
+      if (done >= n) stop();
+      return;
+    }
+    const mark = { triggered: '✓', not_triggered: '·', other_skill: '↷' }[row.verdict] || '!';
+    line(`  [${done}/${n}] ${mark} ${row.queryId}#${row.run} → ${row.verdict}`);
+  };
+  onTrial.finish = stop;
+  return onTrial;
+}

package/lib/submit.js

@@ -7,7 +7,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { say, confirm } from './ui.js';
+import { say, confirm, choose, hasTerminal } from './ui.js';
+import { ensureGithub, watchPullRequest } from './github.js';
 import { errorText, t } from './i18n.js';
 import {
   SubmitError, buildPackage, gitFacts, gradeOfSummary, normalizeRepo, skillShaAtCommit, slug, writePackage,
@@ -139,6 +140,9 @@ export async function cmdSubmit(args, { exec = defaultExec, verifyRemote = skill
   const opts = parseSubmitArgs(args);
   const runDir = path.resolve(opts.dir);
   const skillDir = opts['skill-dir'] ? path.resolve(opts['skill-dir']) : path.resolve(runDir, '..', '..', '..');
+  // On a terminal, make sure git, the GitHub CLI and a sign-in exist before anything else: a machine with nothing on
+  // it gets each offered with enter. Skipped when the contributor's name was given, and under test fakes.
+  if (hasTerminal() && !opts['github-user'] && exec === defaultExec) await ensureGithub({ pick: choose, out: say });
   const gh = ghState(exec);
   const contributor = opts['github-user'] || gh.user;
   if (!contributor) throw new SubmitError('submitNoUser');
@@ -196,6 +200,8 @@ export async function cmdSubmit(args, { exec = defaultExec, verifyRemote = skill
     const url = openPullRequest({ pkgDir, pkg, gh, exec });
     say(`\n${t('submitPrOpened', { url })}`);
     say(t('submitNext'));
+    // the CLA link and the wait for the merge, with enter to continue (under test fakes there is nothing to wait for)
+    if (hasTerminal() && exec === defaultExec) await watchPullRequest(url, { pick: choose, out: say });
     return { pkgDir, pkg, url };
   } catch (err) {
     say(`\n${t('submitGhFail', { msg: String(err.stderr || err.message).trim().split(/\r?\n/).slice(-3).join(' ') })}`);

package/lib/trial.js

@@ -124,18 +124,27 @@ const firstLine = (text) => String(text || '').split(LINE_BREAK).map((l) => l.tr
 // What a host CLI answered, as an error reason: the CLI's own words when it gave any. A CLI can exit 0 with nothing on
 // stdout and its complaint on stderr (CodeBuddy does for a custom model without an endpoint url), so a clean exit
 // status proves nothing; an empty or unreadable stdout is the failure.
+// A CLI that fails in --output-format json still prints one JSON result: the reason is its `result` text ("Not logged in
+// · Please run /login"), which sits after a long block of usage fields, so the raw first line is no reason at all.
+// null when the text is not JSON; otherwise the reason ('' when the result is not an error).
+function jsonProblem(out) {
+  let parsed;
+  try { parsed = JSON.parse(out); } catch { return null; }
+  const last = Array.isArray(parsed) ? parsed.filter((m) => m?.type === 'result').pop() : parsed;
+  if (!last || typeof last !== 'object') return '';
+  if (!last.is_error) return '';
+  return firstLine(typeof last.result === 'string' ? last.result : JSON.stringify(last.result ?? '')) || firstLine(last.error) || 'the CLI reported an error';
+}
+
 export function hostAnswerProblem(r, timeout) {
   if (r.error) return r.error.code === 'ETIMEDOUT' ? `no answer within ${timeout}s` : String(r.error.message).split(LINE_BREAK)[0];
   if (r.signal) return `no answer within ${timeout}s`;
   const out = String(r.stdout || '');
-  if (r.status !== 0) return firstLine(r.stderr) || firstLine(out) || `exit status ${r.status}`;
+  const fromJson = out.trim() ? jsonProblem(out) : null;
+  if (r.status !== 0) return firstLine(r.stderr) || fromJson || firstLine(out).slice(0, 160) || `exit status ${r.status}`;
   if (!out.trim()) return firstLine(r.stderr) || 'the CLI answered with nothing';
-  try {
-    const parsed = JSON.parse(out);
-    const last = Array.isArray(parsed) ? parsed.filter((m) => m?.type === 'result').pop() : parsed;
-    if (last?.is_error) return firstLine(last.result) || 'the CLI reported an error';
-  } catch { return firstLine(out); }
-  return null;
+  if (fromJson === null) return firstLine(out).slice(0, 160);
+  return fromJson || null;
 }
 
 export function pingHost(host, { bin, model = null, timeout = 90, spawn = spawnSync } = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillgauntlet",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Check an agent skill before you install it: context cost, permission surface, code risk, instruction hijacking, description quality, trigger rate and gain.",
   "type": "module",
   "bin": {