@reticlehq/server 3.8.2 → 3.9.0

package/dist/command/cli/cli-verify.js

@@ -86,8 +86,9 @@ async function openConnection(ports) {
 /** Orchestration: boot → wait for a session → replay flows → verdict → exit code. Browser-free. */
 export async function runVerify(args, outer) {
     const conn = await openConnection(outer);
-    if (conn === undefined)
+    if (conn === undefined) {
         return;
+    }
     /*
      * The exit is held until the connection has closed. The live exit is process.exit, and close()
      * runs the last cloud sync cycle that sends this run's flows and screenshots: exiting first skipped
@@ -132,8 +133,9 @@ export async function runVerify(args, outer) {
          */
         if (0 === names.length && (true === args.explore || args.persona !== undefined)) {
             const explored = await explore(conn, args, ports);
-            if (!explored)
+            if (!explored) {
                 return;
+            }
             names = await conn.listFlows();
         }
         if (0 === names.length) {
@@ -192,8 +194,9 @@ export async function runVerify(args, outer) {
     finally {
         await conn.close().catch(() => undefined);
         // In the finally, so the early refusals that `return` from the try exit too.
-        if (exitCode !== undefined)
+        if (exitCode !== undefined) {
             outer.exit(exitCode);
+        }
     }
 }
 /**
@@ -269,8 +272,9 @@ function delay(ms) {
 async function waitForSession(sessions, timeoutMs, now) {
     const deadline = now() + timeoutMs;
     while (now() < deadline) {
-        if (sessions.count() > 0)
+        if (sessions.count() > 0) {
             return true;
+        }
         await delay(SESSION_POLL_MS);
     }
     return sessions.count() > 0;
@@ -298,8 +302,9 @@ export function buildVerifyDeps(running, reticleRoot, now) {
         // RETICLE_API_KEY was told to run `reticle connect` when asking the Harness to drive.
         linkedCloud: linkedCloudPort(fs, reticleRoot, homedir(), process.env),
     };
-    if (running.realInput !== undefined)
+    if (running.realInput !== undefined) {
         deps.realInput = running.realInput;
+    }
     return deps;
 }
 /** Split a drive URL into its origin + whether it's loopback — decides token/injection pairing. */
@@ -501,8 +506,9 @@ export function routeVerify(args) {
             ? { route: VerifyRoute.ADHOC }
             : { route: VerifyRoute.REFUSE, message: expectNeedsDaemonMessage(args.port, args.presence) };
     }
-    if (args.presence !== PortPresence.DAEMON)
+    if (args.presence !== PortPresence.DAEMON) {
         return { route: VerifyRoute.FLOWS };
+    }
     if (true === args.explore && true !== args.wantsOwnBrowser && true !== args.hasSavedFlows) {
         return { route: VerifyRoute.ADHOC_EXPLORE };
     }
@@ -512,7 +518,12 @@ export function routeVerify(args) {
         ? { route: VerifyRoute.REFUSE, message: portBusyMessage(args.port) }
         : { route: VerifyRoute.ADHOC_SUITE };
 }
-export function handleVerify(parsed) {
+export function handleVerify(parsed, 
+/**
+ * Called once, after the last verdict line and before the exit. `cli.ts` passes the CI line:
+ * `telemetry` already reaches this directory, so this directory does not reach back.
+ */
+beforeExit = () => undefined) {
     const now = () => Date.now();
     /*
      * `--expect-file` is `--expect` with the shell taken out of the loop.
@@ -559,7 +570,10 @@ export function handleVerify(parsed) {
         }),
         out: (line) => process.stdout.write(`${line}\n`),
         fail: (line) => process.stderr.write(`${line}\n`),
-        exit: (code) => process.exit(code),
+        exit: (code) => {
+            beforeExit();
+            process.exit(code);
+        },
         cloud: linkedRunsCloudPort(createNodeFileSystem(), reticleRoot, homedir(), process.env),
         dashboardUrl: () => readDashboardUrl(reticleRoot),
         writeResults: (path, text) => writeFile(path, text, 'utf8'),
@@ -569,8 +583,9 @@ export function handleVerify(parsed) {
     // this used to reach the user as a raw node stack rather than as an answer.
     void (async () => {
         const keyNote = (await resolveProjectCloud(createNodeFileSystem(), reticleRoot, homedir(), process.env)).note;
-        if (keyNote !== undefined)
+        if (keyNote !== undefined) {
             process.stderr.write(`${keyNote}\n`);
+        }
         const port = parsed.port ?? RETICLE_DEFAULT_PORT;
         // A lease opened for this verdict writes its runs into this folder's project, not `unmatched/`.
         const root = callerArtifactRoot(process.cwd());
@@ -613,8 +628,9 @@ export function handleVerify(parsed) {
                     ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
                     ...((t) => (t === undefined || 0 === t.length ? {} : { token: t }))(readOrCreatePairingTokenSync(defaultPairingTokenDir())),
                 });
-                for (const line of verdict.lines)
+                for (const line of verdict.lines) {
                     ports.out(line);
+                }
                 ports.exit(verdict.code);
                 return;
             }
@@ -631,8 +647,9 @@ export function handleVerify(parsed) {
                     ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
                     ...((t) => (t === undefined || 0 === t.length ? {} : { token: t }))(readOrCreatePairingTokenSync(defaultPairingTokenDir())),
                 });
-                for (const line of suite.lines)
+                for (const line of suite.lines) {
                     ports.out(line);
+                }
                 ports.exit(suite.code);
                 return;
             }
@@ -647,15 +664,17 @@ export function handleVerify(parsed) {
                     ...callerRoot,
                     ...((t) => (t === undefined || 0 === t.length ? {} : { token: t }))(readOrCreatePairingTokenSync(defaultPairingTokenDir())),
                 });
-                for (const line of explored.lines)
+                for (const line of explored.lines) {
                     ports.out(line);
+                }
                 // The drive runs INSIDE the daemon, so the key has to be in ITS environment. A reader who
                 // exported it in this shell and was told to link has been told to do the thing they just
                 // did; say where the key is actually missing.
                 if (0 !== explored.code && harnessAvailable(process.env)) {
                     const refusedForKey = explored.lines.some((line) => line.includes(MSG_NO_HARNESS_KEY));
-                    if (refusedForKey)
+                    if (refusedForKey) {
                         ports.fail(daemonLacksKeyMessage(port));
+                    }
                 }
                 ports.exit(explored.code);
                 return;

package/dist/command/cli/doctor/browser/chromium-hint.d.ts

@@ -48,6 +48,11 @@ export interface ChromiumProbe {
      * `Microsoft Edge`) — see launch-chromium. Present only when `exists` is false and one was found.
      */
     fallback?: string | undefined;
+    /**
+     * Where Reticle looked for an installed Chrome or Edge when neither Playwright's build nor a
+     * fallback browser was found.
+     */
+    fallbackPaths?: readonly string[] | undefined;
     /** `executablePath` came from RETICLE_CHROMIUM_PATH, so the bundled build is not in play at all. */
     configured?: boolean | undefined;
     /** Why that configured executable cannot be launched. Present only when `exists` is false. */
@@ -118,7 +123,7 @@ export declare function parseChromiumRevision(executablePath: string): {
  * `executablePath()` resolves the revision the daemon will actually launch AND the root it will look
  * in, which is why the probe never reads `PLAYWRIGHT_BROWSERS_PATH` itself.
  */
-export declare function probeChromium(): Promise<ChromiumProbe>;
+export declare function probeChromium(exists?: (path: string) => boolean): Promise<ChromiumProbe>;
 /** The bundled playwright's version, or undefined if it cannot be read (the hint then goes unpinned). */
 export declare function bundledPlaywrightVersion(): string | undefined;
 /**

package/dist/command/cli/doctor/browser/chromium-hint.js

@@ -173,7 +173,7 @@ function installedRevisions(root) {
  * `executablePath()` resolves the revision the daemon will actually launch AND the root it will look
  * in, which is why the probe never reads `PLAYWRIGHT_BROWSERS_PATH` itself.
  */
-export async function probeChromium() {
+export async function probeChromium(exists = existsSync) {
     const searched = playwrightResolutionRoots();
     try {
         const { chromium } = await import('playwright');
@@ -181,14 +181,14 @@ export async function probeChromium() {
         const parsed = parseChromiumRevision(executablePath);
         return {
             executablePath,
-            exists: existsSync(executablePath),
+            exists: exists(executablePath),
             playwrightVersion: bundledPlaywrightVersion(),
             ...(null === parsed
                 ? {}
                 : {
                     wantedRevision: parsed.revision,
                     browsersRoot: parsed.root,
-                    installedRevisions: installedRevisions(parsed.root),
+                    installedRevisions: exists === existsSync ? installedRevisions(parsed.root) : [],
                 }),
         };
     }
@@ -248,6 +248,9 @@ export function bundledPlaywrightVersion() {
 export function chromiumPreflightRefusal(probe) {
     if (probe.exists)
         return undefined;
+    if (undefined !== probe.fallback) {
+        return undefined;
+    }
     if (true === probe.configured && probe.executablePath !== undefined) {
         return configuredChromiumRefusal(probe.executablePath, probe.problem ?? ChromiumPathProblem.MISSING);
     }
@@ -281,16 +284,19 @@ export function chromiumHint(probe) {
         const where = 0 === searched.length ? '' : ` — looked in ${searched.join(', ')}`;
         return `✗ the playwright package is not installed${where}; run: ${command}`;
     }
+    const fallbackPaths = probe.fallbackPaths ?? [];
     const present = probe.installedRevisions ?? [];
     if (present.length > 0 && probe.wantedRevision !== undefined) {
         // The reported machine. Every fact here is one the reader could not otherwise get: what is
         // wanted, what is there, and where "there" is. `npx playwright install chromium` unpinned adds
         // a build to this list and changes nothing, which is what happened.
+        const fallbackWhere = 0 === fallbackPaths.length ? '' : `; also looked for ${fallbackPaths.join(', ')}`;
         return (`✗ wrong revision — the bundled playwright wants ${probe.wantedRevision}; ` +
-            `${probe.browsersRoot ?? ''} holds ${present.join(', ')}. run: ${command}`);
+            `${probe.browsersRoot ?? ''} holds ${present.join(', ')}${fallbackWhere}. run: ${command}`);
     }
     // Naming the path is what turns "missing" from a verdict into evidence: a reader with browsers on
     // disk can see immediately whether this is a missing install or a lookup pointed somewhere else
     // (PLAYWRIGHT_BROWSERS_PATH, a different browsers root, a revision bump).
-    return `✗ missing — looked for ${probe.executablePath}; run: ${command}`;
+    const lookedFor = [probe.executablePath, ...fallbackPaths].join(', ');
+    return `✗ missing — looked for ${lookedFor}; run: ${command}`;
 }

package/dist/command/cli/doctor/doctor-fix.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `reticle doctor --fix`: repair a half-done install, then say what still needs a person.
+ *
+ * A repair changes only Reticle's own state: its pid file, its own stuck daemon, its own Chromium,
+ * and its entry in an agent's MCP config. A row that needs a change to the user's app, a process
+ * that Reticle cannot prove is its daemon, or an action only the user can do, is never changed
+ * here. Its row already names the step, and this prints that step.
+ *
+ * Each repair checks again before it acts, so a second run finds nothing to do and changes nothing.
+ */
+import { DoctorRow } from './doctor-rows.js';
+type DoctorRowLabel = (typeof DoctorRow)[keyof typeof DoctorRow];
+/** One safe repair. `needed` reads the machine; `apply` changes only Reticle's own state. */
+export interface DoctorRepair {
+    /** The doctor row this repair makes green. */
+    readonly row: DoctorRowLabel;
+    /** What the repair is about, in a few words, so two repairs on one row read apart. */
+    readonly what: string;
+    /** The manual step, printed when the repair is not possible or does not take. */
+    readonly step: string;
+    needed(): Promise<boolean>;
+    apply(): Promise<void>;
+}
+/** What `--fix` says about each repair. */
+export declare const FixOutcome: {
+    readonly FIXED: "fixed";
+    readonly NOTHING: "nothing to do";
+    readonly STILL_NEEDS: "still needs";
+};
+/** The last line of a plain `doctor` run, when `--fix` can repair `count` rows. */
+export declare function fixFooter(count: number): string | undefined;
+/** How many repairs have work to do now. */
+export declare function countNeeded(repairs: readonly DoctorRepair[]): Promise<number>;
+/**
+ * Run doctor, apply the needed repairs in the given order, run doctor again, and print one line for
+ * each repair and one for each row that still fails. True when no row fails after the repairs.
+ */
+export declare function runDoctorFix(deps: {
+    /** Runs doctor and returns its rows. Prints them only when `show` is true. */
+    doctor: (show: boolean) => Promise<string[]>;
+    repairs: readonly DoctorRepair[];
+    print: (line: string) => void;
+}): Promise<boolean>;
+export {};

package/dist/command/cli/doctor/doctor-fix.js

@@ -0,0 +1,89 @@
+/**
+ * `reticle doctor --fix`: repair a half-done install, then say what still needs a person.
+ *
+ * A repair changes only Reticle's own state: its pid file, its own stuck daemon, its own Chromium,
+ * and its entry in an agent's MCP config. A row that needs a change to the user's app, a process
+ * that Reticle cannot prove is its daemon, or an action only the user can do, is never changed
+ * here. Its row already names the step, and this prints that step.
+ *
+ * Each repair checks again before it acts, so a second run finds nothing to do and changes nothing.
+ */
+import { DoctorRow, doctorRow, LABEL_COLUMN } from './doctor-rows.js';
+/** What `--fix` says about each repair. */
+export const FixOutcome = {
+    FIXED: 'fixed',
+    NOTHING: 'nothing to do',
+    STILL_NEEDS: 'still needs',
+};
+/** The mark doctor puts on a row that fails. */
+const FAIL_MARK = '✗';
+const FIX_HEADING = 'reticle doctor --fix';
+/** The last line of a plain `doctor` run, when `--fix` can repair `count` rows. */
+export function fixFooter(count) {
+    if (0 === count) {
+        return undefined;
+    }
+    return `Run \`reticle doctor --fix\` to repair ${String(count)} of these.`;
+}
+/** How many repairs have work to do now. */
+export async function countNeeded(repairs) {
+    let count = 0;
+    for (const repair of repairs) {
+        if (await repair.needed()) {
+            count++;
+        }
+    }
+    return count;
+}
+/** The row label at the head of a doctor line, or undefined for a line that is not a row. */
+function rowLabelOf(line) {
+    const label = line.slice(0, LABEL_COLUMN + 2).trim();
+    return 0 === label.length ? undefined : label;
+}
+async function applyOne(repair) {
+    if (!(await repair.needed())) {
+        return FixOutcome.NOTHING;
+    }
+    try {
+        await repair.apply();
+    }
+    catch {
+        // The check below decides. A repair that threw and a repair that did nothing say the same thing.
+    }
+    if (await repair.needed()) {
+        return `${FixOutcome.STILL_NEEDS}: ${repair.step}`;
+    }
+    return FixOutcome.FIXED;
+}
+/**
+ * Run doctor, apply the needed repairs in the given order, run doctor again, and print one line for
+ * each repair and one for each row that still fails. True when no row fails after the repairs.
+ */
+export async function runDoctorFix(deps) {
+    await deps.doctor(true);
+    const results = [];
+    const stillFailing = new Set();
+    for (const repair of deps.repairs) {
+        const outcome = await applyOne(repair);
+        if (outcome.startsWith(FixOutcome.STILL_NEEDS)) {
+            stillFailing.add(repair.row);
+        }
+        results.push(doctorRow(repair.row, `${repair.what}: ${outcome}`));
+    }
+    const after = await deps.doctor(false);
+    const failures = after.filter((line) => line.includes(FAIL_MARK));
+    deps.print('');
+    deps.print(FIX_HEADING);
+    for (const line of results) {
+        deps.print(line);
+    }
+    for (const line of failures) {
+        // A repair that did not take already printed its step for this row.
+        const label = rowLabelOf(line);
+        if (label !== undefined && stillFailing.has(label)) {
+            continue;
+        }
+        deps.print(`  ${FixOutcome.STILL_NEEDS}: ${line.trim()}`);
+    }
+    return 0 === failures.length;
+}

package/dist/command/cli/doctor/doctor-launcher-line.d.ts

@@ -0,0 +1,23 @@
+/** One agent's `reticle` entry, as its config holds it. */
+export interface RegisteredEntry {
+    readonly client: string;
+    readonly entry: unknown;
+}
+interface ConfigIo {
+    readFile(path: string): string | null;
+    exists(path: string): boolean;
+    homeDir(): string;
+}
+/**
+ * The `reticle` entry of each agent config here: Claude Code's user, local and project scopes, and
+ * every file-backed client that `init` registers with.
+ */
+export declare function registeredEntries(io: ConfigIo, cwd: string): RegisteredEntry[];
+/**
+ * The row text, or undefined when every registered launcher exists and no entry is stale.
+ *
+ * @param floatingNote `claudeStaleEntryNote`, when Claude Code's user-scope entry is the floating
+ *   npx form. `setup mcp` keeps that entry, so the row names the remove-then-add step.
+ */
+export declare function launcherLine(entries: readonly RegisteredEntry[], exists: (path: string) => boolean, floatingNote?: string): string | undefined;
+export {};

package/dist/command/cli/doctor/doctor-launcher-line.js

@@ -0,0 +1,60 @@
+/**
+ * The `launcher` row of `reticle doctor`: an agent config starts Reticle from an installed copy
+ * (`node <path> mcp`), and that file is gone.
+ *
+ * `init` registers the installed bin when there is one, so a sandbox boot does not download the
+ * package again. When the package is removed later, the agent shows the server as failed and says
+ * no more. This row names the path and the command that writes a working entry. It prints only
+ * when a launcher is missing, like `version`.
+ */
+import { McpClient, RETICLE_NPM_PACKAGE, claudeReticleEntries, clientSpec, detectMcpClients, isReticleLauncher, } from '@reticlehq/init';
+import { MCP_SERVER_NAME } from '@reticlehq/core';
+const SETUP_MCP = `npx ${RETICLE_NPM_PACKAGE} setup mcp`;
+/** `setup mcp` keeps an existing Claude Code entry, so that entry goes first. */
+const CLAUDE_REMOVE = `claude mcp remove ${MCP_SERVER_NAME} -s user`;
+const record = (value) => 'object' === typeof value && null !== value ? value : {};
+/** Every string in `command` and `args`, in both the `{ command, args }` and the array shape. */
+function strings(entry) {
+    const { command, args } = record(entry);
+    return [command, args].flat().filter((v) => 'string' === typeof v);
+}
+function parsed(text) {
+    try {
+        return JSON.parse(text ?? '');
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The `reticle` entry of each agent config here: Claude Code's user, local and project scopes, and
+ * every file-backed client that `init` registers with.
+ */
+export function registeredEntries(io, cwd) {
+    const claude = claudeReticleEntries(io, cwd).map((entry) => ({
+        client: McpClient.CLAUDE_CODE,
+        entry,
+    }));
+    const others = detectMcpClients(io).map((c) => ({
+        client: c.id,
+        entry: record(record(parsed(c.existing))[clientSpec(c.id).serversKey])[MCP_SERVER_NAME],
+    }));
+    return [...claude, ...others].filter((e) => e.entry !== undefined);
+}
+/**
+ * The row text, or undefined when every registered launcher exists and no entry is stale.
+ *
+ * @param floatingNote `claudeStaleEntryNote`, when Claude Code's user-scope entry is the floating
+ *   npx form. `setup mcp` keeps that entry, so the row names the remove-then-add step.
+ */
+export function launcherLine(entries, exists, floatingNote) {
+    for (const { client, entry } of entries) {
+        const missing = strings(entry).find((s) => isReticleLauncher(s) && !exists(s));
+        if (missing === undefined) {
+            continue;
+        }
+        const fix = McpClient.CLAUDE_CODE === client ? `${CLAUDE_REMOVE}, then ${SETUP_MCP}` : SETUP_MCP;
+        return `✗ ${client} starts Reticle from ${missing}, and that file does not exist. Run: ${fix}`;
+    }
+    return floatingNote === undefined ? undefined : `✗ ${McpClient.CLAUDE_CODE}: ${floatingNote}`;
+}

package/dist/command/cli/doctor/doctor-rows.d.ts

@@ -40,6 +40,8 @@ export declare const DoctorRow: {
      * verification." Every row in this list checks a COMPONENT; none checked a LINK.
      */
     readonly AGENT_LINK: "agent link";
+    /** An agent config starts Reticle from an installed copy that is gone. Only then. */
+    readonly LAUNCHER: "launcher";
     /** Is the APP in this folder wired, not just the tools. Printed by `doctor-project-line.ts`. */
     readonly PROJECT: "project";
     /**
@@ -68,6 +70,8 @@ export declare const DoctorRow: {
     readonly PROMPTS: "prompts";
     /** The daemon's background sync for this project: on or off, why, and the last push. */
     readonly SYNC: "sync";
+    /** Which coding agents found on this machine have Reticle's MCP server registered. */
+    readonly MCP: "mcp";
 };
 type DoctorRowLabel = (typeof DoctorRow)[keyof typeof DoctorRow];
 export declare const DOCTOR_ROW_LABELS: readonly DoctorRowLabel[];

package/dist/command/cli/doctor/doctor-rows.js

@@ -40,6 +40,8 @@ export const DoctorRow = {
      * verification." Every row in this list checks a COMPONENT; none checked a LINK.
      */
     AGENT_LINK: 'agent link',
+    /** An agent config starts Reticle from an installed copy that is gone. Only then. */
+    LAUNCHER: 'launcher',
     /** Is the APP in this folder wired, not just the tools. Printed by `doctor-project-line.ts`. */
     PROJECT: 'project',
     /**
@@ -68,6 +70,8 @@ export const DoctorRow = {
     PROMPTS: 'prompts',
     /** The daemon's background sync for this project: on or off, why, and the last push. */
     SYNC: 'sync',
+    /** Which coding agents found on this machine have Reticle's MCP server registered. */
+    MCP: 'mcp',
 };
 export const DOCTOR_ROW_LABELS = Object.values(DoctorRow);
 /** Indent every row carries, before the label. */

package/dist/command/cli/doctor-repairs.d.ts

@@ -0,0 +1,64 @@
+import { PortPresence } from '../daemon/binding/port-presence.js';
+import { type StepReporter } from './setup-mcp-cli.js';
+import { type PortHolder } from './ports/port-holder.js';
+import { type ChromiumProbe } from './doctor/browser/chromium-hint.js';
+import type { DoctorRepair } from './doctor/doctor-fix.js';
+/** A pid file whose process is gone. `removePid` itself never removes the file of a live process. */
+export declare function stalePidRepair(deps: {
+    readPid: () => number | null;
+    isAlive: (pid: number) => boolean;
+    removePid: () => void;
+}): DoctorRepair;
+/**
+ * A Reticle daemon that holds the port and does not answer. Only a holder whose command line is a
+ * Reticle daemon's qualifies; `stopWedgedDaemon` checks that again, after a grace period, before it
+ * sends a signal. A stranger and the agent's own `reticle mcp` proxy are never stopped.
+ */
+export declare function wedgedDaemonRepair(port: number, deps: {
+    presence: () => Promise<PortPresence>;
+    holder: () => PortHolder | null;
+    stop: () => Promise<boolean>;
+}): DoctorRepair;
+/**
+ * No browser that a launch can use. Only when Playwright's own build is missing or at the wrong
+ * revision and no installed Chrome or Edge stands in. A RETICLE_CHROMIUM_PATH the user set is never
+ * replaced, and an absent playwright package is not a download this can fix.
+ */
+export declare function chromiumRepair(deps: {
+    probe: () => Promise<ChromiumProbe>;
+    install: () => Promise<unknown>;
+    /** The bundled playwright's version, which pins the manual install command. */
+    playwrightVersion: string | undefined;
+}): DoctorRepair;
+/** Agents found on this machine that do not have Reticle's MCP server registered. */
+export declare function mcpRepair(deps: {
+    gaps: () => readonly string[];
+    register: () => void;
+}): DoctorRepair;
+/**
+ * An agent config starts Reticle from an installed copy that no longer exists. `setup mcp`
+ * replaces Reticle's own entry in the JSON clients. It keeps an existing Claude Code entry, so for
+ * Claude Code the row still fails after the repair, and the step is the row's remove-then-add.
+ */
+export declare function launcherRepair(deps: {
+    /** The launcher row, or undefined when every registered launcher exists. */
+    line: () => string | undefined;
+    register: () => void;
+}): DoctorRepair;
+/** The launcher row for the agent configs of this machine and folder. */
+export declare function readLauncherLine(cwd: string): string | undefined;
+/** Which agents found here have Reticle, and which do not. */
+export interface McpRegistration {
+    readonly missing: readonly string[];
+    readonly present: readonly string[];
+}
+/** The `mcp` doctor row. */
+export declare function mcpRegistrationRow(registration: McpRegistration): string;
+/**
+ * Ask `setupMcp` what it would do, and do none of it. Config writes and registration commands are
+ * recorded, not run; only the two `--version` probes run, because they say whether an agent is here.
+ * No telemetry: this is a check, not a registration.
+ */
+export declare function readMcpRegistration(): McpRegistration;
+/** The repairs for this machine and port, in the order `--fix` applies them. */
+export declare function machineRepairs(port: number, reportStep: StepReporter): DoctorRepair[];