ticketlens 0.42.3 → 0.43.0

package/README.md

@@ -333,6 +333,7 @@ ticketlens pr <TICKET-KEY>                    # Generate PR description from tic
 ticketlens pr <TICKET-KEY> --profile=acme    # Specify a profile
 ticketlens pr <TICKET-KEY> --plain           # Plain markdown output
 ticketlens pr <TICKET-KEY> | pbcopy          # Copy to clipboard
+ticketlens pr <TICKET-KEY> --open            # Open a real GitHub PR compare page (Pro, GitHub only)
 ```
 
 Generates a PR description template pre-filled with the ticket summary, acceptance criteria, and compliance coverage. Free — the compliance coverage section follows the `compliance` command's own free (3/month) or Pro (unlimited) limit.
@@ -1121,11 +1122,12 @@ npm test
 See [ROADMAP.md](ROADMAP.md) for the full plan.
 
 Recently shipped:
+- **`ticketlens pr --open`** — opens a real GitHub PR compare page prefilled with the same description `pr` already prints, instead of just printing it. GitHub only, no stored write-credential. Pro tier
 - **`review`/`compliance` fixes** — branch diff now uses merge-base semantics, no longer picks up unrelated unmerged-main files; AC parser now recognizes Jira wiki `Requirements`/`How to test` headers, not just literal "Acceptance Criteria"
 - **`ticketlens update --priority`** — a bad priority name now tells you the project's real, current valid options instead of a bare tracker error
 - **`ticketlens assign --to="name or email"`** — assign a ticket to another developer, not just yourself. Jira (Cloud + Server/DC); searches real assignable users first, lists matches, executes only on one confirmed match. Pro tier
 - **Console: Recall "select all N matching" bulk delete** — Gmail-style banner deletes every note matching your search/filters across all pages, not just the current one
-- **Recall Stop-hook fix** — the end-of-session Recall reminder no longer fires because of file writes; only real ticket writes (comment, transition, assign, update) arm it. Also hardened against malformed transcripts and a session-id path-collision bug found by adversarial testing
+- **Recall Stop-hook fix** — the end-of-session Recall reminder no longer fires because of file writes; only real ticket writes (comment, transition, assign, update) arm it. Also hardened against malformed transcripts and a session-id path-collision bug found by adversarial testing. Pro+/Team accounts now get a silent pass instead of a hard block, since the autonomous background capture already covers them; free tier is unchanged
 - **Console: no repeat request on same-page menu clicks** — sidebar links, the header gear and Settings tabs skip the request when they point at the page you are on
 - **Worklog** (`ticketlens worklog`, `ticket_worklog` MCP) — log time on Jira tickets, preview first. Pro tier
 - **Autonomous Recall capture** — TicketLens judges and saves a note after a session, no `note add` call, reusing your login. Pro+ tier

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.42.3",
+  "version": "0.43.0",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/SKILL.md

@@ -1,4 +1,4 @@
-<!-- jtb-skill-version: 0.47.0 -->
+<!-- jtb-skill-version: 0.48.0 -->
 ---
 name: jtb
 description: Fetch a Jira ticket's full context (description, comments, linked issues, code references) and assemble a structured TicketBrief for implementation planning. Use when user types /jtb, mentions a Jira ticket key, or wants to plan work from a Jira ticket.
@@ -220,11 +220,13 @@ ticketlens pr PROJ-123 $EXTRA_ARGS
 
 Where `$EXTRA_ARGS` are any flags passed (e.g. `--profile=acme`). Requires a ticket key as the first positional argument.
 
-Assembles a ready-to-paste PR description: what changed (from commits linked to the ticket), linked tickets, and — if the ticket has acceptance criteria — a requirements-coverage section. Read-only. The requirements-coverage section reuses the same Free-tier 3-checks/month counter as `--compliance`/`ticketlens compliance` — running `pr` on a ticket with acceptance criteria counts against that shared monthly limit; Pro removes the cap.
+Assembles a ready-to-paste PR description: what changed (from commits linked to the ticket), linked tickets, and — if the ticket has acceptance criteria — a requirements-coverage section. Read-only by default. The requirements-coverage section reuses the same Free-tier 3-checks/month counter as `--compliance`/`ticketlens compliance` — running `pr` on a ticket with acceptance criteria counts against that shared monthly limit; Pro removes the cap.
+
+Add `--open` (TicketLens Pro required) to open a real GitHub PR compare page prefilled with this same description, instead of just printing it. GitHub only — refuses cleanly on a non-GitHub remote, a detached HEAD, a branch not yet pushed to origin, or when already on the base branch. Requires the current branch already pushed.
 
 Display the script's stdout directly. No plan mode. Stop here.
 
-If this harness has TicketLens's MCP server configured (a tool named `pr` — often shown as `mcp__ticketlens__pr` — visible in your tool list), prefer it over the bash form: same output, same shared compliance-counter caveat, no shell command to construct. It accepts `ticket`/`profile`.
+If this harness has TicketLens's MCP server configured (a tool named `pr` — often shown as `mcp__ticketlens__pr` — visible in your tool list), prefer it over the bash form: same output, same shared compliance-counter caveat, no shell command to construct. It accepts `ticket`/`profile`/`open`.
 
 ---
 

package/skills/jtb/hooks/recall-auto-capture.mjs

@@ -29,7 +29,7 @@ import { appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { isLicensed } from '../scripts/lib/license.mjs';
 import { readCliToken } from '../scripts/lib/cli-auth.mjs';
-import { buildCaptureExcerpt, privateTmpDir } from './recall-nudge-lib.mjs';
+import { buildCaptureExcerpt, privateTmpDir, writeLastCaptureAt } from './recall-nudge-lib.mjs';
 import { autoCapture } from '../scripts/lib/summarizer.mjs';
 import { runNoteAdd } from '../scripts/lib/note-command.mjs';
 import { DEFAULT_CONFIG_DIR } from '../scripts/lib/config.mjs';
@@ -56,17 +56,20 @@ function logLine(message) {
  * @param {string} opts.transcriptPath
  * @param {string} [opts.ticketKey]
  * @param {string} [opts.configDir]
+ * @param {string} [opts.cwd] - directory whose shared capture marker gets updated on a real capture (backlog #44: makes a successful background capture visible to a later sync Stop check, which otherwise has no way to know this ran)
  * @returns {Promise<{outcome: 'skipped'|'captured'|'not-written'|'error', reason?: string, title?: string, error?: string}>}
  */
 export async function runAutoCapture({
   transcriptPath,
   ticketKey,
   configDir = DEFAULT_CONFIG_DIR,
+  cwd = process.cwd(),
   isLicensedFn = isLicensed,
   readCliTokenFn = readCliToken,
   buildCaptureExcerptFn = buildCaptureExcerpt,
   autoCaptureFn = autoCapture,
   runNoteAddFn = runNoteAdd,
+  writeLastCaptureAtFn = writeLastCaptureAt,
 } = {}) {
   if (!isLicensedFn('pro', configDir)) {
     logLine('skipped: not licensed');
@@ -112,10 +115,16 @@ export async function runAutoCapture({
   });
 
   logLine(written ? `captured: ${result.title}` : `not-written: ${result.title}`);
+  if (written) writeLastCaptureAtFn(cwd, Date.now());
   return written ? { outcome: 'captured', title: result.title } : { outcome: 'not-written', title: result.title };
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const [, , transcriptPath, ticketKeyArg] = process.argv;
-  runAutoCapture({ transcriptPath, ticketKey: ticketKeyArg || undefined }).catch(() => { /* never escape — nothing is watching this process */ });
+  // cwdArg (backlog #44 code review): passed explicitly by the spawning Stop
+  // hook rather than relying on this child's own process.cwd() — Node
+  // resolves process.cwd() through symlinks, so a cwd with a symlinked
+  // component would otherwise hash to a different marker file than the one
+  // a later Stop's hasRecentCapture(cwd) reads, silently breaking the bridge.
+  const [, , transcriptPath, ticketKeyArg, cwdArg] = process.argv;
+  runAutoCapture({ transcriptPath, ticketKey: ticketKeyArg || undefined, cwd: cwdArg || undefined }).catch(() => { /* never escape — nothing is watching this process */ });
 }

package/skills/jtb/hooks/recall-nudge-stop.mjs

@@ -89,11 +89,31 @@ if (!sessionId || !transcriptPath) process.exit(0);
 
 const { sawFetch, sawMutatingAction, sawRecallFlag, sawNoteAdd, ticketKey } = scanTranscript(transcriptPath);
 const cliToken = readCliToken();
+// Backlog #44 (9th/10th reports): entitled accounts already run the async
+// auto-capture judge below — throttled to at most once per CAPTURE_FRESHNESS_MS
+// per cwd (hasRecentAutoCaptureAttempt below), not on every single Stop. Once
+// it succeeds, its outcome is now visible via writeLastCaptureAt
+// (recall-auto-capture.mjs) to a LATER Stop's hasRecentCapture() check — but
+// THIS Stop's own decision below still can't see an attempt spawned moments
+// ago (detached, still running), nor is a fresh one spawned if the window's
+// one attempt already ran and moved on. For that residual window, a hard
+// block duplicates a safety net that's already in flight or already spent:
+// exit 0 instead of 2 so this never blocks the turn for these accounts. Free
+// tier has no such net, so it keeps the hard block unchanged — this is its
+// only enforcement.
+const hasSafetyNet = isLicensed('pro') && Boolean(cliToken);
 
-if (isLicensed('pro') && cliToken && !hasRecentAutoCaptureAttempt(cwd)) {
+if (hasSafetyNet && !hasRecentAutoCaptureAttempt(cwd)) {
   try {
     writeLastAutoCaptureAttemptAt(cwd, Date.now());
-    const child = spawn(process.execPath, [AUTO_CAPTURE_SCRIPT, transcriptPath, ticketKey ?? ''], {
+    // cwd is passed explicitly as argv (not left to the child's own
+    // process.cwd()) — code review finding: Node resolves process.cwd()
+    // through symlinks, so a cwd with any symlink component (macOS os.tmpdir()
+    // itself, an iCloud-synced Desktop, a Docker bind mount) would make the
+    // child's own process.cwd() differ from the string used here, hashing to
+    // a different marker file and silently breaking the bridge this fix exists
+    // to build.
+    const child = spawn(process.execPath, [AUTO_CAPTURE_SCRIPT, transcriptPath, ticketKey ?? '', cwd], {
       cwd,
       detached: true,
       stdio: 'ignore',
@@ -156,4 +176,7 @@ if (sawRecallFlag) {
     '`ticketlens note add`. If genuinely nothing qualified, just say so — then finish.\n',
   );
 }
-process.exit(2);
+// hasSafetyNet: the message above is still written (a diagnostic trail if
+// the async job silently fails) but exit 0 means Claude Code never surfaces
+// it or blocks the turn — only exit 2 feeds stderr back (backlog #44).
+process.exit(hasSafetyNet ? 0 : 2);

package/skills/jtb/scripts/fetch-ticket.mjs

@@ -589,6 +589,19 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
     const adapterPr = resolveAdapter(connPr, { fetcher });
     const complianceRunnerPr = opts.runComplianceCheck ?? runComplianceCheck;
 
+    // Backlog #27: --open builds a real GitHub PR compare URL from the same
+    // markdown below and opens it — Pro-gated like every other write-back tool,
+    // unlike the plain preview above which stays Free.
+    const openFlagPr = args.includes('--open');
+    if (openFlagPr) {
+      const { isLicensed: isLicPr, showUpgradePrompt: showUpgradePr } = await import('./lib/license.mjs');
+      if (!isLicPr('pro', resolvedConfigDir)) {
+        showUpgradePr('pro', 'pr --open', { stream: errStream });
+        process.exitCode = 1;
+        return;
+      }
+    }
+
     try {
       const md = await assemblePr(ticketKeyArg, {
         configDir: resolvedConfigDir,
@@ -598,7 +611,24 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
         // upgrade prompt would leak to real stderr unless threaded here — same
         // treatment as the compliance dispatch block above (`stream: errStream`).
         runComplianceCheckFn: (o) => complianceRunnerPr({ ...o, stream: errStream }),
+        // --open needs raw markdown for the compare-URL body, regardless of the
+        // real terminal's TTY-ness — the plain preview path below is unaffected.
+        ...(openFlagPr ? { outStream: { write: () => {}, isTTY: false } } : {}),
       });
+
+      if (openFlagPr) {
+        const { openPr: openPrFn } = await import('./lib/pr-opener.mjs');
+        const openPrRunner = opts.openPr ?? openPrFn;
+        const result = await openPrRunner(ticketKeyArg, md, { cwd: process.cwd() });
+        if (!result.ok) {
+          printErrFn(`Error: ${result.message}\n`);
+          process.exitCode = 1;
+          return;
+        }
+        printFn(`Opening: ${result.url}\n`);
+        return;
+      }
+
       printFn(md + '\n');
     } catch (err) {
       printErrFn(`Error: ${err.message}\n`);

package/skills/jtb/scripts/lib/api-utils.mjs

@@ -3,7 +3,7 @@
  * Centralised here to avoid triplicating the regex and warning logic.
  */
 
-export const DEFAULT_API_BASE = 'http://api.ticketlens.test';
+export const DEFAULT_API_BASE = 'https://api.ticketlens.app';
 export const DEFAULT_SITE_BASE = 'https://ticketlens.app';
 
 // Matches localhost, 127.0.0.1, and any hostname ending in .test or .local,

package/skills/jtb/scripts/lib/browser-login.mjs

@@ -14,12 +14,22 @@ export const generateState = () => randomBytes(16).toString('hex');
 export const pickPort = () =>
   Math.floor(Math.random() * (PORT_MAX - PORT_MIN + 1)) + PORT_MIN;
 
-export function openBrowser(url) {
+/**
+ * @param {string} url
+ * @param {object} [opts]
+ * @param {Function} [opts.spawnFn] - injectable child_process.spawn (default: spawn)
+ */
+export function openBrowser(url, { spawnFn = spawn } = {}) {
   const cmd = process.platform === 'win32' ? 'cmd'
             : process.platform === 'darwin' ? 'open'
             : 'xdg-open';
   const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
-  spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+  const child = spawnFn(cmd, args, { detached: true, stdio: 'ignore' });
+  // A missing/blocked OS opener (headless container, restricted MCP runtime)
+  // emits this asynchronously; unhandled, it's an uncaught exception that
+  // kills the whole process — including a long-lived MCP server.
+  child.on('error', () => {});
+  child.unref();
 }
 
 /**

package/skills/jtb/scripts/lib/git-exec.mjs

@@ -0,0 +1,35 @@
+/**
+ * Shared spawnSync-over-git wrapper. Extracted after code review on backlog
+ * #27 found `pr-assembler.mjs`, `pr-opener.mjs`, `branch-scanner.mjs`, and
+ * `commit-linker.mjs` each reimplementing this; the duplication is exactly
+ * what let `pr-assembler.mjs`'s own `detectRemoteUrl` silently drop `cwd`.
+ * `branch-scanner.mjs`/`commit-linker.mjs` are left untouched here — out of
+ * this ticket's scope, no evidence either has the same bug.
+ */
+
+const SPAWN_OPTS = { encoding: 'utf8', timeout: 10_000 };
+
+/**
+ * @param {Function} execFn - spawnSync-compatible function
+ * @param {string[]} args - args after "git", e.g. ['remote', 'get-url', 'origin']
+ * @param {string} [cwd]
+ * @returns {string|null} stdout on success, null on non-zero exit or a thrown error
+ */
+export function runGit(execFn, args, cwd) {
+  try {
+    const result = execFn('git', args, { ...SPAWN_OPTS, cwd });
+    return result.status === 0 ? (result.stdout ?? '') : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {Function} execFn
+ * @param {string} [cwd]
+ * @returns {string|null}
+ */
+export function detectRemoteUrl(execFn, cwd) {
+  const out = runGit(execFn, ['remote', 'get-url', 'origin'], cwd);
+  return out ? out.trim() : null;
+}

package/skills/jtb/scripts/lib/help.mjs

@@ -658,7 +658,9 @@ export function printMcpHelp({ stream = process.stdout } = {}) {
     `  ${s.cyan('update')}/${s.cyan('create')}/${s.cyan('worklog')} above.`,
     `  ${s.cyan('fetch')}, ${s.cyan('doctor')}, and ${s.cyan('standup')} are Free; ${s.cyan('triage')} is Free with some Pro/Team-gated`,
     `  options (see ${s.cyan('ticketlens triage --help')}); ${s.cyan('compliance')} and ${s.cyan('pr')} are Free, sharing a`,
-    `  3-checks/month cap on their requirements-coverage section, Pro unlimited;`,
+    `  3-checks/month cap on their requirements-coverage section, Pro unlimited; ${s.cyan('pr')}'s`,
+    `  \`open: true\` (Pro) opens a real GitHub PR compare page instead of just printing the`,
+    `  description — GitHub only, current branch must already be pushed to origin;`,
     `  ${s.cyan('compliance')}'s \`consensus: true\` (Pro) runs a multi-agent review server-side against`,
     `  a "consensus" role configured at Console > Admin > AI Roles, and always implies`,
     `  \`--yes\` under MCP, since there is no TTY for the cost-confirmation prompt;`,

package/skills/jtb/scripts/lib/mcp-server.mjs

@@ -231,9 +231,10 @@ async function callStandup(args, deps) {
   return callFetchTicketRun(buildStandupArgs, args, deps, 'standup failed');
 }
 
-function buildPrArgs({ ticket, profile }) {
+function buildPrArgs({ ticket, profile, open }) {
   const args = ['pr', ticket];
   if (profile) args.push(`--profile=${profile}`);
+  if (open) args.push('--open');
   return args;
 }
 

package/skills/jtb/scripts/lib/mcp-tool-schemas.mjs

@@ -79,12 +79,13 @@ export const TOOLS = [
   },
   {
     name: 'pr',
-    description: 'Assemble a ready-to-paste PR description for a ticket — what changed (from linked commits), linked tickets, and (if the ticket has acceptance criteria) a requirements-coverage section. Read-only. The requirements-coverage section reuses the same Free-tier 3-checks/month counter as the `compliance` tool — calling `pr` on a ticket with acceptance criteria counts against that shared monthly limit; TicketLens Pro removes the cap.',
+    description: 'Assemble a ready-to-paste PR description for a ticket — what changed (from linked commits), linked tickets, and (if the ticket has acceptance criteria) a requirements-coverage section. Read-only by default. The requirements-coverage section reuses the same Free-tier 3-checks/month counter as the `compliance` tool — calling `pr` on a ticket with acceptance criteria counts against that shared monthly limit; TicketLens Pro removes the cap. `open: true` (TicketLens Pro required) opens a real GitHub PR compare page instead, prefilled with this same description — GitHub only, requires the current branch already pushed to origin; refuses cleanly on a non-GitHub remote, detached HEAD, or an unpushed branch.',
     inputSchema: {
       type: 'object',
       properties: {
         ticket: { type: 'string', description: 'Ticket key, e.g. PROJ-123.' },
         profile: { type: 'string', description: 'Connection profile to target, overriding folder-based inference and the default profile.' },
+        open: { type: 'boolean', description: 'Open a real GitHub PR compare page prefilled with this description, instead of just returning the text. TicketLens Pro required. GitHub only.' },
       },
       required: ['ticket'],
     },

package/skills/jtb/scripts/lib/pr-assembler.mjs

@@ -11,25 +11,7 @@ import { findLinkedCommits } from './commit-linker.mjs';
 import { runComplianceCheck, STATUS_ICON, statusColor } from './compliance-checker.mjs';
 import { DEFAULT_CONFIG_DIR } from './config.mjs';
 import { createStyler } from './ansi.mjs';
-
-/**
- * Detect the git remote URL using execFn.
- * Returns the URL string or null if none detected.
- *
- * @param {Function} execFn - injectable spawnSync-compatible function
- * @returns {string|null}
- */
-function detectRemoteUrl(execFn) {
-  try {
-    const result = execFn('git', ['remote', 'get-url', 'origin'], { encoding: 'utf8' });
-    if (result.status === 0 && result.stdout) {
-      return result.stdout.trim();
-    }
-  } catch {
-    // non-fatal
-  }
-  return null;
-}
+import { detectRemoteUrl } from './git-exec.mjs';
 
 /**
  * Build the "### Linked tickets" section from a ticket's linkedIssues.
@@ -129,7 +111,7 @@ export async function assemblePr(ticketKey, {
   }
 
   // Detect remote URL for auto-close footer
-  const remoteUrl = detectRemoteUrl(execFn);
+  const remoteUrl = detectRemoteUrl(execFn, cwd);
   const isGitHubOrGitLab = remoteUrl && (
     remoteUrl.includes('github.com') || remoteUrl.includes('gitlab.com')
   );

package/skills/jtb/scripts/lib/pr-opener.mjs

@@ -0,0 +1,108 @@
+/**
+ * Backlog #27 — open a real GitHub PR compare page for a ticket,
+ * prefilled with the same markdown `ticketlens pr KEY` already prints.
+ * GitHub only (v1). No repo-write credential: builds a `/compare` URL
+ * and opens it in the browser — GitHub itself handles PR creation.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { scanCurrentBranch } from './branch-scanner.mjs';
+import { openBrowser } from './browser-login.mjs';
+import { runGit, detectRemoteUrl } from './git-exec.mjs';
+
+const MAX_BODY_LEN = 4000;
+// Repo group excludes only a trailing ".git", not every dot — real GitHub
+// repos commonly contain one (next.js, socket.io); code review caught the
+// original ([^/.]+?) form wrongly refusing every one of them.
+const GITHUB_REMOTE_RE = /github\.com[:/]([^/]+)\/(.+?)(\.git)?$/;
+
+export function parseGitHubRemote(remoteUrl) {
+  if (!remoteUrl) return null;
+  const m = remoteUrl.match(GITHUB_REMOTE_RE);
+  return m ? { owner: m[1], repo: m[2] } : null;
+}
+
+// A literal "/" is common and load-bearing in real branch/repo names
+// (feature/foo) and GitHub's own compare URLs handle it unencoded — a blanket
+// encodeURIComponent would break that. "#" is the one character that must be
+// escaped here: left raw, it starts a URL fragment and silently truncates
+// everything after it (including title/body), rather than 404ing loudly.
+function escapeHash(segment) {
+  return segment.replace(/#/g, '%23');
+}
+
+export function buildCompareUrl({ owner, repo, base, head, title, body, ticketKey }) {
+  const bareBase = escapeHash(base.replace(/^origin\//, ''));
+  const safeHead = escapeHash(head);
+  const safeOwner = escapeHash(owner);
+  const safeRepo = escapeHash(repo);
+  let finalBody = body;
+  if (finalBody.length > MAX_BODY_LEN) {
+    const note = `\n\n_…truncated — full description: \`ticketlens pr ${ticketKey ?? head}\`_`;
+    finalBody = finalBody.slice(0, MAX_BODY_LEN) + note;
+  }
+  const params = new URLSearchParams({ expand: '1', title, body: finalBody });
+  return `https://github.com/${safeOwner}/${safeRepo}/compare/${bareBase}...${safeHead}?${params.toString()}`;
+}
+
+/**
+ * @param {string} ticketKey
+ * @param {string} markdown - the exact markdown assemblePr() already produced
+ * @param {object} [opts]
+ * @returns {Promise<{ok: true, url: string} | {ok: false, reason: string, message: string}>}
+ *
+ * Known limitation (pre-existing in branch-scanner.mjs, not fixed here — see
+ * backlog): run from a repo subdirectory misreports 'no-branch' even on a
+ * real branch, since scanCurrentBranch only checks for .git at cwd exactly,
+ * not via git's own upward search. Run from the repo root.
+ */
+export async function openPr(ticketKey, markdown, {
+  cwd = process.cwd(),
+  execFn = spawnSync,
+  scanCurrentBranchFn = scanCurrentBranch,
+  openBrowserFn = openBrowser,
+} = {}) {
+  const remoteUrl = detectRemoteUrl(execFn, cwd);
+  const gh = parseGitHubRemote(remoteUrl);
+  if (!gh) {
+    return { ok: false, reason: 'not-github', message: 'No GitHub remote detected on origin — `pr --open` supports GitHub only.' };
+  }
+
+  const [scan] = scanCurrentBranchFn({ cwd, execFn }) ?? [];
+  if (!scan || !scan.branch) {
+    return { ok: false, reason: 'no-branch', message: 'Not on a real branch (detached HEAD, or not a git repository).' };
+  }
+  if (!scan.base) {
+    return { ok: false, reason: 'no-base', message: 'No base branch detected (tried origin/main, origin/master, origin/develop, main, master).' };
+  }
+  if (scan.branch === scan.base.replace(/^origin\//, '')) {
+    return { ok: false, reason: 'head-equals-base', message: `Already on the base branch ("${scan.branch}") — nothing to compare.` };
+  }
+
+  const pushed = runGit(execFn, ['rev-parse', '--verify', `origin/${scan.branch}`], cwd);
+  if (pushed === null) {
+    return { ok: false, reason: 'unpushed', message: `Branch "${scan.branch}" isn't pushed to origin yet — push it first, then re-run.` };
+  }
+
+  const firstNewline = markdown.indexOf('\n');
+  const titleLine = (firstNewline === -1 ? markdown : markdown.slice(0, firstNewline)).replace(/^##\s*/, '');
+  const body = firstNewline === -1 ? '' : markdown.slice(firstNewline + 1).trim();
+
+  const url = buildCompareUrl({
+    owner: gh.owner,
+    repo: gh.repo,
+    base: scan.base,
+    head: scan.branch,
+    title: titleLine,
+    body,
+    ticketKey,
+  });
+
+  try {
+    openBrowserFn(url);
+  } catch {
+    // best-effort — the URL is still returned/printed either way
+  }
+
+  return { ok: true, url };
+}