salesprompter-cli 0.1.83 → 0.1.84

package/README.md

@@ -44,6 +44,24 @@ For headless or automation use, generate a CLI token in the app and run `salespr
 
 `leads:at-companies` researches Director, Head-of, VP and C-level contacts across functions. It exports a shortlist for review without starting email enrichment or outreach.
 
+Start with company names; no LinkedIn IDs are needed in your brief:
+
+```json
+{ "companies": [{ "name": "Your target company", "maxContacts": 20 }] }
+```
+
+```bash
+salesprompter auth:login
+salesprompter browser:connect
+salesprompter leads:at-companies --brief companies.json --out-dir ./research --resolve-companies --all
+```
+
+After a successful connection, Chrome is remembered for company research. If names are ambiguous, an interactive terminal shows verified candidate locations, websites and evidence links. Choose a number, then confirm; nothing is preselected. The CLI saves the decision and resumes without editing your brief. Use `--review` to review a saved ambiguity later. Enter 0 or press Enter to leave it unresolved.
+
+JSON, quiet and non-interactive runs never prompt. Their `outcome` is `complete`, `incomplete` or `needs_review`; `nextCommand` gives the terminal command for pending collection or identity review. `collectionComplete` refers only to collection, so it can be true while role review remains. Add `--require-complete` for exit code 2 whenever collection or review is unfinished. Without it, exit 0 means the command ran, not that all research is complete. `--no-interactive` disables prompts in a terminal too.
+
+Guided review fetches native details for at most ten exact-name candidates. Non-exact, composite or larger identity choices still need independently checked `--review-file` decisions. Missing/mismatched details cannot be approved. Explicit connection flags override the remembered choice; failed Chrome authentication never falls back silently to another identity.
+
 The checkpoint, shortlist and review exports refresh after every collected page, so long runs expose saved progress immediately. Company labels with punctuation, such as `(TKMS)`, are escaped safely in search queries.
 
 Use `--report-only` to refresh saved reports without contacting LinkedIn. The workspace-bound checkpoint is still checked. `progress` separates unique shortlisted people, review rows, review people, review-only people, pending searches, partial/unknown coverage and unresolved companies. `collectionComplete` is false while any coverage gap remains; `nextActions` explains what is left. Unrestricted geography is labeled explicitly.
@@ -93,23 +111,23 @@ The CLI validates and persists the complete review file as `review-decisions.jso
 
 Partial continuation checkpoints the raw next offset and deduplicates people. Old checkpoints without an offset replay the first page once before advancing. `quota` stops at the shortlist ceiling; `exhaustive` means attempting the accessible 2,500-result window, **not** a promise of exhaustive coverage. Count changes, empty/repeated pages and larger result sets remain explicitly incomplete. Stopped searches require investigation; the CLI does not automatically clear `stoppedReason`. `--all` controls the number of jobs, not these safety limits. Make a private copy of the output directory before comparing old and new role-policy results.
 
-For standalone browser research, sign in once to the CLI-owned Chrome profile, then select Chrome:
+For standalone browser research, sign in once to the CLI-owned Chrome profile:
 
 ```bash
 salesprompter browser:connect
 salesprompter leads:at-companies --brief companies.json --out-dir ./research \
-  --resolve-companies --all --browser chrome
+  --resolve-companies --all
 ```
 
 `browser:connect` opens a separate Chrome window and waits up to ten minutes for your manual Sales Navigator sign-in (change with `--wait <seconds>`). It confirms a successful native authenticated request, then closes its own browser. Google Chrome must be installed. The private profile lives at `~/.config/salesprompter/chrome-research` (or under `SALESPROMPTER_CONFIG_DIR`). Your everyday Chrome profile stays untouched. The control connection uses a private OS pipe, not a debugging port. No cookies or browser storage are read/exported. The CLI keeps only allowlisted native request headers in memory.
 
 Research runs reuse that profile in background Chrome, execute the GET requests themselves, and close their own browser when finished. No Codex task, relay worker, extension, or manual request polling is needed. A first sign-in, expired login, or security challenge still requires you: rerun `browser:connect`, then repeat the research command with the same output directory. Rate limits stop immediately without switching accounts. `--browser chrome`, `--browser-relay-port`, and `--wait-for-session` are mutually exclusive. Chrome connects lazily, so completed checkpoints and report-only runs never launch it.
 
-The default `--browser session` keeps the extension-credential route. Credentials load only for pending requests; on an auth failure it tries changed credentials for the same identity once. Add `--wait-for-session 300` for a bounded refresh wait. The optional Codex `--browser-relay-port` route still needs its external worker. Salesprompter workspace authentication applies in every mode.
+`browser:connect` remembers Chrome only after confirming a successful authenticated request. `browser:connect --check` checks an existing sign-in in background and also remembers it; it does not open a sign-in window. The preference is private and scoped to the CLI configuration directory. Explicit `--browser session` selects extension credentials; without a remembered choice, session remains the fallback. Explicit relay/wait flags take precedence over the preference. Credentials load only for pending requests; on an auth failure the session route tries changed credentials for the same identity once. Add `--wait-for-session 300` for a bounded refresh wait. The optional Codex `--browser-relay-port` route still needs its external worker. Salesprompter workspace authentication applies in every mode.
 
 Ctrl+C, SIGTERM and terminal hangup stop Chrome research gracefully: completed searches stay saved, the owned browser closes, and the research lock is released before exit. Repeat the same command to resume only pending work. A forced kill or power loss cannot run cleanup; if a stale lock remains, confirm that its process stopped before removing only `.research-lock` as the CLI error explains.
 
-Create a JSON brief with verified numeric LinkedIn company IDs. Use each subsidiary's own ID; names alone are not an employer match. Missing IDs stay in the coverage report as unresolved.
+Create a JSON brief with company names or verified numeric LinkedIn company IDs. Use `--resolve-companies` for names. Each subsidiary must resolve to its own ID; unresolved identities stay in the coverage report and are never guessed.
 
 For a name-only list, the executable end-to-end research mode is:
 

package/dist/cli.js

@@ -17,6 +17,8 @@ import { z } from "zod";
 import { AffiliateCopyReviewSchema, renderAffiliateCopyReview } from "./affiliate-copy.js";
 import { CompanyBriefSchema, planCompanySearches, runCompanyResearch } from "./company-leads.js";
 import { CompanyReviewSchema, resolveCompanyIdentity } from "./company-recovery.js";
+import { chooseCompanyIdentity, companyResearchNextCommand, createCompanyReviewPrompt } from "./company-identity-review.js";
+import { rememberResearchBrowser, selectResearchBrowser } from "./research-browser-preference.js";
 import { createLazySessionRecovery, waitForFreshSession, isFreshSessionForIdentity } from "./session-recovery.js";
 import { createChromeResearchBrowser, ChromeResearchInterruptedError } from "./chrome-browser.js";
 import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWithToken, readAuthSession, requireAuthSession, shouldBypassAuth, verifySession, writeAuthSession } from "./auth.js";
@@ -15142,10 +15144,13 @@ program
     .command("browser:connect")
     .description("Sign in once to the CLI-owned research Chrome; no external browser worker required.")
     .option("--wait <seconds>", "Time allowed for manual LinkedIn sign-in", "600")
+    .option("--check", "Check the saved sign-in in background without opening a sign-in window", false)
     .action(async (options) => {
-    const browser = createChromeResearchBrowser({ visible: true, loginWaitMs: z.coerce.number().int().min(1).max(3600).parse(options.wait) * 1000, onProgress: message => process.stderr.write(`${message}\n`) });
+    const browser = createChromeResearchBrowser({ visible: !options.check, loginWaitMs: options.check ? 5000 : z.coerce.number().int().min(1).max(3600).parse(options.wait) * 1000, onProgress: message => process.stderr.write(`${message}\n`) });
     try {
-        printOutput({ status: "ok", ...await browser.connect() });
+        const connection = await browser.connect();
+        await rememberResearchBrowser(getSalesprompterConfigDir(), "chrome");
+        printOutput({ status: "ok", ...connection, defaultResearchBrowser: "chrome" });
     }
     finally {
         await browser.close();
@@ -15154,7 +15159,7 @@ program
 program
     .command("leads:at-companies")
     .description("Find senior contacts at named companies, balanced across functions; export a review shortlist.")
-    .requiredOption("--brief <path>", "JSON company list with verified company IDs and optional role criteria")
+    .requiredOption("--brief <path>", "JSON company names or verified IDs, with optional role criteria")
     .option("--out-dir <path>", "Private output directory and resume checkpoint", "./company-leads")
     .option("--max-searches <number>", "Maximum company/function searches this invocation", "12")
     .option("--report-only", "Refresh saved research reports without contacting LinkedIn", false)
@@ -15162,15 +15167,24 @@ program
     .option("--resolve-companies", "Resolve unique exact company names and collect their contacts in the same run", false)
     .option("--retry-unresolved", "Retry cached identity misses without discarding completed searches (requires --resolve-companies)", false)
     .option("--review-file <path>", "Apply fingerprint-bound, evidence-backed identity/alias decisions without changing the brief")
+    .option("--review", "Choose unresolved company identities in this terminal, then resume collection", false)
+    .option("--no-interactive", "Never prompt for company review; return needs_review for unresolved choices")
+    .option("--require-complete", "Exit 2 unless collection and review are complete; still write reports", false)
     .option("--verify-employers", "Verify canonical employer names against LinkedIn company details and save safe aliases", false)
     .option("--continue-partial <mode>", "Resume saved partial pages: quota or exhaustive (2500-result window)")
     .option("--company <name>", "Limit recovery to an exact brief company name; repeat for multiple companies", (value, previous) => [...previous, value], [])
     .option("--wait-for-session <seconds>", "Wait for a refreshed extension session after an auth failure; never retry rate limits", "0")
     .option("--browser-relay-port <number>", "Use the signed-in Codex browser through a loopback relay")
-    .option("--browser <mode>", "Use chrome for CLI-owned browser research, or session for extension credentials", "session")
+    .option("--browser <mode>", "Override saved connection: chrome or session; browser:connect remembers chrome")
     .option("--dry-run", "Preview targeting and unresolved companies without network calls", false)
     .action(async (options) => {
-    const browserMode = z.enum(["chrome", "session"]).parse(options.browser);
+    const browserMode = await selectResearchBrowser(options, getSalesprompterConfigDir());
+    const canReview = Boolean(process.stdin.isTTY && process.stderr.isTTY && !runtimeOutputOptions.json && !runtimeOutputOptions.quiet && options.interactive);
+    if (options.review && !canReview)
+        throw new Error("--review requires an interactive terminal without --json, --quiet or --no-interactive. Run the displayed nextCommand in a terminal, or use --review-file for an evidence-backed scripted decision.");
+    if (options.review && (options.reportOnly || options.dryRun))
+        throw new Error("--review cannot be combined with --report-only or --dry-run; candidate verification requires live company details.");
+    const interactiveReview = canReview && !options.reportOnly && !options.dryRun && (options.review || options.resolveCompanies);
     if (options.retryUnresolved && !options.resolveCompanies)
         throw new Error("--retry-unresolved requires --resolve-companies.");
     const waitMs = z.coerce.number().int().min(0).max(3600).parse(options.waitForSession) * 1000;
@@ -15188,16 +15202,30 @@ program
     const maxSearches = options.all ? Number.MAX_SAFE_INTEGER : z.coerce.number().int().min(1).max(10000).parse(options.maxSearches);
     if (options.dryRun) {
         const inScope = (name) => !options.company.length || options.company.includes(name);
-        printOutput({ status: "ok", dryRun: true, searches: jobs.filter(job => inScope(job.company.name)), unresolvedCompanies: brief.companies.filter(c => !c.companyId && inScope(c.name)), maxSearches, recovery: { companies: options.company, verifyEmployers: options.verifyEmployers, continuePartial: continuePartial ?? null, reviewFile: options.reviewFile ? path.resolve(options.reviewFile) : null, savedCheckpointNotRead: true }, outreachStarted: false, emailEnrichmentStarted: false });
+        printOutput({ status: "ok", outcome: "preview", browser: browserMode, dryRun: true, searches: jobs.filter(job => inScope(job.company.name)), unresolvedCompanies: brief.companies.filter(c => !c.companyId && inScope(c.name)), maxSearches, recovery: { companies: options.company, verifyEmployers: options.verifyEmployers, continuePartial: continuePartial ?? null, reviewFile: options.reviewFile ? path.resolve(options.reviewFile) : null, savedCheckpointNotRead: true }, outreachStarted: false, emailEnrichmentStarted: false });
         return;
     }
     const session = await requireAuthSession();
     const orgId = session.user.orgId;
     if (!orgId)
         throw new Error("Choose a Salesprompter workspace before company research.");
+    const finish = (report, reportOnly = false) => {
+        const nextCommand = companyResearchNextCommand({ brief: path.resolve(options.brief), outDir: report.output, browser: browserMode, unresolved: report.progress.unresolvedCompanies, pending: report.progress.remainingSearches, companies: options.company });
+        writeProgress(`\n${report.outcome.replace(/_/g, " ").toUpperCase()}: ${report.selected.length} contacts; ${report.progress.completedSearches}/${report.progress.totalSearches} searches; ${report.progress.reviewOnlyPeople} additional people to review.`);
+        if (nextCommand)
+            writeProgress(`Next: ${nextCommand}`);
+        if (report.review.length)
+            writeProgress(`Role/employer review: ${path.join(report.output, "review.csv")}`);
+        if (process.stdout.isTTY && !runtimeOutputOptions.json)
+            writeProgress(`Contacts: ${path.join(report.output, "contacts.csv")}\nReport: ${path.join(report.output, "coverage.json")}`);
+        else
+            printOutput({ status: report.status, outcome: report.outcome, browser: browserMode, reportOnly, selected: report.selected.length, reviewRequired: report.review.length, progress: report.progress, nextActions: report.nextActions, nextCommand, completedSearches: report.completedSearches, totalSearches: report.totalSearches, coverage: report.coverage, output: report.output, resumable: true, outreachStarted: false, emailEnrichmentStarted: false });
+        if (options.requireComplete && report.outcome !== "complete")
+            process.exitCode = 2;
+    };
     if (options.reportOnly) {
         const report = await runCompanyResearch({ brief, review, onlyCompanies: options.company, outDir: path.resolve(options.outDir), scope: `${session.apiBaseUrl}:${orgId}`, maxSearches: 0, search: async () => { throw new Error("Report-only cannot collect leads."); } });
-        printOutput({ status: "ok", reportOnly: true, progress: report.progress, nextActions: report.nextActions, output: report.output, outreachStarted: false, emailEnrichmentStarted: false });
+        finish(report, true);
         return;
     }
     const port = options.browserRelayPort == null ? null : z.coerce.number().int().min(1).max(65535).parse(options.browserRelayPort);
@@ -15252,12 +15280,21 @@ program
         const record = cliImportCompanyRecord(body?.[id]);
         const explicitId = record?.entityUrn ? extractLinkedInSalesCompanyIdFromUrn(record.entityUrn) : null;
         const evidence = response.status === 200 && typeof record?.name === "string" && (!explicitId || explicitId === id)
-            ? { companyId: id, name: record.name, website: typeof record.website === "string" ? record.website : undefined, evidenceUrl: `https://www.linkedin.com/sales/company/${id}` } : null;
+            ? { companyId: id, name: record.name, website: typeof record.website === "string" ? record.website : undefined, location: formatCliImportCompanyLocation(record.headquarters) ?? formatCliImportCompanyLocation(record.location) ?? undefined, evidenceUrl: `https://www.linkedin.com/sales/company/${id}` } : null;
         detailsCache.set(id, evidence);
         return evidence;
     };
     try {
         const report = await runCompanyResearch({ brief, review, onlyCompanies: options.company, continuePartial, outDir: path.resolve(options.outDir), scope: `${session.apiBaseUrl}:${orgId}`, maxSearches, retryUnresolved: options.retryUnresolved,
+            reviewIdentity: !interactiveReview ? undefined : async (company, diagnostic) => {
+                const prompt = createCompanyReviewPrompt();
+                try {
+                    return await chooseCompanyIdentity({ targetName: company.name, diagnostic, details, io: prompt.io });
+                }
+                finally {
+                    prompt.close();
+                }
+            },
             verifyEmployer: options.verifyEmployers ? details : undefined,
             diagnoseCompany: !options.resolveCompanies ? undefined : company => resolveCompanyIdentity(company.name, async (query, start) => {
                 await paced();
@@ -15295,7 +15332,7 @@ program
                 });
             },
         });
-        printOutput({ status: report.status, selected: report.selected.length, reviewRequired: report.review.length, progress: report.progress, nextActions: report.nextActions, completedSearches: report.completedSearches, totalSearches: report.totalSearches, coverage: report.coverage, output: report.output, resumable: true, outreachStarted: false, emailEnrichmentStarted: false });
+        finish(report);
     }
     finally {
         await relay?.close();

package/dist/company-identity-review.js

@@ -0,0 +1,78 @@
+import { companyIdentityKey } from "./company-recovery.js";
+import { createInterface } from "node:readline/promises";
+/** Cancelling a terminal question must reject it so research can release its lock. */
+export function createCompanyReviewPrompt(input = process.stdin, output = process.stderr) {
+    const rl = createInterface({ input, output, terminal: true });
+    const cancellation = new AbortController();
+    const cancel = () => cancellation.abort();
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    rl.on("SIGINT", cancel);
+    rl.once("close", cancel);
+    for (const signal of signals)
+        process.on(signal, cancel);
+    return {
+        io: {
+            write: (text) => { output.write(text); },
+            ask: async (question) => {
+                try {
+                    return await rl.question(question, { signal: cancellation.signal });
+                }
+                catch (error) {
+                    if (cancellation.signal.aborted)
+                        throw new Error("Company review cancelled. Saved work is preserved; rerun with the same --out-dir to resume.");
+                    throw error;
+                }
+            },
+        },
+        close: () => {
+            for (const signal of signals)
+                process.off(signal, cancel);
+            rl.close();
+        },
+    };
+}
+export const terminalText = (text) => text.replace(/[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, " ").slice(0, 300);
+export async function chooseCompanyIdentity(input) {
+    const { targetName, diagnostic, details, io } = input;
+    const candidates = [...new Map(diagnostic.candidates.filter(c => /^[1-9]\d*$/.test(c.companyId) && companyIdentityKey(c.name) === companyIdentityKey(targetName)).map(c => [c.companyId, c])).values()];
+    io.write(`\nCompany review: ${terminalText(targetName)}\n`);
+    if (!candidates.length || candidates.length > 10) {
+        io.write("No bounded exact-name choice is available. Inspect recovery.json and use an evidence-backed --review-file; this company remains unresolved.\n");
+        return null;
+    }
+    const verified = [];
+    for (const candidate of candidates) {
+        const evidence = await details(candidate.companyId);
+        if (!evidence || evidence.companyId !== candidate.companyId || evidence.evidenceUrl !== `https://www.linkedin.com/sales/company/${candidate.companyId}` || companyIdentityKey(evidence.name) !== companyIdentityKey(candidate.name))
+            continue;
+        verified.push(evidence);
+        io.write(`\n${verified.length}. ${terminalText(evidence.name)}\n   Location: ${terminalText(evidence.location ?? "not provided")}\n   Website: ${terminalText(evidence.website ?? "not provided")}\n   Evidence: ${terminalText(evidence.evidenceUrl)}\n`);
+    }
+    if (!verified.length) {
+        io.write("No candidate could be verified. Nothing approved.\n");
+        return null;
+    }
+    io.write("\nMatch the location and website to your intended company. No choice is preselected.\n");
+    while (true) {
+        const answer = (await io.ask("Company number [0 = skip]: ")).trim();
+        if (!answer || answer === "0")
+            return null;
+        if (!/^[1-9]\d*$/.test(answer) || Number(answer) > verified.length) {
+            io.write("Enter a listed number, or 0 to skip.\n");
+            continue;
+        }
+        const chosen = verified[Number(answer) - 1];
+        const confirm = await io.ask(`Use ${terminalText(chosen.name)} (${terminalText(chosen.location ?? chosen.companyId)}) for ${terminalText(targetName)}? [y/N]: `);
+        return /^(y|yes)$/i.test(confirm.trim()) ? chosen : null;
+    }
+}
+export function companyResearchNextCommand(input) {
+    const quote = (text) => `'${text.replace(/'/g, "'\\''")}'`;
+    const scope = (input.companies ?? []).map(name => ` --company ${quote(name)}`).join("");
+    const base = `salesprompter leads:at-companies --brief ${quote(input.brief)} --out-dir ${quote(input.outDir)} --browser ${input.browser}${scope}`;
+    if (input.unresolved)
+        return `${base} --resolve-companies --review --all`;
+    if (input.pending)
+        return `${base} --all`;
+    return null;
+}

package/dist/company-leads.js

@@ -182,11 +182,12 @@ export function shortlistCompanyLeads(brief, results) {
     };
     const nextActions = [
         ...(progress.remainingSearches ? ["Resume the unchanged brief and output directory to collect pending searches."] : []),
-        ...(unresolved.length ? ["Inspect recovery.json; retry selected identities with --resolve-companies --retry-unresolved --company, or apply evidence-backed --review-file decisions."] : []),
+        ...(unresolved.length ? ["Use --review in a terminal to choose a verified exact-name identity. Inspect recovery.json for non-exact decisions or an intentional --retry-unresolved --resolve-companies retry."] : []),
         ...(incomplete.length || unknown.length ? ["Use --continue-partial quota or exhaustive to resume eligible pages; inspect stoppedReason before claiming exhaustive coverage."] : []),
         ...(review.length ? ["Use --verify-employers for canonical names, or evidence-backed --review-file aliases. Ambiguous roles remain review-only."] : []),
     ];
-    return { selected, review, rejected, coverage, progress, nextActions, rolePolicyVersion: 2, outreachStarted: false, emailEnrichmentStarted: false };
+    const outcome = unresolved.length ? "needs_review" : !progress.collectionComplete ? "incomplete" : review.length ? "needs_review" : "complete";
+    return { outcome, selected, review, rejected, coverage, progress, nextActions, rolePolicyVersion: 2, outreachStarted: false, emailEnrichmentStarted: false };
 }
 export function companyLeadCsv(rows) {
     const columns = ["companyName", "companyId", "fullName", "title", "department", "profileUrl", "location", "sourceQueryUrl", "observedAt", "sourceCompanyName", "reason", "reasons", "employerAliasEvidence"];
@@ -386,6 +387,31 @@ async function runCompanyResearchLocked(input) {
                 await collect();
             }
         }
+        if (input.reviewIdentity)
+            for (const [index, company] of brief.companies.entries()) {
+                if (!allowed(company.name) || company.companyId || state.resolutions?.[String(index)])
+                    continue;
+                const diagnostic = state.diagnostics?.[String(index)];
+                if (!diagnostic)
+                    continue;
+                const choice = await input.reviewIdentity(company, diagnostic);
+                if (!choice)
+                    continue;
+                if (!diagnostic.candidates.some(c => c.companyId === choice.companyId && companyIdentityKey(c.name) === companyIdentityKey(choice.name)))
+                    throw new Error("Reviewed identity must match a verified candidate from this research.");
+                if (effectiveBrief().companies.some(c => c.companyId === choice.companyId))
+                    throw new Error("Reviewed identity is already assigned to another target.");
+                const identity = { targetName: company.name, companyId: choice.companyId, canonicalName: choice.name, evidenceUrl: choice.evidenceUrl };
+                review = CompanyReviewSchema.parse({ fingerprint, employerAliases: review?.employerAliases ?? [], identities: [...(review?.identities ?? []), identity] });
+                // The durable review overlay is written first. A crash before the checkpoint
+                // write is recovered by the normal review-file replay on the next invocation.
+                await save(path.join(outDir, "review-decisions.json"), JSON.stringify(review, null, 2));
+                state.resolutions ??= {};
+                state.resolutions[String(index)] = { companyId: choice.companyId, companyName: company.name, canonicalName: choice.name, evidenceUrl: choice.evidenceUrl };
+                await save(checkpoint, JSON.stringify(state));
+                await publish();
+                await collect();
+            }
     }
     catch (e) {
         await publish();

package/dist/research-browser-preference.js

@@ -0,0 +1,37 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const Preference = z.object({ browser: z.enum(["chrome", "session"]) }).strict();
+export async function readResearchBrowserPreference(configDir) {
+    const file = path.join(configDir, "research-browser.json");
+    try {
+        return Preference.parse(JSON.parse(await readFile(file, "utf8"))).browser;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "session";
+        throw new Error(`Cannot read research browser preference at ${file}. Run browser:connect again, or choose --browser chrome or --browser session explicitly.`);
+    }
+}
+export async function rememberResearchBrowser(configDir, browser) {
+    const value = Preference.parse({ browser });
+    await mkdir(configDir, { recursive: true, mode: 0o700 });
+    const file = path.join(configDir, "research-browser.json");
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, JSON.stringify(value) + "\n", { mode: 0o600, flag: "wx" });
+        await rename(temporary, file);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function selectResearchBrowser(options, configDir) {
+    if (options.browser !== undefined)
+        return Preference.shape.browser.parse(options.browser);
+    // An explicit connection route takes precedence over the saved preference.
+    if (options.browserRelayPort !== undefined || Number(options.waitForSession ?? 0) > 0)
+        return "session";
+    return readResearchBrowserPreference(configDir);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salesprompter-cli",
-  "version": "0.1.83",
+  "version": "0.1.84",
   "description": "Sales workflow CLI for guided lead generation, enrichment, scoring, and sync.",
   "author": "Daniel Sinewe <hello@danielsinewe.com>",
   "type": "module",