litmus-cli 1.4.46 → 1.4.48

package/dist/commands/connect.js

@@ -16,7 +16,7 @@ import { parseEditorVersion, parseWorkspaceProbe, remoteProbeCommand, seedVerdic
 import { fatal, success, info, warn, setErrorContext } from "../lib/errors.js";
 import { oldWindowsSshHint, parseOpenSshVersion, proxyJumpBroken, readEditorSettings, readSshVersionBanner, sshExecutableFor, sshPreflight, sshPreflightHint, } from "../lib/ssh-client.js";
 import { editorEndingForewarning } from "../lib/session-end.js";
-import { announceCursorAutoRestart, attemptQuit, platformSupportsGracefulCursorRestart, realCursorProcessIo, renderCursorRestartOutcome, } from "../lib/cursor-restart.js";
+import { attemptQuit, attemptRelaunch, platformSupportsGracefulCursorRestart, realCursorProcessIo, } from "../lib/cursor-restart.js";
 /**
  * `litmus connect <token>` — the CLI connector for the v2 codespace, modeled on
  * `gh codespace ssh/code`. It removes the manual "paste your public key + copy
@@ -371,7 +371,7 @@ export const NATIVE_EDITORS = {
         downloadUrl: "https://cursor.com/download",
         seedCommitPath: "/opt/cursor-server-cache/COMMIT",
         serverHomeDir: ".cursor-server",
-        requiresSeedMatch: true,
+        requiresSeedMatch: false,
     },
 };
 /**
@@ -492,344 +492,147 @@ export function identifyEditorCli(ed, command, run = runEditorHelp) {
         return { kind: "unverified" };
     return actual === ed.ide ? { kind: "match" } : { kind: "mismatch", actual };
 }
+/**
+ * ENG-2890 — the copy rules every connect outcome below follows.
+ *
+ * A hiring manager watched a candidate fail to open Cursor behind a ~41-line notice,
+ * quit and retry several times, and get nowhere. So each outcome is a few lines, the
+ * action first, with no mechanism words, and NO CREDENTIAL: the connect token and the
+ * browser-IDE URL (which carries `t=`) are never printed. The way back is "run the same
+ * litmus connect command again", which is in the candidate's shell history, and the
+ * assessment page, whose URL carries only the assessment id (`candidatePageUrl`).
+ */
+const SAME_COMMAND = "run the same litmus connect command";
+/**
+ * The route that needs nothing else to work: the browser IDE, reached from the page,
+ * or the alias we have just written into their ~/.ssh/config.
+ */
+export function workNowLine(alias, pageUrl) {
+    const page = pageUrl
+        ? `the browser IDE on your assessment page (${chalk.cyan(pageUrl)})`
+        : "the browser IDE on your assessment page";
+    return `  Or work now: ${page}, or ${chalk.cyan(`ssh ${alias}`)}.`;
+}
+/** Where the long form went. Not printed when it is already being shown. */
+function detailsLine(verbose) {
+    return verbose ? [] : [chalk.dim("  Details: add --verbose.")];
+}
 /**
  * ENG-2152 — the refusal, when the command the candidate's PATH answers with is the
- * other editor.
- *
- * Two routes, and the one that WORKS RIGHT NOW comes first: on a machine where `code` is
- * Cursor, Cursor is almost certainly the daily driver and VS Code may not be installed at
- * all, so leading with "fix your PATH" leads with the thing that may be impossible.
- * That ordering is the same one `announceCursorFullQuit` documents — what a candidate can
- * act on immediately is what they read first.
- *
- * The offered command carries the token already inlined, for the reason `CursorReentry`
- * gives: a `litmus connect <token>` a candidate has to repair themselves is worse than no
- * command at all.
- *
- * When the editor that answered is Cursor, the quit requirement rides along. It is the
- * headline only, not the whole ENG-1728 notice, because the command being offered prints
- * that notice in full at selection time before anything opens — this is a FORWARD
- * reference to output the candidate is about to see, not ENG-2145's back-reference to
- * output that has scrolled away. Restating the whole block here would also have to
- * restate its "this command is still running and will open Cursor for you", which on
- * this path is false.
+ * other editor. Nothing has been opened and no extension installed when this prints.
+ *
+ * The editor that answered comes first: on a machine where `code` is Cursor, Cursor is
+ * almost certainly the daily driver and VS Code may not be installed at all. The PATH
+ * fix follows in one line, then the routes that need neither.
  */
-export function editorMismatchLines(chosen, actual, reentry = CURSOR_REENTRY_FALLBACK) {
-    const lines = [
-        "",
-        chalk.yellow.bold(`  ⚠  The \`${chosen.bin}\` command on your PATH is ${actual.label}, not ${chosen.label}.`),
-        "",
-        `     You asked for ${chosen.label}, so nothing has been opened and no extension has been`,
-        `     installed. Working in ${actual.label} while you believe you are in ${chosen.label} would`,
-        "     leave your AI work unrecorded, so this stops here instead.",
-        "",
-        "     Your workspace is up and waiting — nothing has been lost.",
-        "",
-        `     To carry on in ${actual.label} — which is what \`${chosen.bin}\` actually is — run:`,
-        "",
-        `       ${chalk.cyan(`${reentry.command} --ide ${actual.ide}`)}`,
+export function editorMismatchLines(chosen, actual, alias, pageUrl) {
+    return [
+        chalk.yellow.bold(`⚠ The \`${chosen.bin}\` command on your PATH is ${actual.label}, not ${chosen.label}. Nothing was opened.`),
+        `  To use ${actual.label}: ${SAME_COMMAND} with ${chalk.cyan(`--ide ${actual.ide}`)}.`,
+        `  To use ${chosen.label}: in ${chosen.label}, run "${chosen.shellCommand}" from the Command Palette, open a new terminal, then ${SAME_COMMAND} again.`,
+        workNowLine(alias, pageUrl),
     ];
-    if (actual.ide === "cursor") {
-        lines.push("");
-        lines.push(chalk.yellow("     ⚠ Quit Cursor completely before you run that, or your work is not recorded."));
-        lines.push("       That command explains why, in full, before anything opens.");
-    }
-    lines.push("");
-    lines.push(`     To carry on in ${chosen.label} instead, put its own \`${chosen.bin}\` command first on`);
-    lines.push(`     your PATH: in ${chosen.label}, run "${chosen.shellCommand}" from the`);
-    lines.push("     Command Palette, then open a NEW terminal and check that");
-    lines.push(`     \`${chosen.bin} --help\` names ${chosen.label}. Then run the same \`litmus connect\` command again.`);
-    lines.push("");
-    return lines;
 }
 /**
-* ENG-2332 — the refusal when the candidate's editor is a different build from the one
- * this workspace has, and the route to the workspace that still works.
- *
- * What it must never do is offer a way round the refusal: there is no flag and no "open
- * it anyway", since the thing on the other side of that door is a window that looks
- * completely normal and records nothing (`lib/editor-server.ts` carries the measurement).
- *
- * ENG-2867 — but it must say the one thing that DOES change the verdict, and say it first.
- * The image bakes the latest Stable build at image build time and Cursor ships about
- * weekly, so the usual mismatch is a candidate one release behind, and updating is what
- * clears it. The ENG-2332 cut never said so. A candidate who had just been told to quit
- * Cursor read that as the remedy and re-ran the same refused command four times. So the
- * order is: what to do, that retrying without it will not help, the exact command to run
- * after, and only then why. The "why" is one sentence; it used to be the whole notice.
- *
- * Update is not guaranteed to land on the baked build: an image built before the newest
- * release is refused again after updating, since `seedVerdict` wants an exact commit. So
- * the copy says "usually", names that outcome as step 4, and the routes that need no
- * update follow it (Greptile on #3033). Step 4 diagnoses nothing: the check compares
- * commits, and a second refusal has more causes (an older image, a second install found
- * first) than a notice can tell apart. The routes below always work, so step 4 sends the
- * candidate there and states only the one fact the version line proves.
+ * ENG-2332 — the refusal when the candidate's editor is a different build from the one
+ * this workspace has.
+ *
+ * ENG-2884: no editor sets `requiresSeedMatch` any more, so this is reachable only if one
+ * is measured failing again and the flag goes back on. Kept short for that day: what
+ * happened, that updating usually clears it, and the routes that need no update. There is
+ * deliberately no "open it anyway".
  */
-export function editorSeedMismatchLines(ed, verdict, browserIdeUrl, alias, reentry = CURSOR_REENTRY_FALLBACK) {
-    const short = (c) => c.slice(0, 12);
-    const width = Math.max(`Your ${ed.label}:`.length, "This workspace:".length) + 1;
-    const lines = [
-        "",
-        chalk.yellow.bold(`  ⚠  Update ${ed.label}, then run this again. Your ${ed.label} is a different release`),
-        chalk.yellow.bold(`     from the one this workspace was built for, so it cannot open it.`),
-        "",
-        `     ${`Your ${ed.label}:`.padEnd(width)}${verdict.clientVersion ?? "unknown version"} (${short(verdict.clientCommit)})`,
-        `     ${"This workspace:".padEnd(width)}${short(verdict.seedCommit)}`,
-        "",
-        chalk.bold(`     Running this again, or quitting ${ed.label}, will not fix it. Updating usually does:`),
-        "",
-        `       1. Update ${ed.label}: use "Check for Updates" in ${ed.label}'s menu, or download it from`,
-        `          ${chalk.cyan(ed.downloadUrl)}`,
-        `       2. Quit ${ed.label} completely (Cmd+Q on macOS; File → Exit on Windows/Linux).`,
-        `       3. From a terminal that is NOT inside ${ed.label}, run:`,
-        `            ${chalk.cyan(`${reentry.command} --ide ${ed.ide}`)}`,
-        "       4. If it is refused again, use one of the routes below. (If \"Your " + ed.label + "\" still",
-        `          shows the old version, this command is reading a different ${ed.label} install than`,
-        "          the one you updated.)",
-        "",
-        chalk.dim(`     (Why: ${ed.label} needs a matching server inside the workspace, and the workspace cannot`),
-        chalk.dim("     download one. A mismatched window looks normal, but your work in it is not recorded, so"),
-        chalk.dim("     nothing was opened. Your workspace is up and waiting, and nothing is lost.)"),
-        "",
-        `     Refused after updating, or short on time? Work in the same workspace, fully recorded:`,
-        "",
+export function editorSeedMismatchLines(ed, verdict, pageUrl, alias) {
+    const which = verdict.clientVersion ? `${ed.label} ${verdict.clientVersion}` : `This ${ed.label}`;
+    return [
+        chalk.yellow.bold(`⚠ ${which} can't open this workspace.`),
+        `  Try updating ${ed.label} (${chalk.cyan(ed.downloadUrl)}), then ${SAME_COMMAND} again.`,
+        workNowLine(alias, pageUrl),
     ];
-    if (browserIdeUrl) {
-        lines.push(`       Browser IDE:  ${chalk.cyan(browserIdeUrl)}`);
-    }
-    else {
-        lines.push("       Browser IDE:  open your assessment page and use the browser IDE there");
-    }
-    if (ed.ide !== "vscode") {
-        lines.push(`       VS Code:      ${chalk.cyan(`${reentry.command} --ide vscode`)}`);
-    }
-    lines.push(`       Terminal:     ${chalk.cyan(`ssh ${alias}`)}`);
-    lines.push("");
-    return lines;
 }
 /**
  * ENG-2332 — what to say when the editor CLI cannot be found anywhere.
  *
- * The line this replaces offered `<bin> --remote ssh-remote+<alias> …` as the
- * remediation for `<bin>` not existing. Everything here is something the candidate can do
- * WITHOUT that command: the editor's own Remote-SSH picker (the alias is already in their
- * `~/.ssh/config`), the palette command that would put the CLI on PATH, and the browser
- * IDE, which needs nothing installed at all.
+ * Never `<bin> --remote …`: that is the binary whose absence is the message. Everything
+ * here works without it: the editor's own Remote-SSH picker (the alias is already in
+ * their `~/.ssh/config`), the palette command that puts the CLI on PATH, and the routes
+ * that need no editor.
  */
-export function editorNotFoundLines(ed, alias, browserIdeUrl) {
-    const lines = [
-        "",
-        chalk.yellow.bold(`  ⚠  Couldn't find ${ed.label}'s \`${ed.bin}\` command on this machine.`),
-        "",
-        `     It is not on your PATH and it is not where ${ed.label}'s installer puts it, so`,
-        "     nothing has been opened. Your workspace is up and waiting — nothing is lost.",
-        "",
-        `     Your SSH config is already written, so from inside ${ed.label} you can connect`,
-        "     with no command line at all:",
-        "",
-        `       Command Palette → ${chalk.bold("Remote-SSH: Connect to Host…")} → ${chalk.bold(alias)}`,
-        "",
-        `     (Needs the "${ed.remoteSshExt}" extension, which ${ed.label} will offer to install.)`,
-        "",
-        `     To get the \`${ed.bin}\` command for next time: in ${ed.label}, Command Palette →`,
-        `     "${ed.shellCommand}", then open a NEW terminal.`,
+export function editorNotFoundLines(ed, alias, pageUrl) {
+    return [
+        chalk.yellow.bold(`⚠ Couldn't find ${ed.label}'s \`${ed.bin}\` command, so nothing was opened.`),
+        // Greptile on #3071: this route never restarts Cursor, and Cursor only loads the
+        // workspace's prompt recording when the app starts (gotcha 090).
+        ...(ed.ide === "cursor" ? ["  Quit Cursor completely and reopen it first, or your AI prompts won't be recorded."] : []),
+        `  In ${ed.label}: Command Palette → ${chalk.bold("Remote-SSH: Connect to Host…")} → ${chalk.bold(alias)}`,
+        `  To get the \`${ed.bin}\` command for next time: Command Palette → "${ed.shellCommand}".`,
+        workNowLine(alias, pageUrl),
     ];
-    if (browserIdeUrl) {
-        lines.push("");
-        lines.push("     Or skip the editor entirely — the browser IDE needs nothing installed:");
-        lines.push(`       ${chalk.cyan(browserIdeUrl)}`);
-    }
-    lines.push("");
-    return lines;
 }
 /**
- * ENG-2332 — the positive signal, which the CLI had none of.
- *
- * It states exactly what was verified and not one step more. A server running in the
- * workspace means the window is editing the container's files, so the file, terminal and
- * commit lanes are live — that is what "recorded" may claim here.
- *
- * IT MAY NOT CLAIM AI CAPTURE ON CURSOR, and that is not hedging. Cursor reads its hooks
- * configuration once, at application startup (ENG-1728, measured): a candidate who
- * connected from an already-running Cursor has a live, correct, never-loaded hook, and
- * their prompts are not recorded although everything else is. The verification above
- * cannot see that — a server is up either way — so a flat "your work is being recorded"
- * would be the same false reassurance this ticket is about, moved one lane along. The
- * full notice is printed at selection time; this restates only the dependency.
+ * ENG-2332 — the footer under the verified success line.
+ *
+ * ENG-2890: for Cursor, one line naming the window that IS connected, since a restart
+ * can leave the candidate's other Cursor windows reopening beside it. The window title
+ * is safe to name here and only here: this prints after `verifyEditorAttached` saw a
+ * server, unlike the failure branches, where the never-attached window carries the same
+ * `[SSH: <alias>]` (ENG-2154). The workspace path is for whoever is debugging, so it is
+ * `--verbose` only. VS Code needs no footer.
  */
-export function editorConnectedLines(ed, alias) {
-    const lines = [chalk.dim(`  Workspace: ${alias}:${REMOTE_WORKSPACE_DIR}`)];
+export function editorConnectedLines(ed, alias, verbose = false, platform = process.platform) {
+    const lines = [];
+    if (verbose)
+        lines.push(chalk.dim(`  Workspace: ${alias}:${REMOTE_WORKSPACE_DIR}`));
     if (ed.ide === "cursor") {
-        lines.push(chalk.dim("  Your AI prompts are recorded only if you quit Cursor completely before this opened;"));
-        lines.push(chalk.dim("  reloading the window or reconnecting does not load the hook."));
+        const mod = platform === "darwin" ? "Cmd" : "Ctrl";
+        lines.push(`  Use the Cursor window titled "workspace [SSH: ${alias}]". ${mod}+Shift+E shows your files.`);
     }
     return lines;
 }
 /**
- * ENG-2332 — what to say when a window opened and no server came up in the workspace.
- *
- * This is the copy the ticket was opened about. It used to be
- * "If a new window doesn't appear, run litmus connect again" — which is wrong twice: a
- * window DOES appear in this failure, and re-running connect cannot change the state,
- * which is exactly what had the reporter run it four times. So it names what was
- * observed, and every route it offers is one this failure does not block.
- *
- * `seed` rides along because on VS Code a mismatch is not a refusal (see
- * `requiresSeedMatch`) — so when a VS Code launch does fail, the build difference is the
- * first thing worth knowing, and it is already in hand.
- *
- * WHAT IT MAY NOT SAY IS THAT NOTHING WILL CHANGE. That is what it said first, and it is
- * a claim about the future made on a reading that stops at the verification budget. A VS
- * Code client whose build the image did not bake is NOT refused (`requiresSeedMatch`), so
- * its launch legitimately goes on to fetch a server through the mirror — a ~28.6 MB CLI
- * and, on a prewarm miss, the whole bundle — and a slow link can still be fetching when
- * the budget runs out. Telling that candidate their window is dead and pointing them
- * elsewhere is the harm `unverified` exists to avoid, arriving on the branch below it.
- * So it states the bound it actually waited (derived from `VERIFY_SCHEDULE_MS`, never a
- * second hard-coded copy), says the window may yet attach, and offers the other two
- * routes rather than instructing an exit. What it still may not do is tell them to re-run
- * this command, which is the original bug.
- *
- * AND IT MAY NOT HAND THEM A CHECK THAT PASSES ON THE DEAD WINDOW. It pointed at the
- * remote indicator — "the bottom-left corner reads SSH: <alias>" — and this repo has
- * measured that indicator PRESENT in exactly the failure case: `lib/editor-server.ts`'s
- * header records the never-attached window carrying `"remoteAuthority":
- * "ssh-remote+<alias>"` and being indistinguishable from a working one, and
- * `lib/session-end.ts` records (ENG-2154) that a window whose transport is gone still
- * reads `[SSH: <host>]`. A candidate told to look at the corner sees what they were told
- * to look for and goes on working unrecorded, which is this ticket's own bug re-entering
- * through its remediation. The honest sentence is that the two windows look the same —
- * that is WHY the CLI checks — so the copy says so and names no visual test at all.
+ * ENG-2332 — a window opened and no server came up in the workspace, so that window is
+ * running against the candidate's own machine and records nothing.
+ *
+ * ENG-2890: four lines. Close the window, retry with the cause that usually explains it
+ * (an editor that stopped to ask for a sign-in or an update), or work elsewhere now.
+ *
+ * IT MAY NOT HAND THEM A CHECK THAT PASSES ON THE DEAD WINDOW. The remote indicator
+ * ("SSH: <alias>" in the corner) is PRESENT on the never-attached window
+ * (`lib/editor-server.ts`'s header; ENG-2154 in `lib/session-end.ts`), so no visual test
+ * is named here at all.
  */
-export function editorNotConnectedLines(ed, alias, browserIdeUrl, seed, launchLog) {
-    const waited = Math.round(VERIFY_SCHEDULE_MS[VERIFY_SCHEDULE_MS.length - 1] / 1000);
-    const lines = [
-        "",
-        chalk.yellow.bold(`  ⚠  ${ed.label} opened, but it never started a server in your workspace.`),
-        "",
-        `     A ${ed.label} window is on screen and it is NOT attached to your workspace: it is`,
-        "     running against your own machine. Anything you do in that window is work on your",
-        chalk.yellow("     laptop, and it is not recorded."),
-        "",
-        `     We watched your workspace for ${waited} seconds after opening it and nothing`,
-        `     started there. A first-ever ${ed.label} connection can still be downloading its`,
-        "     server at that point and attach a little later. There is nothing you can check",
-        "     by eye: an attached window and an unattached one look exactly the same, which is",
-        "     why this command checks your workspace instead of asking you to.",
-        "",
+export function editorNotConnectedLines(ed, alias, pageUrl, verbose = false) {
+    return [
+        // Greptile on #3071: a first download of this build's server can outlast the check, so
+        // the window may still attach; it is not called dead.
+        `  It may still be setting up. If the ${ed.label} window doesn't show your workspace files in a couple of minutes, close it: work in it isn't recorded.`,
+        `  Then ${SAME_COMMAND} again. If ${ed.label} asked you to sign in or update, that's usually why.`,
+        workNowLine(alias, pageUrl),
+        ...detailsLine(verbose),
     ];
-    if (seed.kind === "mismatch") {
-        lines.push(`     The likely reason: your ${ed.label} is build ${seed.clientCommit.slice(0, 12)} and this`);
-        lines.push(`     workspace holds ${seed.seedCommit.slice(0, 12)}. It could not fetch a matching one.`);
-        lines.push("");
-    }
-    if (browserIdeUrl) {
-        lines.push("     You can work in the browser IDE instead — same workspace, same files, fully");
-        lines.push("     recorded, and nothing to install:");
-        lines.push(`       ${chalk.cyan(browserIdeUrl)}`);
-    }
-    else {
-        lines.push("     You can work in the browser IDE instead, from your assessment page — same");
-        lines.push("     workspace, same files, fully recorded.");
-    }
-    lines.push("");
-    lines.push("     You can also work from a terminal, which does not need the editor at all:");
-    lines.push(`       ${chalk.cyan(`ssh ${alias}`)}`);
-    if (launchLog) {
-        lines.push("");
-        lines.push(chalk.dim(`     ${ed.label} said, while trying to open:`));
-        for (const line of launchLog.split(/\r?\n/).slice(-8))
-            lines.push(chalk.dim(`       ${line}`));
-    }
-    lines.push("");
-    return lines;
 }
 /**
- * ENG-2332 — what to say when the editor never started at all.
- *
- * THIS BRANCH EXISTS BECAUSE THE ONE ABOVE MUST NOT BE REACHABLE WITHOUT A WINDOW.
- * `editorNotConnectedLines` opens by stating, as a fact, that a window is on screen and
- * running against the candidate's own machine; when `spawn` itself fails that sentence is
- * false, and the reading the verification produces is identical either way (no server,
- * empty launch log). So the spawn error is recorded (`EditorLaunchHandle`) and routed
- * here instead, where the only claim made is the one we can support.
- *
- * It offers the same two routes and, like every other failure branch, offers rather than
- * instructs: there is no window to close, and re-running this command is the remediation
- * the ticket was opened about. The error text is carried verbatim because it is the whole
- * of what we know — `ENOENT` on a resolved path means the app moved or was removed since
- * the `--version` probe a moment earlier, which is a thing the candidate can act on and
- * we cannot diagnose for them.
+ * ENG-2332 — the editor never started at all, so no window exists.
+ *
+ * Its own branch because `editorNotConnectedLines` tells them to close a window, which
+ * is false when `spawn` failed. The error is carried verbatim: it is all we know.
  */
-export function editorLaunchFailedLines(ed, alias, browserIdeUrl, error, launchLog) {
-    const lines = [
-        "",
-        chalk.yellow.bold(`  ⚠  ${ed.label} could not be started, so no window was opened.`),
-        "",
-        `     We found the ${ed.label} command and it answered a moment ago, but running it`,
-        "     failed:",
-        `       ${chalk.dim(error)}`,
-        "",
-        `     That usually means ${ed.label} was moved, removed or updated between those two`,
-        "     moments. Nothing has been opened and nothing is being recorded yet.",
-        "",
-    ];
-    if (browserIdeUrl) {
-        lines.push("     You can work in the browser IDE instead — same workspace, same files, fully");
-        lines.push("     recorded, and nothing to install:");
-        lines.push(`       ${chalk.cyan(browserIdeUrl)}`);
-    }
-    else {
-        lines.push("     You can work in the browser IDE instead, from your assessment page — same");
-        lines.push("     workspace, same files, fully recorded.");
-    }
-    lines.push("");
-    lines.push("     You can also work from a terminal, which does not need the editor at all:");
-    lines.push(`       ${chalk.cyan(`ssh ${alias}`)}`);
-    if (launchLog) {
-        lines.push("");
-        lines.push(chalk.dim(`     ${ed.label} said, while trying to open:`));
-        for (const line of launchLog.split(/\r?\n/).slice(-8))
-            lines.push(chalk.dim(`       ${line}`));
-    }
-    lines.push("");
-    return lines;
+export function editorLaunchFailedLines(ed, alias, pageUrl, error, verbose = false) {
+    return [`  ${chalk.dim(error)}`, workNowLine(alias, pageUrl), ...detailsLine(verbose)];
 }
 /**
- * ENG-2332 — what to say when we could not reach the workspace to ask at all.
- *
- * Three-valued on purpose: "we could not check" is not "nothing came up", and saying
- * either of the other two here would be a claim we cannot make. It lives beside the other
- * copy rather than inline in `runConnect` so that what it may and may not say is testable
- * — it is bound by the same rule as `editorNotConnectedLines` and broke it the same way.
- *
- * It may NOT tell the candidate to look at the remote indicator. That indicator is
- * rendered from the remote authority, which the never-attached window carries (see
- * `lib/editor-server.ts`'s header, and ENG-2154 in `lib/session-end.ts`), so the check
- * passes in exactly the case it was offered to detect. It states the ambiguity instead
- * and offers the two routes that are not in doubt.
+ * ENG-2332 — we could not reach the workspace to ask, which is not "nothing came up".
+ *
+ * It may NOT offer the remote indicator as a check (ENG-2154: the never-attached window
+ * carries it). The file explorer is a fair one: a window not attached to the workspace
+ * has no workspace files to list.
  */
-export function editorUnverifiedLines(ed, alias, browserIdeUrl) {
-    const lines = [
-        `  Your ${ed.label} window may or may not be attached to your workspace, and there is`,
-        "  nothing you can check by eye: an attached window and an unattached one look exactly",
-        `  the same. An unattached one runs on your own machine and is ${chalk.yellow("not recorded")}.`,
-        "",
+export function editorUnverifiedLines(ed, alias, pageUrl) {
+    return [
+        `  If the ${ed.label} window shows your workspace files in its file explorer, you're all set.`,
+        "  If it doesn't, close that window.",
+        workNowLine(alias, pageUrl),
     ];
-    if (browserIdeUrl) {
-        lines.push("  You can work in the browser IDE instead — same workspace, same files, fully");
-        lines.push("  recorded, and nothing to install:");
-        lines.push(`    ${chalk.cyan(browserIdeUrl)}`);
-    }
-    else {
-        lines.push("  You can work in the browser IDE instead, from your assessment page — same");
-        lines.push("  workspace, same files, fully recorded.");
-    }
-    lines.push("");
-    lines.push("  You can also work from a terminal, which does not need the editor at all:");
-    lines.push(`    ${chalk.cyan(`ssh ${alias}`)}`);
-    return lines;
 }
 /**
  * Ensure the Remote-SSH extension is installed in the user's editor before we
@@ -976,10 +779,8 @@ export function launchEditor(ed, command, alias, logPath) {
     return { launchFailure: () => failure };
 }
 /**
- * Point at the editor's own output. `namePath` is for the branch where a human is
- * walking a candidate through a failure: there the file is named whether or not
- * `--verbose` was asked for, since `editorLaunchLogPath` gives it a per-run suffix that
- * nobody can guess unaided.
+ * Point at the editor's own output, under `--verbose` only (ENG-2890: the failure copy
+ * says "Details: add --verbose." instead of printing a path by default).
  *
  * A PATH IS NAMED ONLY WHEN THERE IS SOMETHING AT IT, and the reason is that the file
  * routinely does not exist. `launchEditor` falls back to `stdio: "ignore"` whenever
@@ -989,15 +790,14 @@ export function launchEditor(ed, command, alias, logPath) {
  * Handing a support person a path with nothing behind it reads as the CLI having lost
  * the log, which is a worse answer than saying plainly that the editor wrote nothing.
  */
-export function editorLaunchOutputLines(logPath, launchLog, verbose, namePath) {
-    if (!namePath && !verbose)
+export function editorLaunchOutputLines(logPath, launchLog, verbose) {
+    if (!verbose)
         return [];
     if (!launchLog)
         return [chalk.dim("  The editor wrote no output while opening.")];
     const lines = [chalk.dim(`  Editor output: ${logPath}`)];
-    if (verbose)
-        for (const line of launchLog.split(/\r?\n/))
-            lines.push(chalk.dim(`    ${line}`));
+    for (const line of launchLog.split(/\r?\n/))
+        lines.push(chalk.dim(`    ${line}`));
     return lines;
 }
 /** What the editor wrote while trying to open, or null when it said nothing. */
@@ -1023,8 +823,8 @@ function sshProbeRunner(alias) {
         }
     };
 }
-function probeWorkspace(ed, run) {
-    return parseWorkspaceProbe(run(remoteProbeCommand(ed.serverHomeDir, ed.seedCommitPath)));
+function probeWorkspace(ed, run, clientCommit = null) {
+    return parseWorkspaceProbe(run(remoteProbeCommand(ed.serverHomeDir, ed.seedCommitPath, clientCommit)));
 }
 /**
  * ENG-2332 — poll the workspace until a server appears, or the budget runs out.
@@ -1052,7 +852,7 @@ function probeWorkspace(ed, run) {
  * than taken whole.
  */
 const SPAWN_ERROR_POLL_MS = 200;
-export async function verifyEditorAttached(ed, baseline, run, onWait, launched) {
+export async function verifyEditorAttached(ed, baseline, run, onWait, launched, clientCommit = null) {
     const started = Date.now();
     const budget = VERIFY_SCHEDULE_MS[VERIFY_SCHEDULE_MS.length - 1];
     let sawNotConnected = false;
@@ -1074,7 +874,7 @@ export async function verifyEditorAttached(ed, baseline, run, onWait, launched)
         if (launched.launchFailure() !== null)
             return { kind: "unverified" };
         onWait(Math.round((Date.now() - started) / 1000));
-        const current = probeWorkspace(ed, run);
+        const current = probeWorkspace(ed, run, clientCommit);
         const verdict = verifyVerdict(baseline, current);
         if (verdict.kind === "connected")
             return verdict;
@@ -1112,20 +912,15 @@ export async function attemptEditorLaunch(ed, io) {
  * (piped / CI), so scripted runs never block on the prompt.
  *
  * `log` is injectable ONLY so that the Cursor notice below is testable through the real
- * selection path rather than by reading a string constant. A warning that is never
- * reached is precisely the bug this ticket is fixing, so a test that cannot see whether
- * it was printed is not a test of it.
- *
- * `reentry` is the way back in, and it is threaded from `runConnect` rather than
- * rebuilt here because only the caller holds the token and the resolved base. When it
- * is absent (a test, a scripted call) the notice degrades to the placeholder form
- * rather than dropping the route — see `cursorReentryLines`.
+ * selection path rather than by reading a string constant, and `platform` so that both
+ * of its forms are (see `cursorSelectionNoticeLines`).
  */
-export async function resolveIde(flag, log = console.log, reentry) {
+export async function resolveIde(flag, log = console.log, platform = process.platform) {
     const norm = (flag ?? "").trim().toLowerCase();
     if (norm === "vscode" || norm === "cursor" || norm === "browser" || norm === "ssh") {
         if (norm === "cursor")
-            announceCursorFullQuit(log, reentry);
+            for (const line of cursorSelectionNoticeLines(platform))
+                log(line);
         return { ide: norm, chosen: true };
     }
     if (norm)
@@ -1134,10 +929,10 @@ export async function resolveIde(flag, log = console.log, reentry) {
         return { ide: "vscode", chosen: false };
     const answered = await promptIdeAnswer();
     const ide = ideForChoice(answered);
-    // At SELECTION time — not after the ~1-2 minute boot wait, and not trailing the
-    // "opening Cursor" line where it scrolls past. See `announceCursorFullQuit`.
+    // At SELECTION time — not after the ~1-2 minute boot wait, where it scrolls past.
     if (ide === "cursor")
-        announceCursorFullQuit(log, reentry);
+        for (const line of cursorSelectionNoticeLines(platform))
+            log(line);
     return { ide, chosen: answered.trim() !== "" };
 }
 // How long `litmus connect` waits for a started workspace to become reachable.
@@ -1185,99 +980,105 @@ export function keepWaitingForWorkspace(elapsedMs, status) {
 export function candidatePageUrl(apiBase, assessmentId) {
     return `${apiBase}/candidate/${assessmentId}`;
 }
-/** The placeholder form, for a call that does not know the token (tests, scripted runs). */
-const CURSOR_REENTRY_FALLBACK = { command: "litmus connect <token>", pageUrl: null };
 /**
- * ENG-2145 — how to get back in, said in the same breath as "quit".
- *
- * Elena, 2026-09-04, after two people who know the product could not work it out:
- * "it prompts you to quit cursor and come back in but it's not quite intuitive how
- * we're going to get back in."
- *
- * The notice used to offer exactly one route — "let this command reopen it" — and that
- * is the one route the instruction above it destroys. A candidate told to quit Cursor is
- * very likely reading the instruction IN CURSOR'S OWN INTEGRATED TERMINAL, because that
- * is where they have a shell; `Cmd+Q` then takes `litmus connect` with it. What is left
- * on screen is a quit editor, no running command, and nothing anywhere naming the way
- * back. On the clock, that reads as the workspace being gone.
- *
- * So the route is stated as an instruction rather than as a promise about a process that
- * may no longer exist, and the terminal it must be run from is named: a candidate who
- * has just been told to quit an application cannot be told to use that application's
- * terminal. The assessment page comes second and is the one that survives closing the
- * tab AND losing the terminal, which is the state Elena was actually in.
- *
- * Both routes reopen the SAME workspace — `litmus connect` re-registers this machine's
- * key and wakes a parked container through the ENG-2005 machinery, and the portal's own
- * card does the same — so the reassurance is a fact about the platform, not a hope.
+ * ENG-1950 — the one thing a Cursor candidate has to be told when they pick Cursor.
+ *
+ * Cursor reads its prompt-recording setup once, at application startup (ENG-1728,
+ * measured), so a Cursor that is already open when the workspace opens records no AI
+ * prompts while everything else works. ENG-2890: on macOS connect quits and reopens
+ * Cursor itself (`lib/cursor-restart.ts`), so nothing is said here and the restart step
+ * speaks when it acts. Elsewhere a graceful quit cannot be confirmed, so the candidate is
+ * asked to do it, in two lines: the 23-line notice this replaced was the wall the
+ * ENG-2890 candidate read past. The second line exists because quitting Cursor also
+ * closes its integrated terminal, and with it this command (ENG-2145).
  */
-export function cursorReentryLines(reentry = CURSOR_REENTRY_FALLBACK) {
-    const lines = [
-        "     To come back in after quitting, open a terminal that is NOT inside Cursor",
-        "     (Terminal or iTerm on macOS; PowerShell or Windows Terminal on Windows) and run:",
-        "",
-        `       ${chalk.cyan(reentry.command)}`,
-        "",
-        "     That reopens this same workspace, with your work exactly as you left it.",
+export function cursorSelectionNoticeLines(platform = process.platform) {
+    if (platformSupportsGracefulCursorRestart(platform))
+        return [];
+    return [
+        "  Before Cursor opens, quit it completely (File → Exit), or your AI prompts won't be recorded.",
+        "  If this terminal is inside Cursor, run the same litmus connect command from another terminal.",
     ];
-    // Deliberately NOT "use the button there". The portal's one-click reopen is the
-    // browser-IDE link, and `browser_ide_url` is null wherever `WORKSPACE_IDE_DOMAIN`
-    // is unset — those candidates get the same command in a copy field instead. Naming
-    // a control a candidate then cannot find costs them the trust they need in the rest
-    // of this notice, which is the same line `workspace-guidance.ts` draws over the tool
-    // list. What is true on every deployment is that the page states the route.
-    if (reentry.pageUrl) {
-        lines.push("     Or open your assessment page, which shows the way back in:");
-        lines.push(`       ${chalk.cyan(reentry.pageUrl)}`);
-    }
-    else {
-        lines.push("     Your assessment page shows the way back in too.");
-    }
-    return lines;
 }
 /**
- * ENG-1950 — the one thing a Cursor candidate has to be told, and the only place we can
- * reliably tell them.
- *
- * Cursor's hooks service reads its configuration ONCE, at application startup. Not on a
- * window reload, not on a fresh Remote-SSH connection. Our prompt capture for Cursor is
- * such a hook (staged into the container by `litmus-firstboot` §5b, ENG-1728), so a
- * candidate who connects from an already-running Cursor gets a session where the hook is
- * present, correct, and never loaded.
- *
- * That failure is entirely silent. The editor connects, the workspace works, files save,
- * the AI answers — and nothing is recorded, so their Process dimension is graded on an
- * empty record. It cost about an hour of investigation on 2026-08-28 to diagnose from
- * the inside, with the container in hand; a candidate has no chance of noticing at all.
- *
- * So the copy is written for a candidate, not for us: what to do, and what it costs if
- * they don't. No "hooks", no "capture lane". The mechanism is our problem.
- *
- * ENG-2145 adds the second half of that sentence: what to do is now "quit, THEN run
- * this", because an instruction to quit with no stated way back is what sent two people
- * who know the product looking for their workspace. The order is deliberate — the cost
- * of skipping the quit still comes last, so the thing a candidate acts on immediately is
- * the thing they read first, and `cursorReentryLines` sits between them rather than
- * after the whole notice where it would scroll.
+ * ENG-2890 — is this process running in Cursor's integrated terminal?
+ *
+ * Quitting Cursor kills its terminals, so the macOS auto-restart would kill this CLI
+ * between the quit and the relaunch, leaving no editor and no command. `TERM_PROGRAM`
+ * is "vscode" in VS Code AND in Cursor's terminal, so one of Cursor's own markers is
+ * required as well: its trace id, its ToDesktop bundle id, or its bundled askpass node.
+ * VS Code's terminal (bundle id `com.microsoft.VSCode`, no trace id) is not a match.
  */
-export function announceCursorFullQuit(log = console.log, reentry = CURSOR_REENTRY_FALLBACK) {
-    log("");
-    log(chalk.yellow.bold("  ⚠  Quit Cursor completely first — otherwise your work is not recorded."));
-    log("");
-    log("     If Cursor is open right now, quit the whole app:");
-    log(`       macOS:          ${chalk.bold("Cmd+Q")}`);
-    log(`       Windows/Linux:  ${chalk.bold("File → Exit")}, or close every Cursor window`);
-    log("");
-    for (const line of cursorReentryLines(reentry))
-        log(line);
-    log("");
-    log("     (If you are running this from a terminal outside Cursor, it is still running");
-    log("     and will open Cursor for you once your workspace is ready.)");
-    log("");
-    log("     Reloading the window or reconnecting is NOT enough — Cursor only picks up your");
-    log("     workspace's recording setup when the app itself starts. If it stays open,");
-    log("     everything will look normal and none of your work will be recorded.");
-    log("");
+export function runningInsideCursorTerminal(env = process.env) {
+    if (env.TERM_PROGRAM !== "vscode")
+        return false;
+    return (Boolean(env.CURSOR_TRACE_ID) ||
+        (env.__CFBundleIdentifier ?? "").includes("todesktop") ||
+        (env.VSCODE_GIT_ASKPASS_NODE ?? "").includes("Cursor"));
+}
+/** ENG-2890 — said instead of quitting Cursor out from under this terminal. */
+export function insideCursorTerminalLines() {
+    return [
+        chalk.yellow.bold("⚠ This terminal is inside Cursor, and restarting Cursor would close it."),
+        "  Run the same litmus connect command from Terminal or iTerm instead.",
+    ];
+}
+/** ENG-2890 — the one line connect prints before its macOS auto-restart of Cursor. */
+/** Cursor success when this command could not confirm a fresh start (gotcha 090). */
+export const CURSOR_RECORDING_CAVEAT_LINE = "  Your AI prompts are recorded only if Cursor was fully quit before it opened. If it wasn't, quit it and run the same litmus connect command again.";
+/** How long a freshly started Cursor gets to finish restoring its session (ENG-2884). */
+export const CURSOR_SETTLE_MS = 6000;
+/** When, into the attach wait, the open request is sent to Cursor a second time. */
+export const CURSOR_RESEND_AFTER_S = 20;
+/** Whether to send the workspace-open request again (once, Cursor only, after a fresh start). */
+export function shouldResendCursorOpen(ide, startedFresh, waitedSeconds, resend) {
+    return ide === "cursor" && startedFresh && !resend.done && waitedSeconds >= CURSOR_RESEND_AFTER_S;
+}
+/**
+ * ENG-2884 — the launch when the open request may be sent a second time. Every `send`
+ * answers ONE handle for all the requests so far. It reports a failure only once EVERY
+ * request has failed: a failed retry must not end the wait while the first request may
+ * still be attaching (Greptile on #3078). A retry's failure is kept in `readLog` instead,
+ * beside every request's output, so `--verbose` still shows why it failed.
+ */
+export function resendableLaunch(launch) {
+    const sent = [];
+    const handle = {
+        launchFailure: () => {
+            const failures = sent.map((s) => s.handle.launchFailure());
+            return failures.length > 0 && failures.every((f) => f !== null) ? failures[failures.length - 1] : null;
+        },
+    };
+    return {
+        send: (logPath) => {
+            sent.push({ logPath, handle: launch(logPath) });
+            return handle;
+        },
+        readLog: (read) => {
+            const logs = [];
+            sent.forEach((s, i) => {
+                const log = read(s.logPath);
+                if (log !== null)
+                    logs.push(log);
+                const failure = i > 0 ? s.handle.launchFailure() : null;
+                if (failure !== null)
+                    logs.push(`Second open request failed: ${failure}`);
+            });
+            return logs.length > 0 ? logs.join("\n") : null;
+        },
+    };
+}
+export const CURSOR_RESTARTING_LINE = "Restarting Cursor so your AI prompts are recorded (it reopens on its own)...";
+/**
+ * ENG-2890 — the quit was asked for and Cursor is still running, so nothing is
+ * launched (see the gate in `connectFlow`). `renderCursorRestartOutcome`'s longer form
+ * stays with init and doctor.
+ */
+export function cursorQuitUnconfirmedLines() {
+    return [
+        chalk.red.bold("✖ Cursor didn't quit. It may be waiting on a \"Save changes?\" dialog."),
+        "  Quit Cursor yourself, then run the same litmus connect command again from Terminal or iTerm.",
+    ];
 }
 /**
  * Map a menu answer to an editor. (ENG-1667 item 3; Cursor added by ENG-1950.)
@@ -1316,7 +1117,7 @@ export function ideMenuLines() {
         `  ${chalk.bold("2")}) VS Code — native, via Remote-SSH`,
         // ENG-2389. Cursor sits beside VS Code, where it belongs by kinship, and plain SSH is
         // last — see `ideForChoice` for what that renumbering costs and why it is bounded.
-        `  ${chalk.bold("3")}) Cursor — native, via Remote-SSH ${chalk.dim("(quit Cursor first)")}`,
+        `  ${chalk.bold("3")}) Cursor — native, via Remote-SSH`,
         `  ${chalk.bold("4")}) SSH — just print the command for your terminal`,
     ];
 }
@@ -1403,24 +1204,33 @@ function promptIdeAnswer() {
         });
     });
 }
-/** Open a URL in the user's default browser. Best-effort, cross-platform. */
+/**
+ * Open a URL in the user's default browser. Best-effort, cross-platform. Resolves
+ * whether the opener started, so the caller prints its fallback in order rather than
+ * after the success line, and never prints the URL itself: the browser-IDE URL carries
+ * the `t=` credential (ENG-2890).
+ */
 function openBrowser(url) {
     const spec = process.platform === "darwin" ? ["open", [url]]
         : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]]
             : ["xdg-open", [url]];
-    const fallback = () => console.log(`Open this in your browser:\n    ${url}`);
-    try {
-        const child = spawn(spec[0], spec[1], { detached: true, stdio: "ignore" });
-        // spawn reports a missing opener ASYNCHRONOUSLY via an 'error' event, not a
-        // sync throw — without this listener an ENOENT (e.g. no xdg-open on a minimal
-        // Linux / WSL / headless box) becomes an uncaughtException that crashes the
-        // CLI right after the success line. The try/catch alone can't see it.
-        child.on("error", fallback);
-        child.unref();
-    }
-    catch {
-        fallback();
-    }
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(spec[0], spec[1], { detached: true, stdio: "ignore" });
+            // spawn reports a missing opener ASYNCHRONOUSLY via an 'error' event, not a
+            // sync throw — without this listener an ENOENT (e.g. no xdg-open on a minimal
+            // Linux / WSL / headless box) becomes an uncaughtException that crashes the CLI.
+            child.on("error", () => resolve(false));
+            child.on("spawn", () => resolve(true));
+            child.unref();
+            // Never let the browser opener hold connect up: if neither event arrives, the
+            // launch is assumed to have gone ahead, which is how connect behaved before ENG-2890.
+            setTimeout(() => resolve(true), 3000).unref();
+        }
+        catch {
+            resolve(false);
+        }
+    });
 }
 /**
  * Drop any stale known_hosts entries for this workspace's target + bastion.
@@ -1501,14 +1311,10 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     // Pick the editor up front (flag or interactive prompt) so the choice is made
     // before the boot wait, not after.
     //
-    // ENG-2145 — the Cursor notice is told the way back in. Both routes are known here
-    // and nowhere inside `resolveIde`: the token is a credential the caller holds, and
-    // `apiBase` is the frontend base the disclosure branch below already points at.
-    const reentry = {
-        command: `litmus connect ${token}`,
-        pageUrl: candidatePageUrl(apiBase, meta.assessmentId),
-    };
-    const { ide: chosenIde, chosen: ideWasChosen } = await resolveIde(ideOpt, console.log, reentry);
+    // ENG-2890 — the assessment page is the one re-entry route connect prints: its URL
+    // carries only the assessment id, never the token.
+    const pageUrl = candidatePageUrl(apiBase, meta.assessmentId);
+    const { ide: chosenIde, chosen: ideWasChosen } = await resolveIde(ideOpt, console.log);
     let ide = chosenIde;
     // ENG-2814: asked here, next to the editor choice, and uploaded once the workspace is
     // ready. Never fails the connect. See `lib/connect-skills.ts`.
@@ -1578,7 +1384,7 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     }
     boot.succeed("Workspace ready");
     if (pendingSkills)
-        skillImport.report = startSkillImport(backendUrl, token, pendingSkills);
+        skillImport.report = startSkillImport(backendUrl, token, pendingSkills, undefined, () => ide);
     // Browser IDE: no local SSH / VS Code needed — just open the signed URL.
     if (ide === "browser") {
         // Greptile on #1713. The browser IDE is now the DEFAULT, so this branch is reached by
@@ -1596,14 +1402,20 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
             ide = "vscode";
         }
         else if (fallback === "unavailable") {
-            fatal("The browser IDE isn't available for this workspace yet.", "Open it in native VS Code instead: `litmus connect <token> --ide vscode`.", { severity: "warning" });
+            fatal("The browser IDE isn't available for this workspace yet.", "Open it in native VS Code instead: run the same `litmus connect` command with `--ide vscode`.", { severity: "warning" });
             return;
         }
     }
     if (ide === "browser" && conn.browser_ide_url) {
-        openBrowser(conn.browser_ide_url);
-        success("Opening your workspace in the browser");
-        console.log(chalk.dim(`  ${conn.browser_ide_url}`));
+        // ENG-2890 — the URL carries the `t=` credential, so it is opened, never printed,
+        // except under --verbose for whoever is debugging the opener.
+        // `openBrowser` resolving true means the opener started, not that a browser showed the
+        // page (xdg-open can exit with no browser at all), so the fallback is always given.
+        await openBrowser(conn.browser_ide_url);
+        success("✔ Opening your workspace in the browser");
+        console.log(`  If nothing opens, use the browser IDE link on your assessment page: ${chalk.cyan(pageUrl)}`);
+        if (verbose)
+            console.log(chalk.dim(`  ${conn.browser_ide_url}`));
         return;
     }
     if (!conn.ssh_command) {
@@ -1634,7 +1446,8 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     pruneStaleHostKeys(parsed);
     const block = buildSshConfigBlock(alias, KEY_PATH, parsed);
     const cfgPath = writeSshConfig(alias, block, buildControlPathBlock(alias, parsed));
-    info(`SSH config written to ${cfgPath} (Host "${alias}")`);
+    if (verbose)
+        info(`SSH config written to ${cfgPath} (Host "${alias}")`);
     // ENG-2693 — prove the connection before handing it off (see `sshPreflight`). The
     // client is the one the route will run, as in ENG-2682. A failure stops the route with
     // ssh's own words, rather than in an editor that fails the same way silently — and it
@@ -1745,8 +1558,8 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     //     no-op that touches nothing.
     //
     //     Cursor is still given no laptop-side equivalent of the WRITE: its AI is captured
-    //     in-container, which is exactly what the full-quit notice at selection time
-    //     protects.
+    //     in-container, which is what the Cursor restart (or, off macOS, the quit note at
+    //     selection time) protects.
     //
     //     ENG-2152 — a MISMATCH refuses below and opens nothing, so it may not WRITE. See
     //     `chatConfigActionForIdentity`, which is where that belongs: keying the write on
@@ -1791,7 +1604,7 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     // manual-instructions branch. Checking the mismatch first means a Windows candidate
     // whose `code` is Cursor is told so, rather than told their editor is not installed.
     if (identity.kind === "mismatch") {
-        for (const line of editorMismatchLines(editor, NATIVE_EDITORS[identity.actual], reentry)) {
+        for (const line of editorMismatchLines(editor, NATIVE_EDITORS[identity.actual], alias, pageUrl)) {
             console.log(line);
         }
         return;
@@ -1800,22 +1613,13 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
         // ENG-2332 — the CLI is not on PATH and not where the installer puts it. Everything
         // offered here is reachable WITHOUT it; the line this replaced offered
         // `<bin> --remote …`, i.e. the binary whose absence is the message.
-        for (const line of editorNotFoundLines(editor, alias, conn.browser_ide_url ?? null))
+        for (const line of editorNotFoundLines(editor, alias, pageUrl))
             console.log(line);
-        // The full-quit requirement outlives this degraded path — arguably it matters MORE
-        // here, since a candidate connecting by hand is doing it from an editor they still
-        // have to quit.
-        //
-        // ENG-2145: and so does the way back. This used to point at "the note above", which
-        // is a back-reference to a notice printed BEFORE a boot wait that can run to two
-        // minutes and fills the screen — and, worse, one whose own route back was a promise
-        // about this very command, which by then has returned. So the route is restated
-        // here in full rather than referred to.
-        if (ide === "cursor") {
-            console.log(chalk.yellow("  Quit Cursor completely before you connect, or your work is not recorded."));
-            for (const line of cursorReentryLines(reentry))
+        // A candidate connecting by hand does it from a Cursor they still have to quit, and
+        // nothing here restarts it, so the selection note is restated (empty on macOS).
+        if (ide === "cursor")
+            for (const line of cursorSelectionNoticeLines())
                 console.log(line);
-        }
         return;
     }
     if (identity.kind === "unverified") {
@@ -1828,9 +1632,10 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
         // printing this first produced "opening it as you asked" immediately followed by
         // "not found on PATH" — two lines contradicting each other about whether anything was
         // about to open, which is on the ticket in its own right.
-        console.log(chalk.dim(`  (Couldn't confirm that \`${editor.bin}\` is ${editor.label}; opening it as you asked.)`));
+        if (verbose)
+            console.log(chalk.dim(`  (Couldn't confirm that \`${editor.bin}\` is ${editor.label}; opening it as you asked.)`));
     }
-    if (resolved.source === "install-location") {
+    if (verbose && resolved.source === "install-location") {
         info(`Using ${editor.label} at ${resolved.command}`);
         console.log(chalk.dim(`  (\`${editor.bin}\` isn't on your PATH. ${editor.label}'s "${editor.shellCommand}" adds it.)`));
     }
@@ -1841,9 +1646,9 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     const probe = sshProbeRunner(alias);
     // ENG-2491, Greptile P1 on #2613 — the baseline probe is taken HERE, before
     // any decision to quit Cursor, and the resulting `seedVerdict` is checked
-    // before quitting too. `attemptEditorLaunch` below can still REFUSE the
-    // launch on a Cursor build that doesn't match this workspace's seed
-    // (`requiresSeedMatch`), and a refusal opens nothing — so a quit sequenced
+    // before quitting too. `attemptEditorLaunch` below REFUSES the launch on a
+    // mismatched build for any editor with `requiresSeedMatch` set (none today,
+    // ENG-2884), and a refusal opens nothing — so a quit sequenced
     // ahead of that check could close every Cursor window on a path that was
     // always going to end in "nothing was opened", with no way given back in
     // locally. Checking the identical rule first means a quit only ever
@@ -1854,20 +1659,22 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     // two, for the same reason this file already takes it once for the seed
     // check and the verification baseline together.
     const readSpinner = ora(`Checking your workspace...`).start();
-    const baseline = probeWorkspace(editor, probe);
+    const baseline = probeWorkspace(editor, probe, resolved.version.commit);
     readSpinner.stop();
     const seed = seedVerdict(resolved.version, baseline);
     const seedWillRefuseLaunch = seed.kind === "mismatch" && editor.requiresSeedMatch;
     // ENG-2491 — Cursor reads its hooks configuration once, at its OWN launch,
     // no matter which remote window it then opens (ENG-1728, measured) — so an
     // ALREADY-RUNNING local Cursor never reloads even for a brand new
-    // Remote-SSH connection. `announceCursorFullQuit` (already said, at
-    // selection time, above) has told the candidate this for months; this acts
-    // on it instead of only saying it, with the same graceful, never-a-kill
+    // Remote-SSH connection. This quits it with the same graceful, never-a-kill
     // quit `init` uses (see lib/cursor-restart.ts). The launch a few lines
     // below IS the relaunch — connect already opens the editor, so there is
     // nothing else to relaunch it into.
     //
+    // ENG-2890 — NOT from Cursor's own terminal: the quit would kill this
+    // process before the relaunch, leaving no editor and no command. That case
+    // stops before anything is touched, the same way an unconfirmed quit does.
+    //
     // NEVER proceeds to launch on an unconfirmed quit. Doing so would hand the
     // new `--remote` argv to the SAME still-running process — Cursor's
     // single-instance lock just forwards it as a new window into a hooks
@@ -1875,23 +1682,40 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     // failure, not a fix for it. So an unconfirmed quit stops here, the same
     // way every other refusal in this file does: nothing opened, workspace
     // still up and waiting, and the exact way back in.
+    // Whether the Cursor about to open is a FRESH start, so its prompt recording loads:
+    // it was not running, or this command confirmed it quit. Only then may success say the
+    // work is recorded (Greptile on #3071); elsewhere (Linux, Windows, an unreadable process
+    // list) the candidate was only asked to quit it, and nothing checked that they did.
+    let cursorStartsFresh = false;
     if (!seedWillRefuseLaunch && ide === "cursor" && platformSupportsGracefulCursorRestart(process.platform)) {
         const cursorIo = realCursorProcessIo();
-        if (cursorIo.isRunning() === "running") {
-            for (const line of announceCursorAutoRestart())
-                console.log(line);
+        const presence = cursorIo.isRunning();
+        if (presence === "not-running")
+            cursorStartsFresh = true;
+        if (presence === "running") {
+            if (runningInsideCursorTerminal()) {
+                for (const line of insideCursorTerminalLines())
+                    console.log(line);
+                return;
+            }
+            info(CURSOR_RESTARTING_LINE);
             const quit = await attemptQuit(cursorIo);
             if (!quit) {
-                for (const line of renderCursorRestartOutcome({ kind: "quit-unconfirmed" }))
+                for (const line of cursorQuitUnconfirmedLines())
                     console.log(line);
-                console.log();
-                console.log(chalk.yellow.bold("  Quit Cursor completely yourself, then run this again:"));
-                for (const line of cursorReentryLines(reentry))
-                    console.log(line);
-                console.log();
                 return;
             }
-            info("Cursor quit — reopening it for your workspace...");
+            cursorStartsFresh = true;
+        }
+        // ENG-2884. A COLD start handed `--remote` loses it: measured twice on a real
+        // profile (2026-10-01 21:11 and 2026-10-02 00:26 PT), Cursor 3 came up restoring its
+        // previous session (the Agents window plus old folders) and never created the
+        // workspace window. Sent to a Cursor that has finished starting, the same request
+        // opens it (./cursorrelaunch variant C). So start Cursor first, let it settle, and
+        // only then launch; if it cannot be started this way, the launch below is the cold
+        // start it always was.
+        if (cursorStartsFresh && (await attemptRelaunch(cursorIo))) {
+            await cursorIo.sleep(CURSOR_SETTLE_MS);
         }
     }
     // A holder rather than a `let`, because the spinner is created inside a callback and
@@ -1901,6 +1725,8 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     // "Checking the Remote-SSH extension" through it names the wrong step, on the one path
     // where the next thing the candidate may see is a refusal that installed nothing.
     const spinners = { verify: null };
+    const resend = { done: false };
+    const launches = resendableLaunch((logPath) => launchEditor(editor, resolved.command, alias, logPath));
     const outcome = await attemptEditorLaunch(editor, {
         // Reused from the pre-check above — see the comment there for why this
         // is a cache, not a second probe.
@@ -1909,17 +1735,21 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
         ensureExtension: () => {
             const extSpinner = ora(`Checking ${editor.label} Remote-SSH extension...`).start();
             const state = ensureRemoteSshExtension(editor, resolved.command);
-            if (state === "present")
+            // ENG-2890: an internal step, so it says nothing when it worked.
+            if (state === "failed") {
+                extSpinner.warn(`Couldn't install the Remote-SSH extension (${editor.remoteSshExt}). Install it from ${editor.label}'s Extensions view if ${editor.label} asks.`);
+            }
+            else if (!verbose)
+                extSpinner.stop();
+            else if (state === "present")
                 extSpinner.succeed("Remote-SSH extension ready");
-            else if (state === "installed")
-                extSpinner.succeed(`Installed the ${editor.label} Remote-SSH extension`);
             else
-                extSpinner.warn("Couldn't auto-install the Remote-SSH extension");
+                extSpinner.succeed(`Installed the ${editor.label} Remote-SSH extension`);
             return state;
         },
         launchLogPath: editorLaunchLogPath,
         launch: (logPath) => {
-            const launched = launchEditor(editor, resolved.command, alias, logPath);
+            const launched = launches.send(logPath);
             // The launch is not the result, so nothing claims one here. What used to be printed
             // at this point was `✔ Opening <editor> → <alias>`, which is true of a spawn that is
             // about to fail, and was the last thing the CLI said in a session where nothing was
@@ -1927,15 +1757,22 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
             spinners.verify = ora(`Opening ${editor.label} — waiting for it to start in your workspace...`).start();
             return launched;
         },
-        readLaunchLog: readEditorLaunchLog,
+        readLaunchLog: () => launches.readLog(readEditorLaunchLog),
         verifyAttached: (baseline, launched) => verifyEditorAttached(editor, baseline, probe, (waited) => {
             if (spinners.verify) {
                 spinners.verify.text = `Opening ${editor.label} — waiting for it to start in your workspace... (${waited}s)`;
             }
-        }, launched),
+            // ENG-2884: if the first request still produced no attached window, ask the
+            // (now running) Cursor once more. A window already opening for this folder is
+            // focused rather than duplicated, so a slow first attach costs nothing.
+            if (shouldResendCursorOpen(editor.ide, cursorStartsFresh, waited, resend)) {
+                resend.done = true;
+                launches.send(editorLaunchLogPath());
+            }
+        }, launched, resolved.version.commit),
     });
     if (outcome.kind === "refused") {
-        for (const line of editorSeedMismatchLines(editor, outcome.seed, conn.browser_ide_url ?? null, alias, reentry)) {
+        for (const line of editorSeedMismatchLines(editor, outcome.seed, pageUrl, alias)) {
             console.log(line);
         }
         return;
@@ -1945,49 +1782,45 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
         // No window was created, so none of the not-connected copy is true here. See
         // `editorLaunchFailedLines`.
         launchSpinner?.fail(`Couldn't start ${editor.label}.`);
-        for (const line of editorLaunchFailedLines(editor, alias, conn.browser_ide_url ?? null, outcome.error, verbose ? null : outcome.launchLog)) {
+        for (const line of editorLaunchFailedLines(editor, alias, pageUrl, outcome.error, verbose))
             console.log(line);
-        }
-        for (const line of editorLaunchOutputLines(outcome.logPath, outcome.launchLog, verbose, true))
+        for (const line of editorLaunchOutputLines(outcome.logPath, outcome.launchLog, verbose))
             console.log(line);
         return;
     }
     if (outcome.verdict.kind === "connected") {
-        launchSpinner?.succeed(`${editor.label} is running in your workspace — your files, terminal and commits are recorded.`);
-        skillImport.footer.push(...editorConnectedLines(editor, alias));
+        const recordingKnown = editor.ide !== "cursor" || cursorStartsFresh;
+        launchSpinner?.succeed(recordingKnown
+            ? `${editor.label} is open in your workspace. Your work is recorded.`
+            : `${editor.label} is open in your workspace.`);
+        if (!recordingKnown)
+            skillImport.footer.push(CURSOR_RECORDING_CAVEAT_LINE);
+        skillImport.footer.push(...editorConnectedLines(editor, alias, verbose));
     }
     else if (outcome.verdict.kind === "unverified") {
         // Three-valued on purpose: we could not reach the workspace to ask, which is not the
         // same as knowing nothing came up, and saying either of the other two here would be a
         // claim we cannot make. See `verifyVerdict`.
-        launchSpinner?.warn(`Couldn't check whether ${editor.label} attached to your workspace.`);
-        for (const line of editorUnverifiedLines(editor, alias, conn.browser_ide_url ?? null))
+        launchSpinner?.warn(`Couldn't confirm ${editor.label} connected to your workspace.`);
+        for (const line of editorUnverifiedLines(editor, alias, pageUrl))
             console.log(line);
     }
     else {
-        launchSpinner?.fail(`${editor.label} did not start in your workspace.`);
-        // Under --verbose the whole log is printed below, so the copy's own 8-line tail is
-        // withheld rather than repeated; without it that tail is the only view of the output.
-        for (const line of editorNotConnectedLines(editor, alias, conn.browser_ide_url ?? null, outcome.seed, verbose ? null : outcome.launchLog)) {
+        launchSpinner?.fail(`${editor.label} hasn't connected to your workspace yet.`);
+        for (const line of editorNotConnectedLines(editor, alias, pageUrl, verbose))
             console.log(line);
-        }
-        if (outcome.extension === "failed") {
+        // Under --verbose: the log path and the editor's whole output. The extension failure
+        // was already warned about when it happened.
+        if (verbose && outcome.extension === "failed") {
             console.log(chalk.dim(`  The Remote-SSH extension ("${editor.remoteSshExt}") also failed to install, which would explain this.`));
         }
-        // The one outcome somebody is walked through, and the log now carries a per-run
-        // suffix — so its PATH is named here whether or not --verbose was asked for.
-        for (const line of editorLaunchOutputLines(outcome.logPath, outcome.launchLog, verbose, true))
+        for (const line of editorLaunchOutputLines(outcome.logPath, outcome.launchLog, verbose))
             console.log(line);
         return;
     }
-    // The log's PATH is named on every branch a human gets walked through, and `unverified`
-    // is one: it is precisely the branch where we could not reach the workspace at all, so
-    // the editor's own resolver message is the only evidence anybody has — and the name
-    // carries a per-run suffix nobody can guess unaided. `editorLaunchOutputLines` still
-    // withholds a path with nothing behind it.
-    for (const line of editorLaunchOutputLines(outcome.logPath, outcome.launchLog, verbose, outcome.verdict.kind !== "connected")) {
+    // Under --verbose, the editor's own output on both remaining branches (ENG-2890).
+    for (const line of editorLaunchOutputLines(outcome.logPath, outcome.launchLog, verbose))
         console.log(line);
-    }
     // ENG-2154. The window we have just opened outlives the session, and what it
     // does when the session ends looks like a failure. This is the only moment
     // anything of ours is on the candidate's own machine — `connect` returns here
@@ -1995,6 +1828,6 @@ async function connectFlow(token, ideOpt, opts, skillImport) {
     // assessment page — so it is also the only warning that reaches a candidate
     // who ends their session somewhere we do not run. See lib/session-end.ts,
     // which also carries why we do not simply close the window.
-    skillImport.footer.push(...editorEndingForewarning(editor.label));
+    skillImport.footer.push(...editorEndingForewarning());
 }
 //# sourceMappingURL=connect.js.map