skillgauntlet 1.3.2 → 1.3.4

package/bin/skillgauntlet.js

@@ -20,7 +20,10 @@ 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';
@@ -145,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) };
@@ -345,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));
@@ -600,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,175 @@
+// 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: { url: 'https://git-scm.com/downloads', pkg: { winget: 'Git.Git', choco: 'git', scoop: 'git', brew: 'git', apt: 'git', dnf: 'git', pacman: 'git', zypper: 'git', apk: 'git' } },
+  gh: { url: 'https://cli.github.com', pkg: { winget: 'GitHub.cli', choco: 'gh', scoop: 'gh', brew: 'gh', apt: 'gh', dnf: 'gh', pacman: 'github-cli', zypper: 'gh', apk: 'github-cli' } },
+};
+
+// The package managers to look for on each system, in the order they are preferred.
+export const MANAGERS = { win32: ['winget', 'choco', 'scoop'], darwin: ['brew'], linux: ['apt-get', 'dnf', 'pacman', 'zypper', 'apk', 'brew'] };
+
+// The steps that install `pkg` with a manager. The system-wide ones need root, so they are run through sudo unless the
+// user already is root; a `sudo` prompt for the password then appears on the user's own terminal.
+function stepsFor(manager, pkg, id, asRoot) {
+  const root = (args) => (asRoot ? args : ['sudo', ...args]);
+  switch (manager) {
+    case 'winget': return [['winget', 'install', '--id', id, '-e', '--accept-source-agreements', '--accept-package-agreements']];
+    case 'choco': return [['choco', 'install', pkg, '-y']];
+    case 'scoop': return [['scoop', 'install', pkg]];
+    case 'brew': return [['brew', 'install', pkg]];
+    case 'apt-get': return [root(['apt-get', 'update']), root(['apt-get', 'install', '-y', pkg])];
+    case 'dnf': return [root(['dnf', 'install', '-y', pkg])];
+    case 'pacman': return [root(['pacman', '-S', '--noconfirm', pkg])];
+    case 'zypper': return [root(['zypper', '--non-interactive', 'install', pkg])];
+    case 'apk': return [root(['apk', 'add', pkg])];
+    default: return null;
+  }
+}
+
+// What this system can run to install a tool, or null when it cannot be done here. `ctx.have(cmd)` says whether a command
+// exists; `ctx.uid` is the user id (0 is root). The first package manager found wins.
+export function installPlan(tool, platform = process.platform, ctx = {}) {
+  const spec = TOOLS[tool];
+  if (!spec) return null;
+  const have = ctx.have || (() => false);
+  const asRoot = ctx.uid === 0;
+  const manager = (MANAGERS[platform] || []).find((m) => have(m));
+  if (!manager) return null;
+  const key = manager === 'apt-get' ? 'apt' : manager;
+  const pkg = spec.pkg[key];
+  if (!pkg) return null;
+  const sudoNeeded = !['winget', 'choco', 'scoop', 'brew'].includes(manager) && !asRoot;
+  if (sudoNeeded && !have('sudo')) return null; // neither root nor sudo: nothing that can be done from here
+  return { manager, steps: stepsFor(manager, pkg, pkg, asRoot), sudo: sudoNeeded };
+}
+
+// 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;
+}
+
+export const has = (tool, exec = quiet) => { try { exec(tool, ['--version']); return true; } catch { return false; } };
+
+const line = (plan) => plan.steps.map((st) => st.join(' ')).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, ctx = {} } = {}) {
+  if (has(tool, exec)) return true;
+  addKnownDirsToPath(platform, exists);
+  if (has(tool, exec)) return true;
+  const plan = installPlan(tool, platform, { have: (c) => has(c, exec), uid: typeof process.getuid === 'function' ? process.getuid() : undefined, ...ctx });
+  out(`\n${t('toolMissing', { tool })}`);
+  if (!plan) {
+    out(t('toolNoAuto', { tool, url: TOOLS[tool].url }));
+    return false;
+  }
+  if (plan.sudo) out(t('toolSudo'));
+  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`);
+  for (const [cmd, ...args] of plan.steps) {
+    const r = run(cmd, 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} 条负样本都填出了可核实的借用词',
@@ -133,6 +133,40 @@ const MESSAGES = {
     '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}，之后随时在浏览器里看。',
+    toolSudo: '这一步要用管理员权限安装：下面可能会让你输入这台电脑的登录密码（输入时不会显示字符，输完按回车）。',
     modelUnknown: '{host} 的模型清单里没有“{model}”。它现在支持：{list}。请重新选一个，或选“默认模型”。',
     updateAvail: '有新版本 {latest}（你现在用的是 {current}）。',
     updateQ: '要更新吗？',
@@ -493,7 +527,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',
@@ -531,6 +565,40 @@ const MESSAGES = {
     '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.',
+    toolSudo: 'This install needs administrator rights: you may be asked for this computer\'s password below (nothing is shown as you type; press enter when done).',
     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?',
@@ -886,7 +954,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} 件すべてに検証可能な借用語があります',
@@ -977,6 +1045,40 @@ Layer 0 always runs first: it is free, and it disqualifies most problems before
     '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}。いつでもブラウザで確認できます。',
+    toolSudo: 'このインストールには管理者権限が必要です。このコンピューターのパスワードの入力を求められることがあります（入力中は何も表示されません。入力後に Enter）。',
     modelUnknown: '{host} のモデル一覧に「{model}」はありません。現在対応：{list}。別のものを選ぶか、既定のモデルを選んでください。',
     updateAvail: '新しいバージョン {latest} があります（現在は {current}）。',
     updateQ: '更新しますか？',

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.2",
+  "version": "1.3.4",
   "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": {