/**
 * Detect **degenerate repetition** — the most common LLM failure mode: a model that gets stuck
 * emitting the same character or short phrase forever (often with no punctuation), e.g. `啊啊啊啊…`
 * or `the answer is the answer is the answer is…`. Brains poll this over the growing output and, on a
 * hit, **cancel the stream** and mark the turn errored, so the loop doesn't keep paying for garbage and
 * downstream (e.g. a team member) treats it as a failed turn rather than a real statement.
 *
 * Only an *exact* tail repetition trips it (character-for-character). The original header claimed
 * normal code "won't false-positive" because repeated structure differs in content — **falsified in
 * the field** (docs/DEADTARGET-WINNING-AVG-COREWARS-2026-07-10.md §〇-3): legitimate code repeats the
 * SAME line verbatim (redcode boot blocks `mov <bootsrc, {bootdst` ×6-8, SQL fixture rows, ASCII-art
 * banners), landed exactly in the rule-2 window, and the cut stream three-struck whole TB tasks dead.
 * Hence two structural allowances, both bounded so true runaway loops are still caught:
 *   - rule 1 exempts short symbol runs (ASCII dividers) — a run of a non-letter/digit char only
 *     counts as degenerate past `CHAR_RUN_SYMBOL`;
 *   - rule 2 exempts *code-line-shaped* units (full-line repeats carrying operand/structure chars or
 *     indentation) unless the loop SATURATES the whole inspection window (`SATURATION_REPS`) —
 *     no legitimate boot block is 16+ identical lines deep inside one 400-char tail.
 */
/**
 * The errorMessage a brain stamps on a turn it cut off for degenerate repetition. Exported as a single
 * constant so the cut-off site (the brains) and the detection site (`assembleResult`, which maps it to
 * `errorCode="output.degenerate"` + salvages the turn text — design/39) agree on one machine-readable
 * signal, instead of matching a duplicated magic string. Wording: the output is salvaged now, not discarded.
 */
export declare const DEGENERATE_MESSAGE = "degenerate repetition detected \u2014 the model looped on the same text; output cut off at the repetition";
/**
 * One detector hit — either the event that CUT a stream (`degenerate`) or a repetition that landed in
 * a detection window but was SPARED by a 2e1c161 structural allowance (code-line shape / divider run).
 * Spared events are the RSI raw material for judging whether the allowance is too wide or too narrow
 * (clay 2026-07-10: the detector must report counts AND the detected segment, not just a boolean).
 */
export interface RepetitionEvent {
    /** Which rule's window the repetition landed in: rule 1 (`char-run`) or rule 2 (`unit-loop`). */
    rule: "char-run" | "unit-loop";
    /** Repeating-unit length in chars (1 for a char run). */
    period: number;
    /** How many times the unit repeated (the run length for a char run). */
    reps: number;
    /** Sample of the repeated unit/tail, truncated to ≤{@link SEGMENT_MAX} chars. */
    segment: string;
}
/** Structured result of one detector pass over a (growing) output tail. */
export interface RepetitionInspection {
    /** True ⇒ a degenerate loop tripped — the caller should cut the stream (same verdict as `looksDegenerate`). */
    degenerate: boolean;
    /** The event that tripped; present iff `degenerate`. */
    cut?: RepetitionEvent;
    /** Allowance-spared hits (at most one per rule per pass — the smallest period is the fundamental one). */
    spared: RepetitionEvent[];
}
/**
 * Structured detector pass: same verdict as {@link looksDegenerate}, plus WHAT hit (`cut`) and what
 * the 2e1c161 allowances spared. Spared collection is bounded: at most one `char-run` and one
 * `unit-loop` event per pass (rule 2 keeps the smallest period — the fundamental unit — so a p and
 * its 2p/3p multiples don't report the same loop several times).
 */
export declare function inspectDegenerate(text: string): RepetitionInspection;
export declare function looksDegenerate(text: string): boolean;
/**
 * T1-4 (brain stream-layer truncation): drop the degenerate TAIL off the text face that tripped a
 * cut, keeping ONE instance of the repeating unit, so the salvaged prefix lands in the final
 * assistant content / `salvagedOutput` without hundreds of chars of loop garbage (which the loop's
 * bounded degenerate-recovery continue would otherwise re-feed the model as context — the very text
 * it must not repeat).
 *
 * Always-on by design (no opt-out flag). The honest argument (fable review tightened the original
 * "zero information loss" claim):
 *  - everything removed is a byte-identical duplicate of the unit that is KEPT, so no UNIQUE text is
 *    ever swallowed (a non-repeating tail never matches and is returned unchanged). What CAN be lost
 *    is a repetition COUNT: if the legitimate text immediately before the loop happened to end with
 *    the same unit repeated (e.g. an intentional "very very" directly abutting a "very"-loop), those
 *    legitimate repeats fold into the loop and collapse to the single kept instance. This only ever
 *    happens on a stream the detector ALREADY cut as degenerate, and the alternative is worse (the
 *    full loop tail re-fed to the model);
 *  - most legitimate verbatim repetition (code lines, dividers) never gets here at all — the 2e1c161
 *    allowances spare it upstream, and a spared stream is never cut;
 *  - the loop may have grown far past the 400-char inspection window before the poll fired; the
 *    scan below strips ALL trailing repeats (and one trailing PARTIAL unit from post-cut buffered
 *    deltas), not just the reps the window measured.
 *
 * Fail-safe floor: the trim only fires when the tail ends with ≥2 exact repeats of the cut event's
 * unit — a WRONG-face call (e.g. the cut tripped in thinking, this is the text face) is structurally
 * a no-op unless that face coincidentally ends with ≥2 exact unit repeats (in which case those — and
 * any partial-unit suffix stripped with them — fold like any other repeats; same bounded cost as
 * above). Thinking/reasoning faces are deliberately never trimmed by the brains: anthropic thinking
 * blocks are signature-sealed for replay (mutating them invalidates the signature), and neither face
 * reaches `salvagedOutput`.
 */
export declare function trimDegenerateTail(text: string, cut: RepetitionEvent): string;
//# sourceMappingURL=repetition.d.ts.map