@hasna/recordings 0.2.13 → 0.3.1

package/dist/lib/capture-probe.d.ts

@@ -0,0 +1,216 @@
+import type { RecordingsConfig } from "../types/index.js";
+import { RECORDINGS_BUNDLE_IDENTIFIER } from "./macos-bundle.js";
+/**
+ * Why this module exists.
+ *
+ * On macOS a process that has NOT been granted the Microphone TCC permission
+ * does not fail when it opens an input device. CoreAudio hands it
+ * ZERO-FILLED buffers instead. `rec` therefore exits 0 and writes a
+ * correctly-sized, structurally valid WAV file that contains digital silence.
+ *
+ * Observed on a fleet Mac (macOS 26) with Microphone = not_determined:
+ *   $ rec -q -c 1 -r 16000 /tmp/probe.wav trim 0 1   # exit 0, 64080 bytes
+ *   $ sox /tmp/probe.wav -n stat                      # Maximum amplitude: 0.000000
+ *
+ * Consequence: exit status, file existence and file size prove NOTHING about
+ * whether capture works. The only sound evidence is signal amplitude. Every
+ * capture check in this package must therefore assert on amplitude.
+ */
+/** Peak amplitude of a 16-bit PCM WAV, normalised to 0..1. */
+export interface WavPeak {
+    samples: number;
+    peak: number;
+}
+/**
+ * Read the peak amplitude of a 16-bit PCM WAV file.
+ *
+ * Walks the RIFF chunk list rather than assuming a fixed 44-byte header, since
+ * sox emits a LIST/INFO chunk ahead of `data` for some output formats.
+ *
+ * The whole list is scanned before anything is decoded. Stopping at `data`
+ * looked like a harmless optimisation and was not: RIFF does not mandate chunk
+ * order, so a file with `data` ahead of `fmt ` left the format unread and fell
+ * back to "assume 16-bit PCM" — which silently reinterpreted 32-bit float
+ * samples as integers and reported a plausible, wrong peak. A format this
+ * function cannot decode must raise, never guess.
+ *
+ * KNOWN LIMIT, stated rather than implied. Two of the robustness measures above do NOT compose:
+ * a file with `data` ahead of `fmt ` AND an over-declared `data` size (a truncated capture) has
+ * no recoverable format. The declared size is a lie, so the bytes following the data body are
+ * indistinguishable from audio payload without pattern-matching for a `fmt ` signature — and
+ * guessing the format is precisely what this function refuses to do. It raises instead. The chunk
+ * walk is clamped to the file length so the scan cannot run off the end, which is as far as
+ * ground truth reaches. Not reachable from sox output; documented because the two guarantees read
+ * as if they compose and they do not.
+ */
+export declare function readWavPeak(filepath: string): WavPeak;
+export interface CaptureProbeResult {
+    ok: boolean;
+    tool: string | null;
+    seconds: number;
+    samples: number;
+    /** Normalised 0..1 peak amplitude. Exactly 0 means no signal reached us. */
+    peak: number;
+    /**
+     * `true` when a capture happened and its amplitude was at or below
+     * `SILENCE_PEAK_THRESHOLD`; `false` when a capture happened and carried signal;
+     * **`null` when no amplitude was measured at all**.
+     *
+     * The null state is the point. This used to be a plain `boolean` defaulted to `true` on the
+     * shared `base` object, so every early return inherited it — a missing `rec` binary reported
+     * `silent=true samples=0 peak=0`, and a `--json` consumer reading `capture_probe.silent`
+     * concluded "the microphone delivered digital silence" when no capture was ever attempted.
+     * That is the same conflation of "could not measure" with "measured a bad value" that this
+     * module exists to remove, reproduced inside the module itself.
+     */
+    silent: boolean | null;
+    message: string;
+}
+export declare const DEFAULT_PROBE_SECONDS = 1;
+export declare const MAX_PROBE_SECONDS = 60;
+export declare const DEFAULT_RECORD_EXECUTABLE = "rec";
+/**
+ * Amplitude at or below which a capture counts as no signal.
+ *
+ * Not exactly zero. A device can emit a trickle of dither or preamp noise while
+ * delivering nothing, and `peak === 0` would call that a pass. One LSB is
+ * 0.0000305; this threshold is ~33 LSB (32.77), still 40x below the 0.040466 peak
+ * of a real quiet dictation measured on a fleet Mac, so genuine speech passes with
+ * wide margin while a dead input does not.
+ *
+ * The multiplier read "80x" until review recomputed it: 0.040466 / 0.001 is 40.5,
+ * not 80. The threshold value itself measures correctly — verified at the boundary,
+ * int16 peak 32 fails and 34 passes — so only the stated margin was wrong. Corrected
+ * rather than left, because an overstated margin inside the justification for a
+ * threshold is the same defect class this module exists to remove.
+ */
+export declare const SILENCE_PEAK_THRESHOLD = 0.001;
+/**
+ * Actually capture from the microphone and assert that signal arrived.
+ *
+ * This records for `seconds` (default 1) and fails when the result carries no
+ * signal, which on macOS is the signature of a missing Microphone grant.
+ *
+ * `executable` is injected rather than read from the environment. It used to be
+ * `process.env.RECORDINGS_TEST_RECORD_EXECUTABLE || "rec"` — a test hook in the
+ * shipped path, letting an env var choose which program this runs, in a package
+ * whose own diagnostics exist because invisible inherited env vars caused an
+ * outage. The repo idiom is injection (see cli/macos-permissions.ts).
+ */
+export declare function probeMicrophoneCapture(config: RecordingsConfig, options?: {
+    seconds?: number;
+    executable?: string;
+    timeoutMs?: number;
+}): CaptureProbeResult;
+export interface CaptureProbeSubject {
+    /** True when this process is known to have no GUI session to be prompted in. */
+    headless: boolean;
+    /**
+     * False when the responsible process could not be identified. An unidentified
+     * subject must not be narrated as if it were a local terminal.
+     */
+    subject_known: boolean;
+    /** What macOS will attribute the probe's microphone access to. */
+    subject: string;
+    note: string;
+}
+/**
+ * Name whose Microphone grant this probe actually exercises.
+ *
+ * macOS attributes microphone access to the RESPONSIBLE process — for a CLI that
+ * is the terminal application (or sshd), never Recordings.app. So a silent probe
+ * means "the thing running this command has no grant", which is a different
+ * finding, with a different fix, from "the app has no grant". Reporting the one
+ * as the other is how a diagnostic sends someone to the wrong settings pane.
+ * The user TCC db bears this out: it tracks `tmux` and `bun` as separate clients
+ * with their own grants, independent of any app bundle.
+ *
+ * Detection is deliberately three-valued. An earlier version inferred "local
+ * terminal" from the absence of SSH variables, which is wrong in the environment
+ * this org actually drives these machines from: tmux snapshots the environment
+ * when a pane is created and never refreshes it, so inside a pane SSH_CONNECTION
+ * and TERM_PROGRAM are both absent even though the session is remote. `sudo`
+ * (env_reset), launchd and cron produce the same false negative. When the
+ * subject cannot be identified, say so rather than emit the reassuring note.
+ */
+export declare function captureProbeSubject(env?: NodeJS.ProcessEnv | Record<string, string | undefined>, options?: {
+    platform?: string;
+    hasTty?: boolean;
+}): CaptureProbeSubject;
+export interface MicrophoneGrantInstruction {
+    /** The bundle that must receive the grant, or null when none was found. */
+    bundle_path: string | null;
+    bundle_identifier: string;
+    /** Every Recordings.app on disk — more than one makes the grant ambiguous. */
+    candidate_bundle_paths: string[];
+    /** Ordered steps, already naming the pane, the section and the bundle. */
+    steps: string[];
+}
+export { RECORDINGS_BUNDLE_IDENTIFIER };
+/**
+ * Value the TCC reader returns when a database existed but could not be read.
+ *
+ * Rebase note (#24 x #25): this used to be its own literal,
+ * `"unreadable_no_full_disk_access"`, because this branch also owned the reader that produced
+ * it. #24 replaced that reader with `resolveTccGrant()` in `cli/macos-permissions.ts`, which
+ * reports the same condition as `"undetermined_tcc_database_unreadable"`. Two different strings
+ * for one condition made every `=== TCC_UNREADABLE_STATE` comparison in the `check` renderer
+ * dead code, so a refused database read fell through to the red "denied" branch and printed
+ * grant instructions for a permission that may already have been granted — the exact false
+ * statement this module exists to remove.
+ *
+ * The name is kept because it is part of the package's public surface; only the value moves, to
+ * the single definition both sides now read.
+ */
+export declare const TCC_UNREADABLE_STATE = "undetermined_tcc_database_unreadable";
+/**
+ * Has the app ever asked the user for this permission?
+ *
+ * Three-valued on purpose, and that is the whole point. The previous boolean
+ * collapsed "I could not read the database" into "it never asked", so on a box
+ * where TCC was unreadable — every tmux pane on the affected machine, because it had no
+ * Full Disk Access — the CLI asserted "the app has never requested microphone
+ * access (no TCC entry exists)" while the row
+ * `kTCCServiceMicrophone|com.hasna.recordings|2` demonstrably existed. Emitting a
+ * confident false statement to the operator is the exact failure this module was
+ * written to remove, so unknown must stay unknown.
+ *
+ * `unknown` (TCC auth_value 1) counts as REQUESTED: a row exists, so the app has
+ * asked and the Settings list will contain a Recordings entry.
+ */
+export type PermissionRequestState = "requested" | "never_requested" | "unknown";
+export declare function classifyPermissionState(permissionState: string): PermissionRequestState;
+/**
+ * Build the instruction a human must follow at the keyboard, naming the exact
+ * pane, section, control and bundle.
+ *
+ * Microphone consent CANNOT be granted remotely: `tccutil` only resets entries
+ * (`tccutil reset SERVICE [BUNDLE_ID]` is its entire interface — there is no
+ * insert), and the user TCC.db is SIP-protected so it is not writable even as
+ * root. MDM/PPPC profiles can pre-approve many TCC services, but Apple restricts
+ * Camera and Microphone to deny-only by profile, so for Microphone specifically
+ * a human at the keyboard is the only path. The Settings toggle only exists once
+ * the app has asked at least once, so the request must come first.
+ * "Grant Microphone" on its own is not actionable; this spells out what to click
+ * and which binary receives it.
+ */
+export declare function microphoneGrantInstruction(options: {
+    /** Path the installer treats as canonical. */
+    installedAppPath?: string | null;
+    /** Other Recordings.app bundles found on disk (e.g. legacy install sites). */
+    otherAppPaths?: string[];
+    /**
+     * Whether the app has ever prompted. `unknown` means the TCC state could not
+     * be resolved and MUST NOT be narrated as "it never asked".
+     */
+    requestState?: PermissionRequestState;
+}): MicrophoneGrantInstruction;
+/**
+ * Guard so callers do not probe when `rec` is missing entirely — that is a
+ * different, clearer failure and deserves its own message.
+ */
+export declare function captureProbePrecondition(): Promise<{
+    ready: boolean;
+    message: string;
+}>;
+//# sourceMappingURL=capture-probe.d.ts.map

package/dist/lib/capture-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-probe.d.ts","sourceRoot":"","sources":["../../src/lib/capture-probe.ts"],"names":[],"mappings":"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"}

package/dist/lib/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAW9E,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,8BAA8B,iBAAiB,CAAC;AAC7D,eAAO,MAAM,oCAAoC,yBAAyB,CAAC;AAE3E,eAAO,MAAM,cAAc,EAAE,gBAkC5B,CAAC;AAEF,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,gBAAgB,CA2HhE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAoC9E;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAK/D;AAaD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,GAAE,kBAA2B,GACpC,kBAAkB,CAMpB;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,gBAAgB,EACxB,wBAAwB,UAAO,GAC9B,gBAAgB,CAoBlB;AA0BD,wBAAgB,UAAU,IAAI,MAAM,CAyBnC;AAqHD,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAiB5D"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAW9E,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,8BAA8B,iBAAiB,CAAC;AAC7D,eAAO,MAAM,oCAAoC,yBAAyB,CAAC;AAE3E,eAAO,MAAM,cAAc,EAAE,gBAkC5B,CAAC;AAEF,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,gBAAgB,CA2HhE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAoC9E;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAK/D;AAaD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,GAAE,kBAA2B,GACpC,kBAAkB,CAMpB;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,gBAAgB,EACxB,wBAAwB,UAAO,GAC9B,gBAAgB,CAoBlB;AA0BD,wBAAgB,UAAU,IAAI,MAAM,CAyBnC;AA2ID,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAiB5D"}

package/dist/lib/macos-bundle.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Canonical macOS bundle identity for Recordings.app.
+ *
+ * Why this module exists at all, rather than the constant living next to its first caller:
+ * three branches in the #24-#29 queue each introduced their own copy of this literal —
+ * `src/cli/macos-permissions.ts` (#24), `src/lib/capture-probe.ts` (#25) and
+ * `src/cli/macos-shortcut.ts` (#26, as `RECORDINGS_BUNDLE_ID`). None of them exists on the
+ * base commit, so the duplication is entirely a product of parallel work.
+ *
+ * The review ruling was "canonical is `RECORDINGS_BUNDLE_IDENTIFIER` in `macos-permissions.ts`".
+ * That ruling was made before #25 was known to add a copy in `src/lib`, which is the LOWER
+ * layer and re-exports the constant as part of the package's public surface via `src/index.ts`.
+ * Honouring the ruling literally would make `src/lib` import from `src/cli`, inverting the
+ * dependency direction for a published symbol. So the ruled NAME is kept and the owner moves
+ * one layer down to here; `macos-permissions.ts` re-exports it, so the ruled import path still
+ * resolves and every caller in the queue ends up on one definition.
+ *
+ * This identifier is not cosmetic. It is the TCC lookup key, the `tccutil reset` argument, and
+ * the value the app's own UserDefaults domain keys on — a bundle that does not carry it is not
+ * this app whatever it is named on disk.
+ */
+export declare const RECORDINGS_BUNDLE_IDENTIFIER = "com.hasna.recordings";
+/**
+ * The state `resolveTccGrant()` reports when a TCC database existed but could not be read.
+ *
+ * Reading the user TCC database requires Full Disk Access (`kTCCServiceSystemPolicyAllFiles`).
+ * That grant is a property of the **session's responsible process**, not of the tool you happen
+ * to be running. Measured on a fleet Mac: `bun` carries `auth_value=0` — explicitly DENIED — and a
+ * Bun script over SSH reads `TCC.db` anyway, because `sshd-keygen-wrapper` holds
+ * `SystemPolicyAllFiles auth_value=2` and its children inherit that. So "re-run from a plain ssh
+ * shell" is the right remedy for the wrong reason, and the intuitive reason is actively
+ * misleading: granting Full Disk Access to `tmux` or `bun` is not what governs the outcome.
+ *
+ * The failure this state exists for is that a reader inspecting only stdout cannot tell an empty
+ * result from a refused one, which is how the CLI came to assert "the app has never requested
+ * microphone access" on a machine where the grant row demonstrably existed.
+ *
+ * The name is deliberately cause-neutral. A non-zero `sqlite3` exit also covers a missing
+ * binary, `SQLITE_BUSY`, and a corrupt file — none of which is an authorization problem — so
+ * naming Full Disk Access in the state itself would assert a cause that was never established.
+ *
+ * Kept here, and not as a private literal in each consumer, because it is a value two modules
+ * must agree on byte-for-byte: `macos-permissions.ts` produces it and the `check` renderer
+ * compares against it to choose a yellow "cannot tell" marker over a red "denied" one. When
+ * those two strings drifted apart during the #24 x #25 rebase, the comparison silently became
+ * dead code and the renderer fell through to "denied" — telling the operator to grant a
+ * permission that was already granted.
+ */
+export declare const TCC_DATABASE_UNREADABLE_STATE = "undetermined_tcc_database_unreadable";
+//# sourceMappingURL=macos-bundle.d.ts.map

package/dist/lib/macos-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"macos-bundle.d.ts","sourceRoot":"","sources":["../../src/lib/macos-bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,4BAA4B,yBAAyB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,6BAA6B,yCAAyC,CAAC"}

package/dist/lib/persistence-probe.d.ts

@@ -0,0 +1,208 @@
+import { type Store } from "../store.js";
+import type { RecordingsConfig } from "../types/index.js";
+/**
+ * Why this module exists.
+ *
+ * A transcript is only "recorded" once it is durably stored, and this package
+ * has TWO stores behind one interface (src/store.ts): on-box SQLite and the
+ * server's `/v1` HTTP API. Which one is active is decided entirely by the
+ * environment — the presence of HASNA_RECORDINGS_API_URL +
+ * HASNA_RECORDINGS_API_KEY is itself the signal to use the API, with no
+ * variable set explicitly to make it visible.
+ *
+ * `check` never reported which store it had resolved. That blind spot is not
+ * theoretical: on an affected fleet Mac those two variables are set in the
+ * LAUNCHD USER SESSION, so every process in the session inherits them — the GUI
+ * app, its CLI helper, and any ssh shell alike. Writes go to the API while
+ * ~/.hasna/recordings/recordings.db sits frozen at the row count it held when the
+ * machine last read from that file, and the live store has since grown well past
+ * it. Two separate audits read the stale SQLite file and concluded that recording
+ * had stopped persisting. It had not; they were looking at the wrong store.
+ *
+ * Deliberately no hostname, row counts or dates here: they are live production
+ * figures and fleet topology, this repo is public, and the mechanism above is the
+ * part that has engineering value.
+ *
+ * So: naming the active store is part of proving persistence, and a persistence
+ * probe must round-trip against the ACTIVE store, never against whichever one is
+ * easier to open.
+ */
+/** The name we report when the transport came from URL+key presence alone. */
+export declare const AUTO_FLIP_MODE_SOURCE = "auto:api-url+api-key";
+/**
+ * Strip credentials out of a URL before it is printed anywhere.
+ *
+ * `toV1BaseUrl` clears the query and fragment but preserves userinfo, so a
+ * configured `https://svc:PASSWORD@host` reaches every reporter in this module
+ * intact — stdout, the `--json` payload, and two warning strings. This module
+ * exists to make the store visible; leaking a password while doing it would be a
+ * worse bug than the one it fixes.
+ *
+ * Applied at the reporting boundary rather than in `toV1BaseUrl` itself, so the
+ * URL the transport actually requests is left exactly as configured.
+ */
+export declare function safeBaseUrl(baseUrl: string | null): string | null;
+export interface ActiveStoreDescription {
+    transport: "sqlite" | "http";
+    /**
+     * What decided the transport: an env var NAME, `auto:api-url+api-key`, or
+     * `default`. Never a value — these variables hold credentials.
+     */
+    mode_source: string;
+    /** `<url>/v1` when routed to the API, else null. Carries no credential. */
+    base_url: string | null;
+    /** Path the LocalStore would use, reported whether or not it is active. */
+    local_db_path: string;
+    local_db_present: boolean;
+    /**
+     * Rows in the local SQLite file, or null when it is absent or unreadable.
+     * Only read when the file already exists: a diagnostic must not create a
+     * store, or it would invent the very divergence it is looking for.
+     */
+    local_db_recordings: number | null;
+    /**
+     * True when writes are routed to the API while a NON-EMPTY local SQLite file
+     * also exists. Both datasets then look plausible to a human, and only one is
+     * live — the exact condition that produced two wrong audits.
+     */
+    divergent: boolean;
+    warning: string | null;
+}
+/**
+ * Is an existing local store behind the current schema?
+ *
+ * Read-only, because the only other way to find out is to open it read-write,
+ * which applies the migrations — the exact side effect being checked for.
+ * Returns null when the answer cannot be established.
+ */
+export declare function localStoreIsBehindSchema(dbPath: string): boolean | null;
+/**
+ * Report which store this process would read and write, and whether a second,
+ * stale dataset is sitting next to it.
+ */
+export declare function describeActiveStore(config: RecordingsConfig, env?: NodeJS.ProcessEnv | Record<string, string | undefined>): ActiveStoreDescription;
+export interface PersistenceProbeResult {
+    /**
+     * True ONLY when a write was performed and read back. Never true for a skip.
+     *
+     * This used to be `true` on the skip path, which is how `check --probe` came to print
+     * `✓ Persistence round-trip: SKIPPED…` and exit 0 while writing, reading and deleting nothing —
+     * and because a shared API store is skipped by default, that was the DEFAULT outcome on
+     * the fleet Mac whose blind spot this probe was written to close. Read `outcome` to
+     * distinguish "declined to measure" from "measured and passed"; `ok` is exactly
+     * `outcome === "proved"`.
+     */
+    ok: boolean;
+    /**
+     * Three-valued because "I declined to measure" is not a pass and not a failure.
+     *
+     * - `proved`  — a marker was written, read back byte-identical, and cleaned up.
+     * - `failed`  — a write, read-back or cleanup step actively failed.
+     * - `skipped` — the probe refused to write to a shared API store without `allowRemoteWrite`.
+     *
+     * The exit code must key off `failed` alone; the rendered marker must distinguish all three.
+     */
+    outcome: "proved" | "failed" | "skipped";
+    /** False when the probe declined to write, e.g. to a live API store. */
+    attempted: boolean;
+    /**
+     * Whether the active store answered a read-only request, and what it said.
+     *
+     * Only meaningful on the skip path, and it exists because the skip previously made ZERO network
+     * contact: it did not establish that the store was resolvable, reachable or authenticating —
+     * only that the probe had chosen not to write. A read-only `getRecordingStats()` proves
+     * reachability plus credential acceptance without adding a row to production.
+     */
+    reachable: boolean | null;
+    transport: "sqlite" | "http";
+    base_url: string | null;
+    /** Id of the marker recording, kept for cleanup follow-up when needed. */
+    recording_id: string | null;
+    /** The written transcript was read back byte-identical. */
+    read_back: boolean;
+    /**
+     * The marker was removed AND its absence confirmed by a follow-up read. The
+     * delete call's own return value is not sufficient — see the comment below.
+     */
+    cleaned_up: boolean;
+    /** True when the probe itself brought the local SQLite store into existence. */
+    created_local_store: boolean;
+    message: string;
+}
+/**
+ * How a probe outcome must READ, separated from the colour so it can be asserted without a
+ * terminal.
+ *
+ * `PersistenceProbeResult.outcome` already documents that "the rendered marker must distinguish
+ * all three" — and nothing asserted it, so flipping the `skipped` arm of the CLI's inline ternary
+ * from `chalk.yellow("?")` to `chalk.green("✓")` put a green tick back on the word SKIPPED and
+ * survived the entire suite with a byte-identical failure set. The mapping lives here, is
+ * exhaustive, and is the only thing the CLI is allowed to key its colour off.
+ */
+export type ProbeMarkerSeverity = "pass" | "warn" | "fail";
+/** Glyph per severity. `?` for warn, because it is not a tick and not a cross. */
+export declare const PROBE_SEVERITY_GLYPHS: Record<ProbeMarkerSeverity, string>;
+/**
+ * Severity of a persistence outcome. `skipped` is `warn`, never `pass`: declining to measure is
+ * not a measurement that passed.
+ *
+ * Exhaustive on `outcome` so a fourth state has to make its own decision instead of falling into
+ * a tick by default.
+ */
+export declare function persistenceOutcomeSeverity(outcome: PersistenceProbeResult["outcome"]): ProbeMarkerSeverity;
+/**
+ * The marker the CLI prints for a persistence outcome.
+ *
+ * `paint` is injected rather than imported so the whole mapping — outcome to severity to glyph to
+ * colour — is one testable expression instead of a ternary chain inside a 2900-line command file
+ * that no test could reach.
+ */
+export declare function renderPersistenceMarker(outcome: PersistenceProbeResult["outcome"], paint: Record<ProbeMarkerSeverity, (text: string) => string>): string;
+/**
+ * Tag carried by probe rows so a leftover marker is identifiable.
+ *
+ * Do not rely on it alone to find one: the deployed 0.2.10 server ignores the
+ * `tags` filter, so `list --tags check-probe` returns everything. Full-text
+ * search on the marker prefix below does work against that server.
+ */
+export declare const PERSISTENCE_PROBE_TAG = "check-probe";
+/** Searchable prefix every probe marker carries, for recovering a leftover row. */
+export declare const PERSISTENCE_PROBE_MARKER_PREFIX = "recordings check --probe persistence round-trip";
+/**
+ * Prove the active store accepts a write, returns it, and lets it be deleted.
+ *
+ * Presence of a database file, a green `stats` call, or a row count all prove
+ * only that SOMETHING is readable. This writes a tagged marker, reads it back,
+ * compares the text, and deletes it — the same write-probe shape the native app
+ * already uses to validate its helper (RecordingsCLI.probePackagedCompanion).
+ *
+ * Scope note: this proves the store this process resolves is writable. It does
+ * not prove the macOS app resolves the same store; when the two disagree, the
+ * cause is env inheritance, which `describeActiveStore` reports on.
+ *
+ * Writing to a shared API store is NOT done by default. That store is production
+ * for every machine pointed at it, a probe row is briefly visible to concurrent
+ * readers in `stats.total` and `by_model`, and the server's idempotency ledger
+ * keeps a row per create with `ON DELETE SET NULL`, so each run leaves a
+ * permanent orphan that deleting the recording does not remove. A diagnostic may
+ * not do that to production unless the operator asks for it explicitly, so
+ * `allowRemoteWrite` must be set for the `http` transport.
+ */
+export declare function probeRecordingPersistence(options?: {
+    store?: Store;
+    now?: () => Date;
+    /** Required before this will write to a shared API store. */
+    allowRemoteWrite?: boolean;
+    /** Pre-probe existence of the local SQLite file, for honest reporting. */
+    localStoreExistedBefore?: boolean;
+    /**
+     * Required before this will migrate a LEGACY local store. Writing through
+     * the LocalStore opens the database read-write, which applies pending
+     * migrations — and this module calls migrating a legacy file "a destructive
+     * surprise" 80 lines above. It does not get to do it silently either.
+     */
+    allowLocalMigration?: boolean;
+    /** Whether the local store is behind the current schema; null = unknown. */
+    localStoreIsLegacy?: boolean | null;
+}): Promise<PersistenceProbeResult>;
+//# sourceMappingURL=persistence-probe.d.ts.map

package/dist/lib/persistence-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-probe.d.ts","sourceRoot":"","sources":["../../src/lib/persistence-probe.ts"],"names":[],"mappings":"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"}

package/dist/lib/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../src/lib/recorder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAU1D;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC;IAClD,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAoBD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAqD/D;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAa7C;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAE9C;AAwBD;;GAEG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,MAAM,CAAC,CAwCjB"}
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../src/lib/recorder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAU1D;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC;IAClD,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAoBD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAyD/D;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAa7C;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAE9C;AAwBD;;GAEG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,MAAM,CAAC,CAwCjB"}

package/dist/lib/retired-deployment-modes.d.ts

@@ -0,0 +1,24 @@
+export declare const RETIRED_DEPLOYMENT_MODES: readonly ["local", "self_hosted", "cloud", "remote", "hybrid"];
+export type RetiredDeploymentMode = (typeof RETIRED_DEPLOYMENT_MODES)[number];
+/** Fold case, surrounding space, and the `self-hosted`/`self_hosted` spelling split. */
+export declare function normalizeModeToken(value: string): string;
+/** The retired mode this value names, or null if it names something else. */
+export declare function asRetiredDeploymentMode(value: string): RetiredDeploymentMode | null;
+export interface RetiredModeReplacement {
+    /** The variable the caller should set instead. */
+    envKey: string;
+    /** Value that replaces `local` — the on-this-box arm. */
+    onBox: string;
+    /** Value that replaces `self_hosted` / `cloud` / `remote` / `hybrid`. */
+    offBox: string;
+}
+/**
+ * The error a retired mode word must produce.
+ *
+ * It names three things a bare "unknown value" error does not: the variable that
+ * carried the retired word, the variable to set instead, and the exact value —
+ * because the operator reading this cannot be assumed to know the collapse
+ * happened.
+ */
+export declare function retiredDeploymentModeError(rawValue: string, sourceEnvKey: string, replacement: RetiredModeReplacement): Error;
+//# sourceMappingURL=retired-deployment-modes.d.ts.map

package/dist/lib/retired-deployment-modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retired-deployment-modes.d.ts","sourceRoot":"","sources":["../../src/lib/retired-deployment-modes.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,wBAAwB,gEAM3B,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9E,wFAAwF;AACxF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,6EAA6E;AAC7E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAKnF;AAED,MAAM,WAAW,sBAAsB;IACrC,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,sBAAsB,GAClC,KAAK,CASP"}

package/dist/lib/transcriber.d.ts

@@ -4,6 +4,66 @@ export interface TranscriptionOptions {
     onDelta?: (delta: string, textSoFar: string) => void;
 }
 export declare function resetClient(): void;
+/**
+ * Strip anything key-shaped out of a provider error before we print or log it.
+ *
+ * OpenAI's 401 body echoes a partially masked form of the key that was sent
+ * ("sk-abcd1234**********wxyz"). Even masked, that is credential material and
+ * must not land in terminal scrollback, CI logs or a diagnostics file.
+ */
+export declare function redactKeyMaterial(text: string): string;
+export interface CredentialProbeResult {
+    ok: boolean;
+    /** HTTP status when the API answered, null when we never reached it. */
+    status: number | null;
+    model: string;
+    /** Which configured role this probe covered: transcription or enhancement. */
+    role: "transcription" | "enhancement";
+    message: string;
+}
+/**
+ * Performs the one authenticated request the credential probe rests on.
+ *
+ * Injected so the request path can be tested. Before this existed, review deleted the
+ * `models.retrieve` call and its success return outright — replacing them with an unconditional
+ * `{ok: true, status: 200}` that made no request at all — and `bun test
+ * src/__tests__/credential-probe.test.ts` still reported **7 pass / 0 fail, exit 0**. Every
+ * existing test passed an empty key, so all of them returned at the missing-key branch before a
+ * client was ever constructed, leaving the 401 rejection (the probe's headline claim), the 404
+ * model-unavailable case, the 200 success path, and `redactKeyMaterial` applied to a real error
+ * body all uncovered. A probe whose request can be removed without a failing test proves nothing.
+ *
+ * Mirrors the `executable` injection the capture probe already uses for the same reason.
+ */
+export type CredentialModelRetriever = (model: string, apiKey: string) => Promise<{
+    id?: string;
+}>;
+/**
+ * Verify that the configured credential is ACCEPTED by the API, not merely
+ * present in config.
+ *
+ * A non-empty string in `openai_api_key` proves nothing: any placeholder
+ * satisfies it. This makes one real authenticated request, so a rejected or
+ * revoked key surfaces as a failure instead of a green tick.
+ *
+ * The model and key must be passed in as a matched PAIR, and the caller must not
+ * mix roles. An earlier version probed `resolveTranscriberModel(config)` — which
+ * is `transcriber_model || enhancement_model`, the POST-PROCESSING model — using
+ * `openai_api_key`, under a line labelled "Transcription credential". Two ways
+ * to be wrong: with split keys it retrieved the enhancement model with the
+ * transcription key and printed a red 404 on a working machine; and it never
+ * touched `config.transcription_model`, the model `transcribeAudio` actually
+ * uses, so that model being unavailable produced a green tick.
+ *
+ * Scope note: this proves authentication and model access. It does not prove
+ * quota or that a given audio file will transcribe.
+ */
+export declare function verifyTranscriptionCredential(config: RecordingsConfig, model: string, options?: {
+    apiKey?: string;
+    role?: "transcription" | "enhancement";
+    /** Test seam. Defaults to a real authenticated `models.retrieve`. */
+    retrieveModel?: CredentialModelRetriever;
+}): Promise<CredentialProbeResult>;
 export declare function transcribeAudio(audioPath: string, config: RecordingsConfig, options?: Pick<TranscriptionOptions, "prompt">): Promise<TranscriptionResult>;
 export declare function transcribeBuffer(buffer: Buffer, filename: string, config: RecordingsConfig, options?: Pick<TranscriptionOptions, "prompt">): Promise<TranscriptionResult>;
 export declare function transcribeAudioStream(audioPath: string, config: RecordingsConfig, options?: TranscriptionOptions): Promise<TranscriptionResult>;

package/dist/lib/transcriber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transcriber.d.ts","sourceRoot":"","sources":["../../src/lib/transcriber.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAM/E,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACtD;AAcD,wBAAgB,WAAW,IAAI,IAAI,CAGlC;AAED,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAM,GACjD,OAAO,CAAC,mBAAmB,CAAC,CA4B9B;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAM,GACjD,OAAO,CAAC,mBAAmB,CAAC,CA6B9B;AAED,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CA6C9B;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQpE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAM5D"}
+{"version":3,"file":"transcriber.d.ts","sourceRoot":"","sources":["../../src/lib/transcriber.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAM/E,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACtD;AAcD,wBAAgB,WAAW,IAAI,IAAI,CAGlC;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkBtD;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,OAAO,CAAC;IACZ,wEAAwE;IACxE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,IAAI,EAAE,eAAe,GAAG,aAAa,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,wBAAwB,GAAG,CACrC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,OAAO,CAAC;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAU9B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa,CAAC;IACvC,qEAAqE;IACrE,aAAa,CAAC,EAAE,wBAAwB,CAAC;CACrC,GACL,OAAO,CAAC,qBAAqB,CAAC,CA6ChC;AAED,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAM,GACjD,OAAO,CAAC,mBAAmB,CAAC,CA4B9B;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAM,GACjD,OAAO,CAAC,mBAAmB,CAAC,CA6B9B;AAED,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CA6C9B;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQpE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAM5D"}