@impeccable/reviews 0.1.22 → 0.1.23

package/dist/host-questions.js

@@ -306,7 +306,7 @@ export function vercelBypassPaste(stopped) {
             : `Make one yourself: ${where} → Create, named "Impeccable reviews".`;
     return { ...HOST_SCREENS['vercel-bypass-key'], prompt: `Vercel keeps your previews behind a login. ${stopped.reason} ${next} It is stored encrypted and used only to open previews.` };
 }
-/** The apps question on a repository with several apps, worded here: the tool lists the apps the state has, each picked as it is on, so every run asks it the same way. */
+/** The apps question on a repository with several apps, worded here: the tool lists the apps the state has, each picked as it is on, so every run asks it the same way. It has no Skip: at least one app is picked (#405). */
 export const APPS_QUESTION = {
     id: 'apps',
     kind: 'multi',
@@ -316,7 +316,7 @@ export const APPS_QUESTION = {
 };
 /** The apps question's hint when the command was started below the repository's top: `where` is an app's folder ("Tally Board's folder") or the folder itself. */
 export const startedIn = (where) => `You started in ${where}. Impeccable sets up from the top of the repository.`;
-/** The apps question when the command was started for one app (`--app`): no list, one confirm screen naming that app, and the list behind Skip for someone who wants another app (#286). */
+/** The apps question when the command was started for one app (`--app`): no list, one confirm screen naming that app, and the list behind Pick other apps for someone who wants another app (#286); there is no Skip (#405). */
 export const namedAppQuestion = (app) => ({
     id: APPS_QUESTION.id,
     kind: 'confirm',

package/dist/main.js

@@ -16,6 +16,7 @@ import { scanRecorder } from './scan.js';
 import { createReporter, reportingOff } from './report.js';
 import { createSessionSync, pageStatus, plainReport, syncExtension } from './sync.js';
 import { checkPushAccess, readPushAccess } from './push-access.js';
+import { askPrSummary, PR_SUMMARY_OFF } from './pr-summary.js';
 import { appsSummary, createTools, ending, ownPullRequest, resultLine } from './tools.js';
 import { transcriptPaths } from './transcript.js';
 import { askPerson } from './ui/bridge.js';
@@ -227,18 +228,27 @@ export async function main(argv) {
             throw new UserError(`--app ${flags.app} is not an app of ${slug}. Its apps are ${appKeys.join(', ')}. Run it again with one of them, or without --app.`);
         }
         // The setup pushes as the person, so whether git may push is asked of GitHub now, before anything is created.
-        const push = await checkPushAccess(slug, () => readPushAccess(checkout.root), async (screen) => {
+        // A question asked before the agent starts. Ctrl+C there answers it as closed while stopEarly winds the run down and
+        // exits, so nothing after it runs: no update over the stop, and no agent started.
+        const askUpFront = async (screen) => {
             liveSync.update({ phase: 'waiting', question: { id: screen.id, prompt: screen.prompt } });
             const answer = await askPerson({ ...screen, skippable: true });
+            if (stopping)
+                return new Promise(() => { });
             liveSync.update({ phase: 'running', question: null });
             return answer;
-        });
+        };
+        const push = await checkPushAccess(slug, () => readPushAccess(checkout.root), askUpFront);
         log.write('push access', push.outcome);
         if (push.outcome === 'refused' || push.outcome === 'signed-out') {
             await nothingToSetUp(liveSync, reporter, 'stopped', "Git can't push", `Git can't push to ${slug}${push.account ? ` as ${push.account}` : ''}, so nothing was set up. Sign git in as an account that can, then run this again.`, [webPage]);
         }
         if (!interactive)
             say('Signed in.\n');
+        // The summary with before and after in each pull request's description, asked with the other consents up front, so the test drive's has it too (#402).
+        const reviewSettings = `${setupApi}/repos/${encodeURIComponent(token.repository.name)}/review-settings`;
+        const prSummary = await askPrSummary(() => requestJson(reviewSettings, { token: token.access_token }, log), askUpFront, (body) => requestJson(reviewSettings, { method: 'PUT', token: token.access_token, body }, log));
+        log.write('pr summary', prSummary);
         // Beside the transcript, named after the run as it is, so a run never writes over another's in the temp folder.
         const scans = scanRecorder(log, flags.scanReport ? join(dirname(transcriptPaths(run.run_id, flags.transcript).markdown), `scan-report-${run.run_id.replace(/[^\w.-]/g, '_')}.json`) : undefined);
         atExit(() => scans.report());
@@ -300,7 +310,7 @@ export async function main(argv) {
                     ],
                     todo: end.todo,
                     ...(report.hosts?.length ? { used: report.hosts } : {}),
-                    warnings: [...removed, ...left, ...(await unopened(drives ? drives.length : testPr ? 1 : 0)), ...(saved && !saved.ok ? [`The web page missed the last update (${saved.error}), so it may lag behind this.`] : [])],
+                    warnings: [...removed, ...left, ...(await unopened(drives ? drives.length : testPr ? 1 : 0)), ...(saved && !saved.ok ? [`The web page missed the last update (${saved.error}), so it may lag behind this.`] : []), ...(prSummary === 'off' ? [PR_SUMMARY_OFF] : [])],
                 }, hand);
                 // The web page has the report; when it missed it, or the run fell short of all set up, whose why it holds, the report stays here as well.
                 if (!saved?.ok || end.code)

package/dist/playbook/cases/monorepo.md

@@ -5,13 +5,13 @@ The state's repository has an `apps` item: the scan proposed several apps, folde
 ### Steps
 
 1. **Confirm the proposal** as it stands, while the item's status is `needs-you`: impeccable_write to `apps` with the `confirm` action the item's instructions give. Its answer lists every app of the repository, on and off, with its `key`, `name`, `pathPrefixes` and `enabled`; the one the scan switched on is the repository's default. An item that is `done` or `skipped` was answered before (on the setup page, or by an earlier run): no confirm, and step 2 all the same. Done when it answered `apps`, or the item was answered before.
-2. **Ask which apps this run sets up**, on every run, with impeccable_ask: `id: "apps"`, `kind: "multi"`, and the `prompt` *"Which apps should get Impeccable previews?"*. The tool words the question and lists the state's apps (the repository's own, `main`, only where the Worker kept it as a product of its own), each picked as it is on, or every one after this run's confirm. Mark the Set up monorepo apps task in progress first. Every write and host tool for an app is refused until it is answered. Done when it answered `values`, `named` (the command was started for that one app with `--app`, from its card on the dashboard: the tool showed one confirm screen naming that app instead of the list, and the list all the same when the person asked for other apps there), or a skip, whose `on` lists the apps that are on: the ones this run sets up. After `named`, that app is the one this run sets up: every host read, key, proof, method and check is its own, and no other app is mentioned past that screen.
-3. **Write the picks**, one action a call as the item's instructions give them: `enable` each chosen app that is off, then `disable` each app that is on and was not chosen. The last app that is on cannot be switched off (409), which is why the enables come first. **After `named`**, `enable` that app when it is off, and switch no other off. **After Skip**, write nothing more: the apps that are on stay on. Done when the last answer's `apps` show `enabled` true for every chosen app and false for the rest (after `named`, true for that app), or, after Skip, nothing was written.
+2. **Ask which apps this run sets up**, on every run, with impeccable_ask: `id: "apps"`, `kind: "multi"`, and the `prompt` *"Which apps should get Impeccable previews?"*. The tool words the question and lists the state's apps (the repository's own, `main`, only where the Worker kept it as a product of its own), each picked as it is on, or every one after this run's confirm. Mark the Set up monorepo apps task in progress first. Every write and host tool for an app is refused until it is answered. It has no Skip: the person picks at least one app. Done when it answered `values` or `named` (the command was started for that one app with `--app`, from its card on the dashboard: the tool showed one confirm screen naming that app instead of the list, and the list all the same when the person asked for other apps there). Where no answer came (the input ended), the tool wrote nothing and the run ends there: call nothing more. After `named`, that app is the one this run sets up: every host read, key, proof, method and check is its own, and no other app is mentioned past that screen.
+3. **Write the picks**, one action a call as the item's instructions give them: `enable` each chosen app that is off, then `disable` each app that is on and was not chosen. The last app that is on cannot be switched off (409), which is why the enables come first. **After `named`**, `enable` that app when it is off, and switch no other off. Done when the last answer's `apps` show `enabled` true for every chosen app and false for the rest (after `named`, true for that app).
 4. **Read the state again** with impeccable_state. Done when the preview item's `apps` names each chosen app's `directory`, `build` and `method` (none yet for an app not set up), and `perApp` its status.
 5. **Set each chosen app up**, one after the other, as the playbook's steps 3 and 4 say for that app alone, `appKey` on every write and check (`preview`, `test-accounts`, `latest-pull-check`, `connection-check`): its method by the case that applies to it (server-previews when no host deploys it, a host's case when the host deploys that app as a project of its own, proven on that app's own address: impeccable_hosted_previews, impeccable_netlify_previews and impeccable_cloudflare_previews take its `appKey` and list only the previews of the project or site that builds its folder (impeccable_netlify_connect takes it too, and connects that site), so another app's address, project or key never stands in for it; their `unmatched` says why none can be told, and that app goes as server-previews says, with the reason under "What is not verified"), and its own sign-in when the scan item's `accessByApp` says it has one, each account question's title naming the app (*"Order desk admin account"*). **The lock in front of each app's previews is that app's own**: when its proof answers a `gate`, preview-protection's steps run for that app, with its `appKey`, before any other app's step (the tools refuse the next app's reads and writes until its key tool was called), and the key goes to that app's own project or site; a key saved for one app says nothing about another's, and the state's `keySaved` speaks for one app at most. Where a host's setup case (vercel-setup, netlify-setup) opens and records an app's test drive here, check that app's preview right after the recording, as pull-requests' step 6 says with its `appKey`, while its test drive is still the newest open pull request, before the next app is set up. Done when every chosen app's method is saved, or its preview skipped as server-previews says, and its sign-in saved or skipped, and no other app got a write, a build or a question.
 6. **The pull requests** as pull-requests says: the setup commit once for the repository, taking the state's one workflow `file` once every chosen app's method and build settings are saved, or its preview skipped as server-previews says. A run that sets up one app opens its test drive as pull-requests says, on `impeccable/test-drive`, its page in that app alone. A run that sets up more opens **a test drive of its own for each chosen app with a preview**, one app after the other, so each app's review shows on its own pull request; an app whose host's setup case (vercel-setup, netlify-setup) already opened, recorded and checked its test drive in step 5 has it, and gets none again. An app's test drive is branch `impeccable/test-drive-<appKey>` from the setup commit (from the default branch when there is none), with its page in that app alone, in that app's own framework and linked from that app's own public page, and no change to any other app; that case's step 3 builds that app as its host's case says; its step 4 pushes it and proves its page on that app's own preview, with that app's key where its lock stands in front; its step 5 opens it with the app's name in the title (*"Impeccable test drive: Storefront (safe to close)"*) and records it with impeccable_test_pr and that app's `appKey` (which the tool needs only when the run sets up more than one app); its step 6 checks that app with its `appKey` while its test drive is the newest open pull request, before the next app's test drive opens. An app whose preview was skipped gets no test drive, and goes under "What was skipped, and why". Step 7, when there is a setup commit, opens the setup pull request once, last, and records it with the last app's test drive and its `appKey` again. Done when every chosen app with a preview has its test drive recorded and checked, or the reason it has none in the report, and pull-requests' step 7 is done.
    - **A chosen app whose preview was skipped** (server-previews): it stays on, with no method, no job in the workflow and no test drive page. It holds nothing back: the other apps' setup commit, test drive and checks go on as above, and its checkup entry left in `next` counts as done for the playbook's step 5. The report says, on its line and under "What was skipped, and why", that it gets no preview until its host deploys them.
-7. **Report per app**: under "What was configured, and by whom", one line per app the question offered: on or off and why (picked, unticked, named with `--app`, on already after a skip), its method, its sign-in, what was verified; an app the question did not offer and the state shows off (`enabled` false) was turned off on the setup page, and its line says so, never that it was left off in the question; after `named`, an app still on that this run did not set up is outside this run, not turned off; an app left out is under "What was skipped, and why" as well, with the setup page as where it is turned on. impeccable_report adds a section of its own, "Each app, as this run left it", from what the run saved and proved, and the last screen says "You're all set up" only when every chosen app is: an app whose preview met a lock with no key saved, or got no method, is named there with its one step, so the report's lines say the same. Done when every app is on one line.
+7. **Report per app**: under "What was configured, and by whom", one line per app the question offered: on or off and why (picked, unticked, named with `--app`), its method, its sign-in, what was verified; an app the question did not offer and the state shows off (`enabled` false) was turned off on the setup page, and its line says so, never that it was left off in the question; after `named`, an app still on that this run did not set up is outside this run, not turned off; an app left out is under "What was skipped, and why" as well, with the setup page as where it is turned on. impeccable_report adds a section of its own, "Each app, as this run left it", from what the run saved and proved, and the last screen says "You're all set up" only when every chosen app is: an app whose preview met a lock with no key saved, or got no method, is named there with its one step, so the report's lines say the same. Done when every app is on one line.
 
 ### Reference
 

package/dist/playbook.js

@@ -41,7 +41,7 @@ The state names the setup page's other cards in \`notPartOfThisSetup\`. They are
 - Ask through impeccable_ask, which shows a dialog and returns the answer; a question written in your message reaches nobody.
 - Ask only for what the repository cannot tell you. Running this command is the person's go-ahead for every step, so ask no approval questions.
 - Ask the questions that belong together back to back, one call each.
-- Every question offers Skip: after a skip, carry on without the answer, and say in the report what it left undone.
+- Every question offers Skip but the apps question on a repository with several apps, which needs at least one app (the monorepo case): after a skip, carry on without the answer, and say in the report what it left undone.
 - **No run ends by telling the person to run the setup again**: what a step needs from them is asked in this run, on the tool's screen, and the run carries on. After a skip, or retries that ran out, the report says what stopped it, and no \`left\` line or question asks for a rerun.
 
 ## Commands

package/dist/pr-summary.js

@@ -0,0 +1,45 @@
+/**
+ * The summary in each pull request's description, with the pages it changes before and after (#402): pristine's
+ * `modules.overview`, off by default because it writes into the author's description, so the person is asked once,
+ * worded here and never by the model. One question per repository, since pristine keeps the setting there.
+ */
+export const PR_SUMMARY_SCREEN = {
+    id: 'pr-summary',
+    kind: 'confirm',
+    title: 'See every change, before and after',
+    hint: 'Each pull request gets side-by-side screenshots of the pages it changes, right in its description, so reviewers spot the difference at a glance. Turn it off any time in Settings.',
+    prompt: 'Show before and after on your pull requests?',
+    confirmLabel: 'Show it',
+    skipLabel: 'Not now',
+};
+/** The end screen's line when the summary is not on. */
+export const PR_SUMMARY_OFF = 'Before and after is off: turn it on any time in Settings.';
+const modulesOf = (data) => {
+    const modules = data?.effective?.modules;
+    return modules && typeof modules === 'object' && !Array.isArray(modules) ? modules : null;
+};
+/**
+ * Reads the repository's review settings, and unless the summary is on already asks the person; on their yes, reads
+ * them again, since Settings may have changed while the question was up, and saves `modules.overview: true` with every
+ * other module as it is in force then: the save replaces the whole `modules`, and the API has no conditional write.
+ * A Not now, an answer that never came (headless, closed input) or a settings read that failed writes nothing.
+ */
+export async function askPrSummary(read, ask, save) {
+    const inForce = async () => {
+        const current = await read();
+        return current.ok ? modulesOf(current.data) : null;
+    };
+    const before = await inForce();
+    if (!before)
+        return 'off';
+    if (before.overview === true)
+        return 'on';
+    if ((await ask(PR_SUMMARY_SCREEN)).skipped)
+        return 'off';
+    const modules = await inForce();
+    if (!modules)
+        return 'off';
+    if (modules.overview === true)
+        return 'on';
+    return (await save({ modules: { ...modules, overview: true } })).ok ? 'on' : 'off';
+}

package/dist/tools.js

@@ -319,7 +319,7 @@ const ASK = {
         prefill: { type: 'string', minLength: 1, description: 'text, not with sensitive, and account: what the (username) field holds when the dialog opens, such as the seed\'s username. The person can change it.' },
         confirmLabel: { type: 'string', minLength: 1, description: 'confirm only: the way on, such as "Share test accounts".' },
         skipLabel: { type: 'string', minLength: 1, description: 'confirm only: the other way, such as "Skip for now".' },
-        skippable: { type: 'boolean', description: 'Every question offers Skip, whatever this says.' },
+        skippable: { type: 'boolean', description: 'Every question offers Skip, whatever this says, but the apps question.' },
         sensitive: { type: 'boolean', description: 'text only: a password. The person types it hidden, and the answer\'s value is a reference ("secret:…") that impeccable_write turns back into what they typed. A text question whose title, prompt or hint names a token, a password, a secret, a key or a credential is asked this way whatever this says.' },
     },
 };
@@ -2217,7 +2217,7 @@ export function createTools(ctx) {
     /** Whether the repository has several apps (the state's apps item), as the first state or a later read showed it. */
     let appsRepo = ctx.severalApps === true;
     /**
-     * The apps this run sets up, as the apps question answered (after a skip, the ones on): undefined until it was asked.
+     * The apps this run sets up, as the apps question answered: undefined until it was answered.
      * On a repository with several apps every run asks it, however the setup page answered before (#280), and every write
      * and host read for an app names one of these.
      */
@@ -2396,35 +2396,53 @@ export function createTools(ctx) {
     }
     /**
      * The apps question (#280), worded here and listing the apps the state has, each picked as it is on (every one, where
-     * this run confirmed the scan's proposal); the command started for one app (--app) answers it without a screen. The
-     * answer is the apps this run sets up; after a skip, those that are on.
+     * this run confirmed the scan's proposal); the command started for one app (--app) answers it on one confirm screen.
+     * The answer is the apps this run sets up, at least one: the question has no Skip (#405).
      */
-    async function appsQuestion(pi) {
+    async function appsQuestion(pi, signal) {
         const apps = await stateApps(pi);
         if (!apps || apps.length < 2)
             return 'Refused: the setup state could not be read, or lists fewer than two apps: read it again with impeccable_state, then ask again.';
-        // Started for one app (--app, from its card): one confirm screen naming it instead of the list, whose Skip opens the list for someone who wants another app (#286).
+        // Started for one app (--app, from its card): one confirm screen naming it instead of the list, whose Pick other apps opens the list for someone who wants another app (#286).
         const named = ctx.app !== undefined ? apps.find((a) => a.key === ctx.app) : undefined;
-        if (named && !(await ask(namedAppQuestion(named))).skipped) {
-            pick(new Set([named.key]));
-            return JSON.stringify({ values: [named.key], named: true });
+        if (named) {
+            const screen = namedAppQuestion(named);
+            const answer = await ask(screen);
+            if (answer.closed)
+                return unanswered(pi, screen, signal);
+            if (!answer.skipped) {
+                pick(new Set([named.key]));
+                return JSON.stringify({ values: [named.key], named: true });
+            }
         }
         // Started below the top: the app whose folder holds that folder (the deepest, never the root's) is ticked too, and the hint says so.
         const start = ctx.start ?? '';
         const here = start ? apps.filter((a) => a.folder && (start === a.folder || start.startsWith(`${a.folder}/`))).sort((a, b) => b.folder.length - a.folder.length)[0] : undefined;
         const hint = here ? startedIn(`${here.name}'s folder`) : start ? startedIn(start) : APPS_QUESTION.hint;
-        // Reached by Esc on the named app's screen ("Pick other apps"), the list has no Skip on Esc: a second Esc to go back would skip the apps (#324).
-        const answer = await ask({ ...APPS_QUESTION, hint, options: apps.map((a) => ({ label: `${a.name} · ${a.folder || '/'}`, value: a.key, selected: confirmedApps || a.enabled || a === here || a === named })) }, !named);
-        if (answer.skipped) {
-            pick(new Set(apps.filter((a) => a.enabled).map((a) => a.key)));
-            return JSON.stringify({ skipped: true, on: [...pickedApps] });
+        const list = { ...APPS_QUESTION, hint, options: apps.map((a) => ({ label: `${a.name} · ${a.folder || '/'}`, value: a.key, selected: confirmedApps || a.enabled || a === here || a === named })) };
+        // No Skip: Continue is the only way on, with at least one app picked (#405). A blank line in a piped run picks none, so the list goes again; on the list the named app's screen opened, the named app stands.
+        for (;;) {
+            const answer = await ask(list, false);
+            if (answer.skipped)
+                return unanswered(pi, list, signal);
+            const values = (answer.values ?? []).filter((value) => apps.some((a) => a.key === value));
+            if (named && !values.length)
+                values.push(named.key);
+            if (!values.length)
+                continue;
+            pick(new Set(values));
+            return JSON.stringify({ values });
         }
-        const values = (answer.values ?? []).filter((value) => apps.some((a) => a.key === value));
-        // Nothing picked on the list the named app's screen opened, which has no Skip (a blank line in a piped run): the named app stands.
-        if (named && !values.length)
-            values.push(named.key);
-        pick(new Set(values));
-        return JSON.stringify({ values });
+    }
+    /**
+     * No answer came on the apps question (the input ended, or the run stopped with it up), which has no Skip: nothing is
+     * written, and the run ends here as stopped while waiting for that answer, which the end screen and the web page name.
+     */
+    function unanswered(pi, screen, signal) {
+        signal?.throwIfAborted();
+        ctx.sync.update({ phase: 'waiting', question: { id: screen.id, prompt: screen.prompt } });
+        pi.shutdown();
+        return { text: 'No answer came on the apps question, so no app was picked and nothing was written. The run ends here.', terminate: true };
     }
     return [
         tool('impeccable_workflow_access', 'Check workflow access', 'Check that the setup pull request can carry the workflow: reads the active GitHub CLI account and its scopes, the origin remote and the default branch, and refreshes origin/<defaultBranch>. Call it before branching. needsWorkflowScope true means the account lacks workflow access over HTTPS; base.status "refreshed" means origin/<defaultBranch> is current. push is whether git may push to origin, as a dry run at the start found it.', NO_INPUT, (_p, pi, signal) => workflowAccessTool(pi, signal)),
@@ -2614,11 +2632,11 @@ export function createTools(ctx) {
             // A test account never comes back to the model, even if the API echoed it.
             return testAccounts ? redact(answerText(response), typed.values()) : answerText(response);
         }),
-        tool('impeccable_ask', 'Ask the person', 'Ask the person one question in a dialog, and wait for the answer; the web page shows the run waiting meanwhile. Answers {"value": "…"} for text and single, {"values": […]} for multi, {"confirmed": true} for confirm, {"username": "…", "password": "secret:…"} for account, or {"skipped": true}. A host\'s setup question (id "vercel-setup", "vercel-team", "netlify-setup" or "netlify-team") is worded by this tool: give it that id and its kind. So is the apps question on a repository with several apps (id "apps", kind "multi"), which lists the state\'s apps itself and answers {"values": […]}, {"values": [key], "named": true} when the command was started for that app (it shows one confirm screen naming the app instead of the list, and the list when the person asks for other apps there), or {"skipped": true, "on": […]}. netlify-setup and vercel-setup are the host\'s sign-in: it shows its screen only when that CLI is signed out, signs the person in through the browser with a retry, and answers {"confirmed": true, "signedIn": true}, with "team" (the one the project goes into) or "teams" to choose from when the person has several, {"confirmed": true, "cli": "missing"} when the CLI is to be installed first and this asked again, or {"skipped": true}.', ASK, async (p, pi, signal) => {
-            // A skip never stops the run, so every question offers one.
+        tool('impeccable_ask', 'Ask the person', 'Ask the person one question in a dialog, and wait for the answer; the web page shows the run waiting meanwhile. Answers {"value": "…"} for text and single, {"values": […]} for multi, {"confirmed": true} for confirm, {"username": "…", "password": "secret:…"} for account, or {"skipped": true}. A host\'s setup question (id "vercel-setup", "vercel-team", "netlify-setup" or "netlify-team") is worded by this tool: give it that id and its kind. So is the apps question on a repository with several apps (id "apps", kind "multi"), which lists the state\'s apps itself, has no Skip, and answers {"values": […]} (at least one app) or {"values": [key], "named": true} when the command was started for that app (it shows one confirm screen naming the app instead of the list, and the list when the person asks for other apps there); where no answer comes, nothing is written and the run ends. netlify-setup and vercel-setup are the host\'s sign-in: it shows its screen only when that CLI is signed out, signs the person in through the browser with a retry, and answers {"confirmed": true, "signedIn": true}, with "team" (the one the project goes into) or "teams" to choose from when the person has several, {"confirmed": true, "cli": "missing"} when the CLI is to be installed first and this asked again, or {"skipped": true}.', ASK, async (p, pi, signal) => {
+            // A skip never stops the run, so every question offers one, but the apps question, which needs at least one app (#405).
             const asked = p;
             if (asked.id === APPS_QUESTION.id && appsRepo)
-                return appsQuestion(pi);
+                return appsQuestion(pi, signal);
             const host = /^(netlify|vercel)-(setup|team)$/.exec(asked.id);
             // The Vercel setup is for a repository Vercel has never deployed: one it deploys already (every app this run sets up, on a repository with several), as impeccable_hosted_previews read it, gets its previews from the first pull request on (#286). An app with no project of its own still gets the screen, and a setup under way (asked again once the CLI was installed) is not stopped here.
             const deployed = appsRepo ? pickedApps !== undefined && pickedApps.size > 0 && [...pickedApps].every((key) => vercelDeployed.has(key)) : vercelDeployed.has('');
@@ -2650,8 +2668,10 @@ export function createTools(ctx) {
                 ctx.log.write('ask hidden (names a credential)', q.id);
             if (q.kind === 'text' && !q.sensitive)
                 q.caution = NEVER_A_CREDENTIAL;
-            // The apps question's screen is the tool's to show (TOOL_SHOWN), so the web page hears of it here.
-            const answer = q.id === APPS_QUESTION.id ? await ask(q) : await askPerson(q);
+            // The apps question's screen is the tool's to show (TOOL_SHOWN), so the web page hears of it here; it has no Skip (#405).
+            const answer = q.id === APPS_QUESTION.id ? await ask(q, false) : await askPerson(q);
+            if (q.id === APPS_QUESTION.id && answer.skipped)
+                return unanswered(pi, q, signal);
             if (answer.skipped) {
                 // Without a terminal the Vercel CLI names no team on its own, so a skipped team ends the Vercel setup.
                 if (host?.[1] === 'vercel')

package/dist/ui/look.js

@@ -80,7 +80,8 @@ function dotRows(word, max) {
 /** A paragraph of plain text wrapped to at most `max` columns: a sentence a line when each fits, else lines as even as the words allow. */
 function balanced(given, max) {
     const text = given.split(' ').map((word) => dotRows(word, max).join('\n')).join(' ');
-    const sentences = text.split(/(?<=[.!?])\s+/);
+    // A sentence ends on a mark after its last word: the "!" a warning opens with is no sentence of its own.
+    const sentences = text.split(/(?<=\S[.!?])\s+/);
     if (sentences.length > 1 && sentences.every((line) => visibleWidth(line) <= max))
         return sentences;
     const lines = wrapTextWithAnsi(text, Math.max(10, max));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@impeccable/reviews",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "Set up a repository for Impeccable for PRs from your terminal.",
   "license": "SEE LICENSE IN LICENSE",
   "private": false,