import type { CapabilityRow } from "../capabilities.js";
/**
 * The host-capability matrix, built from what THIS v2 session observed.
 *
 * v1's probe can classify a seam as `ok` by watching a hook fire or an event
 * arrive.  v2 needs the same table even more — a 2.x host is moving under us, and
 * every promise on this line (per-role tool trim, JIT over native tools, the
 * address red line, the forced background) lives or dies on a hook the host may or
 * may not call.  What it must NOT do is reuse v1's row list: those seam names are
 * v1's SDK, and a row that says "declared" because a type file mentions a name is
 * worth nothing when the host never calls it (that is precisely how the invented
 * `session.hook("prompt")` nearly got built on).
 *
 * So every row here is derived from an observation the runtime already made — the
 * probe's attached/missing sets, the guard's and offloader's counters — and a row
 * that we merely know from types says `declared` and names the missing proof.
 */
interface Inputs {
    ctx: unknown;
    probe: {
        report: {
            ctxDomains: string[];
            hooksMissing: string[];
            executed: string[];
            executedAfter: string[];
            actions: string[];
            evaluations: number;
            agentsSeen: string[];
        };
    };
    guardsInstalled: boolean;
    backgroundForced: boolean;
    offload: {
        active: boolean;
        registrations: unknown[];
        report: {
            seen: number;
            offloaded: number;
        };
    };
    sessionHooks: number;
    hasTodoSeam: boolean;
    hasAsk: boolean;
    /** what the boot round-trip self-check found: absent | round-trip | read-back-mismatch | threw */
    storageState: string;
    /** Team-scope isolation (#22): how many hook events resolved to one of our six
     *  roles, how many were somebody else's, and how many the host never told us. */
    scope?: {
        report: {
            ours: number;
            foreign: number;
            unknown: number;
        };
    };
    /** The `ctx.event.subscribe()` feed (#8).  `received` is the observation that
     *  makes this row `ok` rather than `declared`: an event that actually arrived. */
    eventFeed?: {
        active: boolean;
        received: number;
        forwarded: number;
        unknown: Record<string, number>;
        stopped?: string;
    };
    /** #49 Context Pruning: the `v2-prune` layer's counters, read off the layer that
     *  runs it.  `prunedMessages > 0` is the only observation that earns `ok`; an
     *  operator who set `TM_PRUNE=off` says so in the note instead of looking broken. */
    prune?: {
        enabled: boolean;
        atPercent: number;
        keepTailPercent: number;
        checked: number;
        prunedMessages: number;
        prunedTokens: number;
        below: number;
        noLimit: number;
        foreignSkipped: number;
        threw: number;
        lastPercent: number;
    };
    /** #33 — what `tm_join { cancel: true }` actually got from `ctx.session.interrupt`.
     *  Absent means the bridge never wrapped the seam, which is itself the row's story:
     *  for a whole release v2 had no stop path at all, and nothing printed that fact. */
    stop?: {
        tried: number;
        confirmed: number;
        refused: number;
        unknown: number;
        error?: string;
    };
}
export declare function v2CapabilityRows(i: Inputs): CapabilityRow[];
export {};
//# sourceMappingURL=v2-capabilities.d.ts.map