@mnemom/mnemom 0.17.32 → 0.17.34-next.1

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

@@ -43,9 +43,15 @@ export interface RenderedLinePreview {
     coverage?: string;
     kind: string;
 }
-/** The aip `renderLines` contract, injected (not yet published). */
+/**
+ * The aip `renderLines` contract, injected. Resolves to the lines the card may show; REJECTS
+ * (with the renderer's reasons) when the card is not verifiable or breaks claim-lint, in which
+ * case no link is printed. `period` asks for the period-card surface (reverts always shown).
+ */
 export interface LineRenderer {
-    renderLines(card: unknown): RenderedLinePreview[];
+    renderLines(card: unknown, opts?: {
+        period?: boolean;
+    }): RenderedLinePreview[] | Promise<RenderedLinePreview[]>;
 }
 export interface StatementSource {
     listLines(): Promise<CandidateLine[]>;
@@ -56,6 +62,11 @@ export interface CardIssuer {
 }
 export interface AgentShareDeps {
     source: StatementSource;
+    /**
+     * Optional claim-lint screen (aip `lintRendering`) run on each candidate before it is
+     * offered; returns a reason when the line must not be shared. Word lists live in aip only.
+     */
+    screen?: (line: SharedCardLine) => Promise<string | null> | string | null;
     issuer: CardIssuer;
     renderer: LineRenderer;
     /** Interactive picker: returns the chosen line ids. */
@@ -66,6 +77,8 @@ export interface AgentShareDeps {
     err: (line: string) => void;
 }
 export interface AgentShareFlags {
+    /** Period card: every offered revert line is included, and a card without one is refused. */
+    period?: boolean;
     lines?: string;
     list?: boolean;
     json?: boolean;

package/dist/commands/agent-share.js

@@ -17,6 +17,7 @@
 import { createInterface } from "node:readline/promises";
 import { getWebsiteUrl } from "../lib/config.js";
 import { fmt } from "../lib/format.js";
+import { aipLineRenderer, aipLineScreen } from "./agent-share-render.js";
 export const AGENT_SHARE_ENV = "MNEMOM_AGENT_SHARE";
 export function agentShareEnabled(env = process.env) {
     return env[AGENT_SHARE_ENV] === "1";
@@ -132,10 +133,16 @@ export async function agentShareCommand(flags, deps, env = process.env) {
     const refused = [];
     for (const c of candidates) {
         const r = refuseReason(c);
-        if (r)
+        if (r) {
             refused.push(r);
+            continue;
+        }
+        const shared = toSharedLine(c);
+        const lint = deps.screen ? await deps.screen(shared) : null;
+        if (lint)
+            refused.push({ id: shared.id, reason: "estimate", detail: lint });
         else
-            offered.push(toSharedLine(c));
+            offered.push(shared);
     }
     if (flags.list) {
         if (flags.json) {
@@ -175,6 +182,15 @@ export async function agentShareCommand(flags, deps, env = process.env) {
         deps.err(fmt.error("No lines picked."));
         return 1;
     }
+    if (flags.period) {
+        for (const l of offered)
+            if (l.kind === "revert" && !ids.includes(l.id))
+                ids.push(l.id);
+        if (!offered.some((l) => l.kind === "revert")) {
+            deps.err(fmt.error("A period card always shows reverts, and none are available to share."));
+            return 1;
+        }
+    }
     const chosen = [];
     for (const id of ids) {
         const r = refused.find((x) => x.id === id);
@@ -202,13 +218,22 @@ export async function agentShareCommand(flags, deps, env = process.env) {
         deps.err(fmt.error(`Refusing to share: ${problem}.`));
         return 1;
     }
+    // The renderer is the gate: nothing is linked unless aip renders the card (verified, lint clean).
+    let rendered;
+    try {
+        rendered = await deps.renderer.renderLines(card, { period: flags.period === true });
+    }
+    catch (error) {
+        deps.err(fmt.error(`Refusing to share: ${error.message}.`));
+        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)) {
+    for (const r of rendered) {
         deps.out(`  ${r.text}${r.coverage ? ` (${r.coverage})` : ""}`);
     }
     deps.out("");
@@ -224,12 +249,8 @@ const notConnected = () => {
 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,
-        })),
-    },
+    renderer: aipLineRenderer(undefined),
+    screen: aipLineScreen,
     pick: async (lines) => {
         const rl = createInterface({ input: process.stdin, output: process.stderr });
         try {

package/dist/commands/agent.d.ts

@@ -25,6 +25,8 @@
  * line, or the proxy's stdin under RC). It is never logged, printed, or passed as
  * an argv value.
  */
+import { type ChildProcess } from "node:child_process";
+import { type SessionKeyDeps, type SessionKeyMintArgs, type SessionKeyRenewal } from "../lib/session-key.js";
 import { type MnemomKeyDeps } from "../lib/subscription-login.js";
 import { type SessionRecord } from "../lib/agent-ledger.js";
 import { type ExperimentalId } from "../lib/experimental.js";
@@ -417,21 +419,49 @@ export interface BaseUrlProxyOptions {
  */
 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
- * x-mnemom-api-key either way; a subscription launch always has one, an api-key launch has one
- * when this machine stores one or the launch pins. Never logged.
+ * The four lines the Remote Control proxy reads on stdin (anthropic, mnemom, openai, proxy
+ * credential). The Mnemom key rides line 2 on BOTH auth modes when the launch has one — the proxy
+ * forwards it as x-mnemom-api-key either way; a subscription launch always has one, an api-key
+ * launch has one when this machine stores one or the launch pins. Line 4 is this session's proxy
+ * credential ({@link newRcProxyCredential}). Never logged.
  */
 export declare function rcProxyStdin(ctx: {
     anthropicKey?: string;
     mnemomKey?: string;
+    proxyCredential: string;
 }): string;
+/**
+ * MNE-9233: a fresh per-session credential for the Remote Control proxy. The proxy injects the
+ * owner's keys and its loopback port is reachable by every local process, so it serves only a
+ * caller that presents this value as `Proxy-Authorization: Basic` (rc-proxy.mjs). 32 random bytes,
+ * hex: URL-safe in the HTTPS_PROXY userinfo without escaping.
+ */
+export declare function newRcProxyCredential(): string;
+/**
+ * The HTTPS_PROXY value for the Remote Control child: the proxy's loopback port, with this
+ * session's credential as the userinfo. Claude Code sends it as `Proxy-Authorization` on CONNECT
+ * and on absolute-form requests. The user name must match rc-proxy.mjs's PROXY_USER.
+ */
+export declare function rcProxyUrl(port: string, proxyCredential: string): string;
 /**
  * The agent id a launch pins, or undefined for a name launch: `--agent` when it is a full
  * `mnm-<uuid>` (any case), else launcher.toml `agent_id` (only when no `--agent` was given —
  * selectLaunchAgent). A truncated/garbled `mnm-…` throws instead of becoming a name.
  */
 export declare function resolveLaunchPin(options: Pick<AgentOptions, "agent" | "agentId">): string | undefined;
+/** The longest line the proxy sends the launcher (`remint <key id>`) is far shorter than this. */
+export declare const RC_CONTROL_LINE_MAX = 1024;
+/**
+ * Renew the Remote Control proxy's session key over its control pipe (fd 3; rc-proxy.mjs SESSION
+ * KEY RENEWAL): a `key <id> <expires> <key>` line before each expiry, a `remint <id>` line from the
+ * proxy when the gateway rejects its key, answered with a new key or `key-failed`. Renewal events
+ * go to the proxy log (the terminal belongs to Claude Code by then), as key ids and expiry times.
+ */
+export declare function startRcSessionKeyRenewal(proxy: Pick<ChildProcess, "stdio">, proxyLog: string, initial: {
+    keyId: string;
+    expiresAt: string;
+    mintArgs: SessionKeyMintArgs;
+}, makeDeps?: (say: (line: string) => void) => SessionKeyDeps): SessionKeyRenewal | undefined;
 /**
  * Locates the `handoff` MCP server (src/mcp/handoff-server.mjs in dev, dist/mcp/handoff-server.mjs
  * once built — a raw, uncompiled `.mjs` file that `copy-assets.mjs` copies verbatim, exactly like

package/dist/commands/agent.js

@@ -26,8 +26,8 @@
  * an argv value.
  */
 import { spawn, spawnSync } from "node:child_process";
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, renameSync, } from "node:fs";
-import { randomUUID } from "node:crypto";
+import { appendFileSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, renameSync, } from "node:fs";
+import { randomBytes, randomUUID } from "node:crypto";
 import { tmpdir, homedir, hostname } from "node:os";
 import { basename, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -39,7 +39,7 @@ import { ALLOW_AUTOCOMPACT_OFF_ENV, dropAutocompactOffEnv, hasOwnSettingsFlag, m
 import { getApiUrl, getGatewayUrl, MNEMOM_DIR } from "../lib/config.js";
 import { createApiKey } from "../lib/api.js";
 import { recordOrgFor } from "../lib/record-org.js";
-import { defaultSessionKeyDeps, mintSessionGatewayKey, revokeSessionGatewayKey, } from "../lib/session-key.js";
+import { defaultSessionKeyDeps, mintSessionGatewayKey, revokeSessionGatewayKey, startSessionKeyRenewal, } from "../lib/session-key.js";
 import { MNEMOM_KEY_STORE_FIELD, resolveAgentAuth, sayRetiredConsoleNotice, readMnemomKey, resolveSubscriptionMnemomKey, subscriptionChildEnv, subscriptionShape, } from "../lib/subscription-login.js";
 import { LEDGER_FILE, appendSessionRecord, findResumeCandidate, readSessionRecords, resolveRetentionDays, resumedContextProfile, toLedgerContract, } from "../lib/agent-ledger.js";
 import { isLoggedIn } from "../lib/auth.js";
@@ -612,6 +612,8 @@ export async function agentCommand(scenarioArg, options = {}) {
     // org is the key owner's personal org, where the agent does not exist, so the API answers 404
     // and the launch would fail closed (door1-path run 40400479127). Same read as Record's.
     let sessionKeyId;
+    // What a Remote Control launch needs to re-mint before the 24h expiry (startSessionKeyRenewal).
+    let sessionKeyRenewal;
     // One read of the served agent's org serves the mint and Record; each says why in its own
     // words when the read fails and the account org is used instead.
     let servedOrg;
@@ -632,13 +634,15 @@ export async function agentCommand(scenarioArg, options = {}) {
                 say(fmt.warn(`mnemom agent: could not read ${servedAgentId}'s org (${o.fallback}); minting the session key under ${account.orgId}.`));
             mintOrgId = o.orgId;
         }
-        const minted = await mintSessionGatewayKey(defaultSessionKeyDeps(say), {
+        const mintArgs = {
             agentId: servedAgentId,
             orgId: mintOrgId,
             sessionId: cc.id ?? undefined,
-        });
+        };
+        const minted = await mintSessionGatewayKey(defaultSessionKeyDeps(say), mintArgs);
         mnemomKey = minted.key;
         sessionKeyId = minted.keyId;
+        sessionKeyRenewal = { expiresAt: minted.expiresAt, mintArgs };
     }
     // ── 1M context window by default ── the model this launch runs on gets `[1m]` when it has no
     // window suffix and supports 1M (resolveWindowModel); an explicit choice — the
@@ -828,6 +832,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         yolo,
         ccSessionId,
         sessionKeyId,
+        sessionKeyRenewal,
     });
 }
 // ───────────────────────────────────────────────────────────────────────────
@@ -1620,13 +1625,31 @@ export function startBaseUrlProxy(door, done, opts = {}) {
 // Remote Control launch (terminal RC + headless server) — behind the bundled proxy
 // ───────────────────────────────────────────────────────────────────────────
 /**
- * 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
- * x-mnemom-api-key either way; a subscription launch always has one, an api-key launch has one
- * when this machine stores one or the launch pins. Never logged.
+ * The four lines the Remote Control proxy reads on stdin (anthropic, mnemom, openai, proxy
+ * credential). The Mnemom key rides line 2 on BOTH auth modes when the launch has one — the proxy
+ * forwards it as x-mnemom-api-key either way; a subscription launch always has one, an api-key
+ * launch has one when this machine stores one or the launch pins. Line 4 is this session's proxy
+ * credential ({@link newRcProxyCredential}). Never logged.
  */
 export function rcProxyStdin(ctx) {
-    return `${ctx.anthropicKey ?? ""}\n${ctx.mnemomKey ?? ""}\n\n`;
+    return `${ctx.anthropicKey ?? ""}\n${ctx.mnemomKey ?? ""}\n\n${ctx.proxyCredential}\n`;
+}
+/**
+ * MNE-9233: a fresh per-session credential for the Remote Control proxy. The proxy injects the
+ * owner's keys and its loopback port is reachable by every local process, so it serves only a
+ * caller that presents this value as `Proxy-Authorization: Basic` (rc-proxy.mjs). 32 random bytes,
+ * hex: URL-safe in the HTTPS_PROXY userinfo without escaping.
+ */
+export function newRcProxyCredential() {
+    return randomBytes(32).toString("hex");
+}
+/**
+ * The HTTPS_PROXY value for the Remote Control child: the proxy's loopback port, with this
+ * session's credential as the userinfo. Claude Code sends it as `Proxy-Authorization` on CONNECT
+ * and on absolute-form requests. The user name must match rc-proxy.mjs's PROXY_USER.
+ */
+export function rcProxyUrl(port, proxyCredential) {
+    return `http://mnemom:${proxyCredential}@127.0.0.1:${port}`;
 }
 /**
  * The agent id a launch pins, or undefined for a name launch: `--agent` when it is a full
@@ -1652,6 +1675,8 @@ function launchRemoteControl(ctx) {
         }
     }
     const proxyScript = resolveProxyScript();
+    // MNE-9233: only the child launched below may use this session's proxy (stdin line 4 + HTTPS_PROXY).
+    const proxyCredential = newRcProxyCredential();
     const rcDir = mkdtempSync(join(rcStateRoot(), "mnemom-code-rc."));
     writeFileSync(join(rcDir, "owner.pid"), `${process.pid}\n`, { mode: 0o600 }); // rc-state.mjs sweep
     const proxyLog = process.env.MNEMOM_AGENT_RC_PROXY_LOG || join(rcDir, "proxy.log");
@@ -1668,13 +1693,28 @@ function launchRemoteControl(ctx) {
         MNEMOM_AGENT_RC_PARENT_PID: String(process.pid),
         MNEMOM_AGENT_RC_AUTH: ctx.anthropicKey ? "api-key" : "subscription",
     };
+    // The minted key expires after 24h and an RC seat outlives that: renew it over a control pipe
+    // (fd 3) — the new key never touches argv, env or disk. Only its id and expiry ride in the env.
+    const renewing = Boolean(ctx.sessionKeyId && ctx.sessionKeyRenewal && ctx.mnemomKey);
+    if (renewing) {
+        proxyEnv.MNEMOM_AGENT_RC_CONTROL_FD = "3";
+        proxyEnv.MNEMOM_AGENT_RC_MNEMOM_KEY_ID = ctx.sessionKeyId;
+        proxyEnv.MNEMOM_AGENT_RC_MNEMOM_KEY_EXPIRES_AT = ctx.sessionKeyRenewal?.expiresAt;
+    }
     // MNE-8245 defense-in-depth: the proxy gets the session's (minted) Mnemom key on stdin only
     // and reads none of the owner's own Mnemom credential vars, so they never ride into its env.
     stripOwnerCredentialEnv(proxyEnv);
     const proxy = spawn("node", [proxyScript], {
         env: proxyEnv,
-        stdio: ["pipe", "pipe", "inherit"],
+        stdio: ["pipe", "pipe", "inherit", renewing ? "pipe" : "ignore"],
     });
+    const renewal = renewing
+        ? startRcSessionKeyRenewal(proxy, proxyLog, {
+            keyId: ctx.sessionKeyId,
+            expiresAt: ctx.sessionKeyRenewal?.expiresAt,
+            mintArgs: ctx.sessionKeyRenewal?.mintArgs,
+        })
+        : undefined;
     let stopped = false;
     const stopProxyAndTempDir = () => {
         if (!proxy.killed) {
@@ -1701,9 +1741,12 @@ function launchRemoteControl(ctx) {
         if (stopped)
             return;
         stopped = true;
+        renewal?.stop();
         stopProxyAndTempDir();
-        if (ctx.sessionKeyId) {
-            await revokeSessionGatewayKey(defaultSessionKeyDeps(say), ctx.sessionKeyId);
+        // After a renewal the proxy holds a newer key than the one minted at launch: revoke that one.
+        const keyId = renewal?.currentKeyId() ?? ctx.sessionKeyId;
+        if (keyId) {
+            await revokeSessionGatewayKey(defaultSessionKeyDeps(say), keyId);
         }
     };
     // Last-resort SYNC fallback only — Node's "exit" handlers cannot await, so this branch never
@@ -1716,11 +1759,12 @@ function launchRemoteControl(ctx) {
         if (stopped)
             return;
         stopped = true;
+        renewal?.stop();
         stopProxyAndTempDir();
     });
-    // Secrets on stdin — three lines (anthropic, mnemom, openai). An api-key launch sends the
-    // Anthropic key, plus this machine's Mnemom key when it has one (the key principal; always
-    // with a pin); a subscription launch sends the Mnemom key only (the identity anchor — the
+    // Secrets on stdin — four lines (anthropic, mnemom, openai, proxy credential). An api-key launch
+    // sends the Anthropic key, plus this machine's Mnemom key when it has one (the key principal;
+    // always with a pin); a subscription launch sends the Mnemom key only (the identity anchor — the
     // user's OAuth bearer is what pays). openai is always empty on this Anthropic-only door.
     // A proxy that exits before reading them turns this write into an EPIPE; that is
     // not a failure of its own — the exited-before-READY check below refuses the
@@ -1731,7 +1775,7 @@ function launchRemoteControl(ctx) {
         say(`mnemom agent: could not hand the secrets to the Remote Control proxy: ${err.message}`);
         void onExit().finally(() => process.exit(1));
     });
-    proxy.stdin?.end(rcProxyStdin(ctx));
+    proxy.stdin?.end(rcProxyStdin({ ...ctx, proxyCredential }));
     let stdoutBuf = "";
     const start = Date.now();
     const tryStart = () => {
@@ -1748,7 +1792,7 @@ function launchRemoteControl(ctx) {
                 void onExit().finally(() => process.exit(1));
                 return;
             }
-            spawnRcCli({ ...ctx, port, ca, onExit });
+            spawnRcCli({ ...ctx, port, ca, proxyCredential, onExit });
             return;
         }
         if (proxy.exitCode !== null) {
@@ -1773,6 +1817,58 @@ function launchRemoteControl(ctx) {
     });
     tryStart();
 }
+/** The longest line the proxy sends the launcher (`remint <key id>`) is far shorter than this. */
+export const RC_CONTROL_LINE_MAX = 1024;
+/**
+ * Renew the Remote Control proxy's session key over its control pipe (fd 3; rc-proxy.mjs SESSION
+ * KEY RENEWAL): a `key <id> <expires> <key>` line before each expiry, a `remint <id>` line from the
+ * proxy when the gateway rejects its key, answered with a new key or `key-failed`. Renewal events
+ * go to the proxy log (the terminal belongs to Claude Code by then), as key ids and expiry times.
+ */
+export function startRcSessionKeyRenewal(proxy, proxyLog, initial, makeDeps = defaultSessionKeyDeps) {
+    const control = proxy.stdio?.[3];
+    if (!control)
+        return undefined;
+    const logLine = (line) => {
+        try {
+            appendFileSync(proxyLog, `${new Date().toISOString()} launcher: ${line}\n`);
+        }
+        catch {
+            /* best effort: the log dir may be gone at exit */
+        }
+    };
+    control.on("error", () => {
+        /* the proxy exited: the next delivery fails and is logged */
+    });
+    const renewal = startSessionKeyRenewal({
+        deps: makeDeps(logLine),
+        mintArgs: initial.mintArgs,
+        initial: { keyId: initial.keyId, expiresAt: initial.expiresAt },
+        deliver: (minted) => {
+            if (control.destroyed || !control.writable)
+                throw new Error("the proxy's control pipe is closed");
+            control.write(`key ${minted.keyId} ${minted.expiresAt} ${minted.key}\n`);
+        },
+        refuse: (reason) => {
+            if (!control.destroyed && control.writable)
+                control.write(`key-failed ${reason}\n`);
+        },
+    });
+    let buf = "";
+    control.on("data", (chunk) => {
+        buf += chunk.toString("utf8");
+        let i;
+        while ((i = buf.indexOf("\n")) >= 0) {
+            const [cmd, keyId] = buf.slice(0, i).split(" ");
+            buf = buf.slice(i + 1);
+            if (cmd === "remint")
+                void renewal.renew("rejected", keyId);
+        }
+        if (buf.length > RC_CONTROL_LINE_MAX)
+            buf = ""; // a runaway line, never a real request
+    });
+    return renewal;
+}
 function spawnRcCli(ctx) {
     // Session name for the claude.ai session list: "<agent>-<scenario>", unless
     // the caller passed their own name after `--` (`--name x`, `--name=x`, `-n x`; lifted out here).
@@ -1805,8 +1901,8 @@ function spawnRcCli(ctx) {
     // env. The RC gate forwards the Mnemom identity via the proxy's own auth plane, never from
     // this child's env, so there is no legitimate use for these vars here either.
     stripOwnerCredentialEnv(childEnv);
-    childEnv.HTTPS_PROXY = `http://127.0.0.1:${ctx.port}`;
-    childEnv.https_proxy = `http://127.0.0.1:${ctx.port}`;
+    childEnv.HTTPS_PROXY = rcProxyUrl(ctx.port, ctx.proxyCredential);
+    childEnv.https_proxy = childEnv.HTTPS_PROXY;
     childEnv.NODE_EXTRA_CA_CERTS = ctx.ca;
     childEnv[SESSION_NAME_ENV] = rcName;
     // Autocompact guard (lib/autocompact-guard.ts). The interactive shape gets the --settings layer

package/dist/commands/protection.js

@@ -15,7 +15,7 @@ const OP_SEVERITIES = ["low", "medium", "high", "critical"];
 // Per ADR-037 Decision 4: deny public LLM endpoints + public DNS providers,
 // and the any-host CIDRs, at write time.
 // T8-4 (2026-05-19) extended the corpus per
-// `safe-house-hardening/audit/deny-list-completeness.md`: added emerging
+// `safe-house-hardening/audits/deny-list-completeness.md`: added emerging
 // LLM providers (Replicate, Together, Anyscale, Fireworks, xAI,
 // Perplexity, DeepSeek) and three reserved IP ranges (link-local v4/v6
 // + multicast v4).

package/dist/commands/scan.d.ts

@@ -0,0 +1,97 @@
+/**
+ * `mnemom scan`: a read-only local scan of GitHub PR metadata. Runs entirely on this machine; nothing is
+ * uploaded in this build. The share-level prompt gates what a later upload step may send, and the chosen
+ * payload is printed so the user sees exactly what would leave. Pure logic is exported so each reject
+ * arm is unit-testable without Commander (same pattern as commands/usage.ts).
+ */
+import { type GitHubCredential } from "../lib/scan/credential.js";
+import { type ScanDeps } from "../lib/scan/scan.js";
+import { type AnthropicUsageDeps } from "../lib/scan/spend/anthropic-usage.js";
+import { type RecordDeps, type RecordOutcome } from "../lib/scan/record.js";
+import { type ReportEmailDeps } from "../lib/scan/report-email.js";
+import { type ReportRecipients } from "../lib/scan/share.js";
+export interface ScanCommandOptions {
+    repos: string[];
+    period?: {
+        start: string;
+        end: string;
+    };
+    share?: string;
+    /** Report recipient. Required unless the runner is the CTO (asked when omitted). */
+    ctoEmail?: string;
+    /** Tier 2: the CTO's own monthly figure, as typed. Needs MNEMOM_ORG_SCAN_MODE=true. */
+    monthlySpend?: string;
+    /** Tier 2 without a figure on the command line: ask for one on the terminal. */
+    noAnthropicUsage?: boolean;
+    /** Tier 1: ask for the Anthropic admin key on the terminal (masked). Otherwise ANTHROPIC_ADMIN_KEY is used if set. */
+    anthropicAdminKey?: boolean;
+    /** Tier 1 result, when the caller already has it (test seam; set from the Anthropic reads otherwise). */
+    anthropicUsageUsd?: number;
+    anthropicOver200kShare?: number | null;
+    /** Test seam: the fetch behind the two Anthropic reads. */
+    anthropicDeps?: AnthropicUsageDeps;
+    /**
+     * The org the report is emailed for; inferred from the signed-in user's single non-personal org when
+     * omitted (see resolveScanOrg). The Record totals preview (MNEMOM_ORG_SCAN_MODE=true) reads ONLY an
+     * org passed explicitly here, never an inferred one: a guess could read the wrong org.
+     */
+    org?: string;
+    /** Test seam: the Record read. */
+    recordDeps?: RecordDeps;
+    /** Test seam: the report-email POST. */
+    emailDeps?: ReportEmailDeps;
+    /** Test seam: the signed-in user's orgs, used to infer --org when it is omitted. */
+    listOrgs?: () => Promise<Array<{
+        org_id: string;
+        name?: string;
+        is_personal?: boolean;
+    }>>;
+    /** Test seams. */
+    isTty?: boolean;
+    env?: NodeJS.ProcessEnv;
+    runnerEmail?: string;
+    credential?: GitHubCredential;
+    deps?: Partial<ScanDeps>;
+    now?: () => number;
+}
+/** Parses repeated/comma-separated `--repo owner/name`. Returns null on any invalid slug. */
+export declare function parseRepoFlags(raw: string[] | undefined): string[] | null;
+export declare const isEmail: (v: unknown) => v is string;
+/** The runner's email (mnemom login, else asked) and the CTO's (flag, else "are you the CTO?"). */
+export declare function resolveRecipients(o: {
+    runnerEmail?: string;
+    ctoEmail?: string;
+}): Promise<ReportRecipients>;
+/** The CTO's figure in USD, or null for none. Throws fixed text only; the input is never echoed. */
+export declare function resolveSelfReportedSpend(o: ScanCommandOptions): Promise<number | null>;
+export declare const NO_ADMIN_KEY_TERMINAL_MSG = "Set ANTHROPIC_ADMIN_KEY (there is no terminal to ask on).";
+export declare const TIER1_FALLBACK_NOTE = "Tier 1 skipped: falling back to the next tier.";
+/**
+ * Tier 1: read measured usage with the CTO's Anthropic admin key, locally. The key comes from
+ * ANTHROPIC_ADMIN_KEY or a masked prompt (--anthropic-admin-key; never a value on argv), lives only in this
+ * call, and goes only to api.anthropic.com. Returns null for "no key" and for every failure, after printing a
+ * fixed sentence: the key, the thrown value and the response never reach the terminal. The caller then falls
+ * back to tier 2, then tier 3.
+ */
+export declare function resolveMeasuredUsage(o: ScanCommandOptions, period: {
+    start: string;
+    end: string;
+}): Promise<{
+    usd: number;
+    over200kShare: number | null;
+} | null>;
+/**
+ * --org is optional only because it can be inferred: the report is emailed on every scan, so the scan
+ * needs an org. Inference uses the signed-in user's own memberships (GET /v1/orgs, personal org
+ * excluded): exactly one org is used; none, several, or a failed read stops the scan loudly BEFORE any
+ * scan work, naming the fix. It never guesses between orgs and never skips the email.
+ */
+export declare function resolveScanOrg(o: ScanCommandOptions): Promise<string>;
+export declare const INVALID_ORG_MSG = "--org must be an org id like org-1a2b3c4d.";
+/**
+ * The Record read for the preview: null when the flag gate is off (no read, no output, as before).
+ * With the gate on and no --org it is a note, not a guess. 404 becomes a note; 401/403 throw
+ * RecordAuthError (fail closed); every other failure becomes a fixed note. Nothing is stored.
+ */
+export declare function resolveRecordOutcome(o: ScanCommandOptions): Promise<RecordOutcome | "no_org" | null>;
+export declare function scanCommand(o: ScanCommandOptions): Promise<void>;