/**
 * Baton service — prose-native "you are here" markers.
 *
 * A baton is a small, typed, persisted record written at the end of a stretch
 * of work to orient the *next* session: position, an advisory next move, the
 * freeform "you are here." This is the one deliberately STATEFUL corner of
 * prose — every other verb is pure-read. Batons are written via `prose baton
 * set` and persisted to `~/.prose/batons.json`, which rides the vault's git
 * history, so batons sync across machines for free.
 *
 * Decoupled from any one methodology. A baton carries a free-form TYPE label
 * (`handoff`, `baton`, `decision`, …) rendered as `↪ <LABEL>: <content>`.
 * Arbiter-Driven Development's `↪ HANDOFF` is simply `type: 'handoff'` — one
 * consumer among many, with no special status in here.
 *
 * "You are here," NOT a backlog. `listBatons` returns the LATEST baton per
 * (project, type) by default; history exists but is never the default surface,
 * so batons orient the next walk without accumulating into a to-do list.
 */
export interface Baton {
    /** Stable unique id. */
    id: string;
    /** Free-form label, lowercased (`handoff`, `baton`, `decision`, …). */
    type: string;
    /** Absolute cwd the baton belongs to — the "garden" it orients. */
    project: string;
    /** Freeform body (e.g. `position — what merged · next: X · or pivot`). */
    content: string;
    /** ISO timestamp of when the baton was set. */
    timestamp: string;
    /**
     * Hidden correlation keys — terminal/multiplexer identifiers captured from the
     * environment at set-time (e.g. `ZMX_SESSION`, `TMUX_PANE`). Purely a behind-
     * the-scenes correlation tool: never rendered, never shown. On read, a baton
     * sharing any one (name,value) pair with the current environment is bumped
     * ahead of the plain latest-per-(project,type) pick, so a terminal recovers
     * *its own* handoff even when several terminals work the same project at once.
     * Absent when nothing identifying was in the environment — and that's fine.
     */
    keys?: Record<string, string>;
}
/**
 * Snapshot the correlation keys present in `env` (defaults to the real process
 * environment). Empty/whitespace values are skipped. Returns `{}` when nothing
 * identifying is present — a perfectly valid "no anchor" state.
 */
export declare function captureCorrelationKeys(env?: Record<string, string | undefined>): Record<string, string>;
/** True iff `a` and `b` share at least one identical (name, value) pair. */
export declare function correlationKeysMatch(a: Record<string, string> | undefined, b: Record<string, string> | undefined): boolean;
/**
 * Where batons live. Honors `PROSE_BATON_STORE` (used by tests to avoid
 * touching the real vault); otherwise the vault's `batons.json`.
 */
export declare function getBatonStorePath(): string;
/**
 * Parse the canonical `↪ <LABEL>: <content>` rendered form back into a type +
 * content. Returns null if the string isn't in that form. The sigil is
 * optional slack: `HANDOFF: foo` parses the same as `↪ HANDOFF: foo`.
 */
export declare function parseBatonLine(line: string): {
    type: string;
    content: string;
} | null;
export interface SetBatonOptions {
    /** Raw content; may itself carry a `↪ LABEL:` prefix, which sets the type. */
    content: string;
    /** Explicit type override. Wins over any prefix parsed from `content`. */
    type?: string;
    /** Project the baton belongs to. Defaults to `process.cwd()`. */
    cwd?: string;
    /**
     * Correlation keys to embed. Defaults to a live snapshot of the environment
     * (`captureCorrelationKeys()`). Exposed mainly so tests can inject a known
     * set without touching `process.env`.
     */
    keys?: Record<string, string>;
}
/**
 * Write a baton. If `content` is in `↪ LABEL: body` form and no explicit
 * `type` is given, the label becomes the type and the body becomes the content.
 */
export declare function setBaton(opts: SetBatonOptions): Baton;
export interface ListBatonOptions {
    /** Scope to one project (exact cwd match). */
    cwd?: string;
    /** Filter to one type. */
    type?: string;
    /** Return full history instead of latest-per-(project,type). */
    history?: boolean;
    /** Cap the number of returned batons (after sorting/dedup). */
    limit?: number;
    /**
     * Correlation keys for the *current* terminal. Defaults to a live environment
     * snapshot. In the collapsed (non-history) view, a baton sharing any key with
     * these wins its (project,type) slot over a newer non-matching one. No match
     * (or no keys) → plain latest-wins, unchanged.
     */
    correlationKeys?: Record<string, string>;
}
/**
 * Batons newest-first. By default collapses to the LATEST baton per
 * (project, type) pair — the "you are here" surface. `history: true` returns
 * every baton instead.
 */
export declare function listBatons(opts?: ListBatonOptions): Baton[];
export interface ClearBatonOptions {
    cwd?: string;
    type?: string;
    /** Nuke the entire store. Required when neither `cwd` nor `type` is given. */
    all?: boolean;
}
/**
 * Remove batons matching the filters. Returns the count removed. Refuses to
 * delete everything unless `all` is explicitly set — an unscoped clear is
 * almost always a mistake.
 */
export declare function clearBatons(opts: ClearBatonOptions): number;
/** The canonical one-line rendering of a baton. */
export declare function renderBatonLine(b: Baton): string;
/**
 * Compact header block of batons for a single cwd — what `snap`/`whisper`
 * prepend so orientation carries the last "you are here" for free. Returns ''
 * when there are no batons (caller prepends nothing).
 */
export declare function renderBatonHeader(batons: Baton[], now?: number): string;
//# sourceMappingURL=baton.d.ts.map