@mnemom/mnemom 0.17.31 → 0.17.32-next.1

package/dist/commands/agent-share-fixture.js

@@ -0,0 +1,134 @@
+/**
+ * FIXTURE-ONLY statement source and card issuer for `mnemom agent share` (MNE-9037).
+ *
+ * Selected only when MNEMOM_AGENT_SHARE=1 AND MNEMOM_AGENT_SHARE_FIXTURE=1. It holds no key
+ * and signs nothing: the cards below are the two TEST cards committed in mnemom/aip
+ * (packages/verifier/test/fixtures/sharecard/{valid,period-revert}.json, key id
+ * test-sharecard-key-1) that the /share page's fixture verifier (MNE-9031) recognises. The
+ * issuer returns one of them only when the picked lines are exactly that card's lines; any
+ * other pick is an error. Two extra candidates (an estimate and an identifying label) exist so
+ * the refusal path can be shown. This is not a real issuer: a production source and signer
+ * are a separate, human-gated change.
+ */
+export const AGENT_SHARE_FIXTURE_ENV = "MNEMOM_AGENT_SHARE_FIXTURE";
+export function agentShareFixtureEnabled(env = process.env) {
+    return env.MNEMOM_AGENT_SHARE === "1" && env[AGENT_SHARE_FIXTURE_ENV] === "1";
+}
+export const FIXTURE_CARD_VALID = {
+    typ: "AAP-ShareCard/v1",
+    card_id: "card-valid-0001",
+    period: {
+        start: "2026-10-01",
+        end: "2026-10-07",
+    },
+    issued_at: "2026-10-08T00:00:00.000Z",
+    signing_key_id: "test-sharecard-key-1",
+    statements: [
+        {
+            typ: "AAP-Statement/v1",
+            hash: "1111111111111111111111111111111111111111111111111111111111111111",
+        },
+        {
+            typ: "AAP-Statement/v1",
+            hash: "2222222222222222222222222222222222222222222222222222222222222222",
+        },
+    ],
+    lines: [
+        {
+            id: "l1",
+            kind: "count",
+            label: "Changes reviewed",
+            value: 42,
+            statement_hash: "1111111111111111111111111111111111111111111111111111111111111111",
+        },
+        {
+            id: "l2",
+            kind: "count",
+            label: "Checks passed",
+            value: 40,
+            statement_hash: "2222222222222222222222222222222222222222222222222222222222222222",
+        },
+    ],
+    signature: "qsHSChAxBEnEyNoQQLQMFXZ6LKxruMyijxA5s3h9oPKl4OijJqxFm3QC0rteDXJsYwJCMeKyk_0xzGTDc3wDAQ",
+};
+export const FIXTURE_CARD_PERIOD_REVERT = {
+    typ: "AAP-ShareCard/v1",
+    card_id: "card-period-0001",
+    period: {
+        start: "2026-10-01",
+        end: "2026-10-07",
+    },
+    issued_at: "2026-10-08T00:00:00.000Z",
+    signing_key_id: "test-sharecard-key-1",
+    statements: [
+        {
+            typ: "AAP-Statement/v1",
+            hash: "1111111111111111111111111111111111111111111111111111111111111111",
+        },
+        {
+            typ: "AAP-Statement/v1",
+            hash: "2222222222222222222222222222222222222222222222222222222222222222",
+        },
+        {
+            typ: "AAP-Statement/v1",
+            hash: "3333333333333333333333333333333333333333333333333333333333333333",
+        },
+    ],
+    lines: [
+        {
+            id: "l1",
+            kind: "count",
+            label: "Changes reviewed",
+            value: 42,
+            statement_hash: "1111111111111111111111111111111111111111111111111111111111111111",
+        },
+        {
+            id: "l2",
+            kind: "count",
+            label: "Checks passed",
+            value: 40,
+            statement_hash: "2222222222222222222222222222222222222222222222222222222222222222",
+        },
+        {
+            id: "l3",
+            kind: "revert",
+            label: "Changes reverted",
+            value: 2,
+            statement_hash: "3333333333333333333333333333333333333333333333333333333333333333",
+        },
+    ],
+    signature: "OQf-4xgUQbIxOef_BsJeTehfpqLPPR2GTv8_y6EbxPX9UkFp2PpE2pnETh2VqcwDfV1U_4bSR8Pwrpsch3DwCw",
+};
+const FIXTURE_CARDS = [FIXTURE_CARD_VALID, FIXTURE_CARD_PERIOD_REVERT];
+const HASH_E = "e".repeat(64);
+const HASH_F = "f".repeat(64);
+/** Real candidate lines plus two that must be refused. */
+export const FIXTURE_CANDIDATES = [
+    ...FIXTURE_CARD_PERIOD_REVERT.lines,
+    {
+        id: "e1",
+        kind: "count",
+        label: "Hours saved",
+        value: 12,
+        statement_hash: HASH_E,
+        estimated: true,
+    },
+    { id: "r1", kind: "count", label: "Repo mnemom/aip", value: 3, statement_hash: HASH_F },
+];
+const same = (a, b) => a.length === b.length &&
+    a.every((l) => {
+        const m = b.find((x) => x.id === l.id);
+        return m !== undefined && JSON.stringify(m) === JSON.stringify(l);
+    });
+export const fixtureAgentShareParts = {
+    source: { listLines: async () => FIXTURE_CANDIDATES },
+    issuer: {
+        issue: async (lines) => {
+            const card = FIXTURE_CARDS.find((c) => same(c.lines, lines));
+            if (!card) {
+                throw new Error("fixture issuer only issues the two test cards: pick l1,l2 or l1,l2,l3");
+            }
+            return structuredClone(card);
+        },
+    },
+};

package/dist/commands/agent-share.d.ts

@@ -0,0 +1,87 @@
+/**
+ * `mnemom agent share` (MNE-9037, parent MNE-9014) — build a shareable work card from the
+ * lines of your own signed statements and print a link to the static share page with the
+ * card in the URL fragment (`/share#card=<base64url(JSON)>`). The fragment is never sent to
+ * a server. The command only PRINTS the link: it never posts, uploads or opens it anywhere
+ * (W6.2 — the share offer never auto-posts).
+ *
+ * Gated by MNEMOM_AGENT_SHARE=1 (not experimental-registry; off by default, so default CLI
+ * behaviour is unchanged). Everything outside the process is injected:
+ *   - `source`   lists candidate lines from the user's signed statements,
+ *   - `issuer`   returns the SIGNED AAP-ShareCard/v1 for the chosen lines (the CLI never holds
+ *                a signing key),
+ *   - `renderer` the aip `renderLines` (MNE-9026, unpublished) behind a small interface.
+ * The CLI refuses, before anything is issued, lines that are estimates or that carry
+ * identifying fields, and re-checks the returned card for the same.
+ */
+export declare const AGENT_SHARE_ENV = "MNEMOM_AGENT_SHARE";
+export declare function agentShareEnabled(env?: Record<string, string | undefined>): boolean;
+/** A line as offered by the statement source. Extra keys are kept so they can be refused. */
+export interface CandidateLine {
+    id: string;
+    kind: string;
+    label: string;
+    value: number;
+    statement_hash: string;
+    [extra: string]: unknown;
+}
+export interface SharedCardLine {
+    id: string;
+    kind: "count" | "revert";
+    label: string;
+    value: number;
+    statement_hash: string;
+}
+/** Shape of AAP-ShareCard/v1 as far as the CLI needs it (full verification is the page's job). */
+export interface ShareCardLike {
+    typ: string;
+    lines: SharedCardLine[];
+    [key: string]: unknown;
+}
+export interface RenderedLinePreview {
+    text: string;
+    coverage?: string;
+    kind: string;
+}
+/** The aip `renderLines` contract, injected (not yet published). */
+export interface LineRenderer {
+    renderLines(card: unknown): RenderedLinePreview[];
+}
+export interface StatementSource {
+    listLines(): Promise<CandidateLine[]>;
+}
+export interface CardIssuer {
+    /** Signed card committing to exactly these lines. */
+    issue(lines: SharedCardLine[]): Promise<ShareCardLike>;
+}
+export interface AgentShareDeps {
+    source: StatementSource;
+    issuer: CardIssuer;
+    renderer: LineRenderer;
+    /** Interactive picker: returns the chosen line ids. */
+    pick: (lines: SharedCardLine[]) => Promise<string[]>;
+    isTTY: () => boolean;
+    websiteBase: () => string;
+    out: (line: string) => void;
+    err: (line: string) => void;
+}
+export interface AgentShareFlags {
+    lines?: string;
+    list?: boolean;
+    json?: boolean;
+}
+export type RefusalReason = "estimate" | "identifying" | "malformed";
+export interface Refusal {
+    id: string;
+    reason: RefusalReason;
+    detail: string;
+}
+/** Null when the line may be shared; otherwise why it is refused. Fails closed. */
+export declare function refuseReason(line: CandidateLine): Refusal | null;
+export declare function toSharedLine(line: CandidateLine): SharedCardLine;
+/** Card → `<base>/share#card=<base64url(UTF-8 JSON)>` (the format the share page reads). */
+export declare function buildShareLink(card: unknown, websiteBase: string): string;
+/** Inverse of buildShareLink's fragment, for tests and `--json` consumers. */
+export declare function decodeShareFragment(link: string): unknown;
+export declare function agentShareCommand(flags: AgentShareFlags, deps: AgentShareDeps, env?: Record<string, string | undefined>): Promise<number>;
+export declare const liveAgentShareDeps: AgentShareDeps;

package/dist/commands/agent-share.js

@@ -0,0 +1,251 @@
+/**
+ * `mnemom agent share` (MNE-9037, parent MNE-9014) — build a shareable work card from the
+ * lines of your own signed statements and print a link to the static share page with the
+ * card in the URL fragment (`/share#card=<base64url(JSON)>`). The fragment is never sent to
+ * a server. The command only PRINTS the link: it never posts, uploads or opens it anywhere
+ * (W6.2 — the share offer never auto-posts).
+ *
+ * Gated by MNEMOM_AGENT_SHARE=1 (not experimental-registry; off by default, so default CLI
+ * behaviour is unchanged). Everything outside the process is injected:
+ *   - `source`   lists candidate lines from the user's signed statements,
+ *   - `issuer`   returns the SIGNED AAP-ShareCard/v1 for the chosen lines (the CLI never holds
+ *                a signing key),
+ *   - `renderer` the aip `renderLines` (MNE-9026, unpublished) behind a small interface.
+ * The CLI refuses, before anything is issued, lines that are estimates or that carry
+ * identifying fields, and re-checks the returned card for the same.
+ */
+import { createInterface } from "node:readline/promises";
+import { getWebsiteUrl } from "../lib/config.js";
+import { fmt } from "../lib/format.js";
+export const AGENT_SHARE_ENV = "MNEMOM_AGENT_SHARE";
+export function agentShareEnabled(env = process.env) {
+    return env[AGENT_SHARE_ENV] === "1";
+}
+const HEX64 = /^[0-9a-f]{64}$/;
+const OPAQUE_ID = /^[a-z0-9_-]{1,64}$/;
+/** Same charset the verifier enforces on labels. */
+const LABEL = /^[A-Za-z0-9 .,()+-]{1,40}$/;
+/** The only top-level fields an AAP-ShareCard/v1 may carry. */
+const CARD_KEYS = [
+    "typ",
+    "card_id",
+    "period",
+    "issued_at",
+    "signing_key_id",
+    "statements",
+    "lines",
+    "signature",
+];
+const LINE_KEYS = ["id", "kind", "label", "value", "statement_hash"];
+/** Words that mark a label as naming a repo, org, person, tool, code or goal text. */
+const IDENTIFYING_LABEL = /\b(repo|repository|org|organization|organisation|team|person|user|author|tool|goal|code|branch|commit|pr)\b/i;
+/** Null when the line may be shared; otherwise why it is refused. Fails closed. */
+export function refuseReason(line) {
+    const id = typeof line.id === "string" ? line.id : "(unknown)";
+    const no = (reason, detail) => ({ id, reason, detail });
+    if (line.estimated === true || line.estimate === true || line.provenance === "estimate") {
+        return no("estimate", "it is an estimate, not a count from a signed statement");
+    }
+    const extras = Object.keys(line).filter((k) => !LINE_KEYS.includes(k));
+    if (extras.length > 0) {
+        return no("identifying", `it carries extra field(s): ${extras.join(", ")}`);
+    }
+    if (typeof line.id !== "string" || !OPAQUE_ID.test(line.id))
+        return no("malformed", "bad line id");
+    if (line.kind !== "count" && line.kind !== "revert")
+        return no("malformed", "unsupported line kind");
+    if (typeof line.value !== "number" || !Number.isSafeInteger(line.value) || line.value < 0) {
+        return no("estimate", "its value is not an exact non-negative integer");
+    }
+    if (typeof line.statement_hash !== "string" || !HEX64.test(line.statement_hash)) {
+        return no("estimate", "it is not tied to a signed statement");
+    }
+    if (typeof line.label !== "string" ||
+        !LABEL.test(line.label) ||
+        /[/#]|:\/\/|www\./i.test(line.label)) {
+        return no("identifying", "its label is not short plain text");
+    }
+    if (IDENTIFYING_LABEL.test(line.label)) {
+        return no("identifying", "its label names a repo, org, person, tool, code or goal");
+    }
+    return null;
+}
+export function toSharedLine(line) {
+    return {
+        id: line.id,
+        kind: line.kind,
+        label: line.label,
+        value: line.value,
+        statement_hash: line.statement_hash,
+    };
+}
+/** Card → `<base>/share#card=<base64url(UTF-8 JSON)>` (the format the share page reads). */
+export function buildShareLink(card, websiteBase) {
+    const bytes = new TextEncoder().encode(JSON.stringify(card));
+    const b64 = Buffer.from(bytes).toString("base64url");
+    return `${websiteBase.replace(/\/+$/, "")}/share#card=${b64}`;
+}
+/** Inverse of buildShareLink's fragment, for tests and `--json` consumers. */
+export function decodeShareFragment(link) {
+    const hash = link.slice(link.indexOf("#") + 1);
+    const encoded = new URLSearchParams(hash).get("card") ?? "";
+    try {
+        return JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** The issued card must contain exactly the chosen lines, unaltered. */
+function checkIssuedCard(card, chosen) {
+    if (!card || typeof card !== "object" || !Array.isArray(card.lines))
+        return "the card has no lines";
+    const extra = Object.keys(card).filter((k) => !CARD_KEYS.includes(k));
+    if (extra.length > 0)
+        return `the card carries unexpected field(s): ${extra.join(", ")}`;
+    if (card.lines.length !== chosen.length)
+        return "the card's lines differ from the ones you picked";
+    for (const want of chosen) {
+        const got = card.lines.find((l) => l.id === want.id);
+        if (!got ||
+            LINE_KEYS.some((k) => got[k] !== want[k]) ||
+            Object.keys(got).length !== LINE_KEYS.length) {
+            return `the card's line "${want.id}" differs from the one you picked`;
+        }
+    }
+    return null;
+}
+export async function agentShareCommand(flags, deps, env = process.env) {
+    if (!agentShareEnabled(env)) {
+        deps.err(fmt.error("unknown command 'share' for 'mnemom agent'"));
+        return 1;
+    }
+    let candidates;
+    try {
+        candidates = await deps.source.listLines();
+    }
+    catch (error) {
+        deps.err(fmt.error(`Could not read your signed statements: ${error.message}`));
+        return 1;
+    }
+    const offered = [];
+    const refused = [];
+    for (const c of candidates) {
+        const r = refuseReason(c);
+        if (r)
+            refused.push(r);
+        else
+            offered.push(toSharedLine(c));
+    }
+    if (flags.list) {
+        if (flags.json) {
+            deps.out(JSON.stringify({ lines: offered, refused }, null, 2));
+        }
+        else {
+            if (offered.length === 0)
+                deps.out("No lines available to share.");
+            for (const l of offered)
+                deps.out(`${l.id}  ${l.label}: ${l.value}`);
+            for (const r of refused)
+                deps.out(`(not shareable) ${r.id}: ${r.detail}`);
+        }
+        return 0;
+    }
+    let ids;
+    if (flags.lines !== undefined) {
+        ids = [
+            ...new Set(flags.lines
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean)),
+        ];
+    }
+    else if (deps.isTTY()) {
+        if (offered.length === 0) {
+            deps.err(fmt.error("No lines available to share."));
+            return 1;
+        }
+        ids = await deps.pick(offered);
+    }
+    else {
+        deps.err(fmt.error("No terminal to pick lines in. Pass --lines <id,id> (see --list)."));
+        return 1;
+    }
+    if (ids.length === 0) {
+        deps.err(fmt.error("No lines picked."));
+        return 1;
+    }
+    const chosen = [];
+    for (const id of ids) {
+        const r = refused.find((x) => x.id === id);
+        if (r) {
+            deps.err(fmt.error(`Refusing line "${id}": ${r.detail}.`));
+            return 1;
+        }
+        const line = offered.find((l) => l.id === id);
+        if (!line) {
+            deps.err(fmt.error(`Unknown line "${id}". Run with --list to see what is available.`));
+            return 1;
+        }
+        chosen.push(line);
+    }
+    let card;
+    try {
+        card = await deps.issuer.issue(chosen);
+    }
+    catch (error) {
+        deps.err(fmt.error(`Could not build the card: ${error.message}`));
+        return 1;
+    }
+    const problem = checkIssuedCard(card, chosen);
+    if (problem) {
+        deps.err(fmt.error(`Refusing to share: ${problem}.`));
+        return 1;
+    }
+    const link = buildShareLink(card, deps.websiteBase());
+    if (flags.json) {
+        deps.out(JSON.stringify({ link, lines: chosen }, null, 2));
+        return 0;
+    }
+    deps.out("Your card:");
+    for (const r of deps.renderer.renderLines(card)) {
+        deps.out(`  ${r.text}${r.coverage ? ` (${r.coverage})` : ""}`);
+    }
+    deps.out("");
+    deps.out(link);
+    deps.out("");
+    deps.out("Nothing was posted or sent. The card is in the link's fragment, which a browser never sends to a server; share the link yourself if you want to.");
+    return 0;
+}
+/** Not wired to a backend yet: the signed-statement source and card issuer land with MNE-9026. */
+const notConnected = () => {
+    throw new Error("statement source not connected yet (waiting on the card renderer, MNE-9026)");
+};
+export const liveAgentShareDeps = {
+    source: { listLines: async () => notConnected() },
+    issuer: { issue: async () => notConnected() },
+    renderer: {
+        renderLines: (card) => (card.lines ?? []).map((l) => ({
+            text: `${l.label}: ${l.value}`,
+            kind: l.kind,
+        })),
+    },
+    pick: async (lines) => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            lines.forEach((l, i) => process.stderr.write(`${i + 1}. ${l.label}: ${l.value}\n`));
+            const answer = await rl.question("Pick lines (numbers, comma-separated): ");
+            return answer
+                .split(",")
+                .map((s) => lines[Number(s.trim()) - 1]?.id)
+                .filter((x) => typeof x === "string");
+        }
+        finally {
+            rl.close();
+        }
+    },
+    isTTY: () => Boolean(process.stdin.isTTY),
+    websiteBase: getWebsiteUrl,
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+};

package/dist/commands/agent.d.ts

@@ -28,8 +28,9 @@
 import { type MnemomKeyDeps } from "../lib/subscription-login.js";
 import { type SessionRecord } from "../lib/agent-ledger.js";
 import { type ExperimentalId } from "../lib/experimental.js";
+import { conductReceiptFor, type ReceiptLaunch } from "../lib/conduct-receipt.js";
 import { type GovernanceOptIn } from "./agent-setup.js";
-import { type ContextProfile, type LaunchShape, type SealedContractEnvelope } from "../lib/agent.js";
+import { type CcSettingsView, type ContextProfile, type LaunchShape, type SealedContractEnvelope } from "../lib/agent.js";
 export interface AgentOptions {
     goal?: string;
     requirement?: string[];
@@ -310,11 +311,79 @@ export interface RcCapability {
  * and by the auto-default selection (a bare launch prefers RC when capable).
  */
 export declare function checkRcCapability(cli: ResolvedCli): RcCapability;
+/**
+ * The extra `--settings` the launch merges (beside the autocompact guard): the status line's,
+ * and with commit reporting on (W1.8) the `Mnemom-Conversation` commit trailer, which keeps the
+ * user's own commit attribution in front of it. Never when the user passed their own --settings.
+ */
+export declare function launchSettingsExtra(o: {
+    statusline: Record<string, unknown> | null;
+    commitReport: boolean;
+    ownSettings: boolean;
+    conversationId: string;
+    /** Claude Code's settings files, highest precedence first (readCcSettings). */
+    settings: CcSettingsView[];
+}): Record<string, unknown> | null;
+/**
+ * Whether the local base-URL proxy runs: implicit goals (turn header), the conduct receipt and
+ * commit reporting (W1.8) all need it; commit reporting reads the lineage key it records.
+ */
+export declare function proxyWanted(o: {
+    turnHeader: boolean;
+    receipt: boolean;
+    commitReport: boolean;
+}): boolean;
+/**
+ * Whether the proxy captures the gateway's record state: the conduct receipt reads it at exit,
+ * and the fed status line reads its lineage key while the session runs.
+ */
+export declare function wantsRecordState(receipt: boolean, fed: boolean): boolean;
+/**
+ * Point Claude Code at a ready proxy and, on a fed launch, start the status-line feed on the
+ * proxy's record state (no state file, no feed: the line stays "mnemom").
+ */
+export declare function onBaseUrlProxyReady(baseUrl: string | null, recordStateFile: string | undefined, childEnv: NodeJS.ProcessEnv, feed: {
+    feedFile: string;
+    orgId: string;
+} | null, start?: (o: {
+    recordStateFile: string;
+    feedFile: string;
+    orgId: string;
+}) => unknown): void;
+/**
+ * The status-line feed file for a fed launch (and FEED_ENV set on the child), or null: the
+ * segment off, no billing org, or {@link fedStatuslineWanted} false.
+ */
+export declare function prepareStatuslineFeed(o: {
+    statusline: boolean;
+    orgId?: string;
+    version: string;
+    goalMode: boolean;
+    env: NodeJS.ProcessEnv;
+    childEnv: NodeJS.ProcessEnv;
+    files?: () => {
+        feedFile: string;
+    };
+}): {
+    feedFile: string;
+} | null;
+/**
+ * Whether this launch feeds the status line measured model cost and μ (W1.4): prerelease
+ * builds only (stable stays "mnemom", decision 14), and only when the turn proxy runs, since
+ * the proxy is what learns the gateway's lineage key for the session.
+ */
+export declare function fedStatuslineWanted(version: string, goalMode: boolean, env: NodeJS.ProcessEnv): boolean;
 /**
  * Add 127.0.0.1 and localhost to BOTH NO_PROXY and no_proxy (proxy clients disagree on which one
  * wins, and some read only the lowercase one), keeping whatever each already listed.
  */
 export declare function exemptLoopbackFromProxy(env: NodeJS.ProcessEnv): void;
+/**
+ * Print the conduct receipt (experimental `record`) — the exit call site here, and the one a
+ * durable park calls. Never throws: a failure is one warning line, and the caller's exit code
+ * is untouched.
+ */
+export declare function sayConductReceipt(launch: ReceiptLaunch, trigger?: "exit" | "park", receipt?: typeof conductReceiptFor): Promise<void>;
 /** Whether a terminal implicit launch runs the turn-origin proxy (MNEMOM_AGENT_TURN_HEADER=0 opts out). */
 export declare function turnProxyWanted(env: NodeJS.ProcessEnv): boolean;
 /** Test seams for startBaseUrlProxy (every real caller omits them). */
@@ -325,6 +394,10 @@ export interface BaseUrlProxyOptions {
     node?: string;
     /** How long to wait for READY before launching straight to the door (default 5 s). */
     readyTimeoutMs?: number;
+    /** Send x-mnemom-turn (default true); false sets MNEMOM_AGENT_TURN_HEADER=0 for the proxy. */
+    turnHeader?: boolean;
+    /** Capture the conduct receipt's record state; its path is `done`'s second argument. */
+    recordState?: boolean;
 }
 /**
  * Start base-url-proxy.mjs in front of `door`; calls `done` exactly once with its
@@ -333,7 +406,7 @@ export interface BaseUrlProxyOptions {
  * script is the same case (node exits 1 before READY). The proxy holds no secret (auth headers
  * pass through it), exits with this process, and is killed on exit.
  */
-export declare function startBaseUrlProxy(door: string, done: (baseUrl: string | null) => void, opts?: BaseUrlProxyOptions): void;
+export declare function startBaseUrlProxy(door: string, done: (baseUrl: string | null, recordStatePath?: string) => void, opts?: BaseUrlProxyOptions): void;
 /**
  * The three secret lines the Remote Control proxy reads on stdin (anthropic, mnemom, openai). The
  * Mnemom key rides line 2 on BOTH auth modes when the launch has one — the proxy forwards it as