@inhuman.tools/harness 0.1.0 → 0.2.0

package/dist/daemon/session/cutoff.d.ts

@@ -1,280 +0,0 @@
-/**
- * Cutoff: declarative zone geometry for compaction. Collapse-phase successor
- * of the classify walk (`cohort-compact-strategies-2026-08-24.md`).
- *
- * The transcript is three contiguous zones, oldest → newest:
- *
- *     [ fold ][ squeeze ][ keep ]
- *
- * A cutoff record bounds the zones (min/max per unit); the resolver computes
- * the two boundaries. There are no labels and no per-round program calls —
- * the thirteen cohort classifiers were all instances of "keep the largest
- * suffix under a budget, subject to floors", so the budget IS the strategy.
- *
- * Laws:
- * - The newest round is always keep (host law; turn-replay class).
- * - Boundary legality filters the candidate cut set (`round` default,
- *   `user-round` = cut only where the round has a prompt). Pair-safety is
- *   round grain itself. Legality wins over caps: when the newest round is
- *   prompt-less, `user-round` makes a `rounds: 1` cap unsatisfiable and the
- *   cut degrades to the nearest legal one — named, accepted.
- * - Bounds on one zone compose — every active bound must hold. `fraction`
- *   denominates against the cap riding the transcript; cap 0 makes fraction
- *   bounds inert (skipped, never poisoning).
- * - Selection: the largest keep satisfying caps AND floors (direct scan —
- *   exact even if the token gauge misbehaves). When no cut satisfies both,
- *   precedence decides: soft pressure → floors win (protect the active
- *   work); overflow / forced → caps win (the window must shrink). Explicit
- *   `precedence` overrides. Floors with no active caps fold the most the
- *   floors allow; no active keep bounds at all → nothing to fold.
- * - `fold.min` is the worth-it floor, measured on the whole reclaimable
- *   range `[0, keepFrom)` BEFORE squeeze carves it (squeeze reclaim counts
- *   toward worth; anti-thrash, OpenCode PRUNE_MINIMUM shape).
- * - `warm: "skip"` (default) refuses to fold a transcript with a completion
- *   still in the prompt cache. `forced: { warm: "ignore" }` on a record is
- *   the sovereignty valve — slash compaction overrides the cache guard by
- *   policy, not by mechanism.
- *
- * Residuals stay outside on purpose: Cursor's composer? model predicate,
- * Aider's fold-all-under-4-rounds, Gemini's share-of-current-chars
- * denominator. Honest hacks are not processed.
- */
-import { z } from "zod";
-import { Transcript } from "./transcript.js";
-declare const boundSchema: z.ZodObject<{
-    tokens: z.ZodOptional<z.ZodNumber>;
-    fraction: z.ZodOptional<z.ZodNumber>;
-    chars: z.ZodOptional<z.ZodNumber>;
-    rounds: z.ZodOptional<z.ZodNumber>;
-    turns: z.ZodOptional<z.ZodNumber>;
-    cells: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-declare const patchSchema: z.ZodObject<{
-    keep: z.ZodOptional<z.ZodObject<{
-        min: z.ZodOptional<z.ZodObject<{
-            tokens: z.ZodOptional<z.ZodNumber>;
-            fraction: z.ZodOptional<z.ZodNumber>;
-            chars: z.ZodOptional<z.ZodNumber>;
-            rounds: z.ZodOptional<z.ZodNumber>;
-            turns: z.ZodOptional<z.ZodNumber>;
-            cells: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-        max: z.ZodOptional<z.ZodObject<{
-            tokens: z.ZodOptional<z.ZodNumber>;
-            fraction: z.ZodOptional<z.ZodNumber>;
-            chars: z.ZodOptional<z.ZodNumber>;
-            rounds: z.ZodOptional<z.ZodNumber>;
-            turns: z.ZodOptional<z.ZodNumber>;
-            cells: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    squeeze: z.ZodOptional<z.ZodObject<{
-        max: z.ZodOptional<z.ZodObject<{
-            tokens: z.ZodOptional<z.ZodNumber>;
-            fraction: z.ZodOptional<z.ZodNumber>;
-            chars: z.ZodOptional<z.ZodNumber>;
-            rounds: z.ZodOptional<z.ZodNumber>;
-            turns: z.ZodOptional<z.ZodNumber>;
-            cells: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    fold: z.ZodOptional<z.ZodObject<{
-        min: z.ZodOptional<z.ZodObject<{
-            tokens: z.ZodOptional<z.ZodNumber>;
-            fraction: z.ZodOptional<z.ZodNumber>;
-            chars: z.ZodOptional<z.ZodNumber>;
-            rounds: z.ZodOptional<z.ZodNumber>;
-            turns: z.ZodOptional<z.ZodNumber>;
-            cells: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    boundary: z.ZodOptional<z.ZodEnum<{
-        round: "round";
-        "user-round": "user-round";
-    }>>;
-    warm: z.ZodOptional<z.ZodEnum<{
-        ignore: "ignore";
-        skip: "skip";
-    }>>;
-    precedence: z.ZodOptional<z.ZodEnum<{
-        caps: "caps";
-        floors: "floors";
-    }>>;
-}, z.core.$strict>;
-declare const cutoffRecordSchema: z.ZodObject<{
-    keep: z.ZodOptional<z.ZodObject<{
-        min: z.ZodOptional<z.ZodObject<{
-            tokens: z.ZodOptional<z.ZodNumber>;
-            fraction: z.ZodOptional<z.ZodNumber>;
-            chars: z.ZodOptional<z.ZodNumber>;
-            rounds: z.ZodOptional<z.ZodNumber>;
-            turns: z.ZodOptional<z.ZodNumber>;
-            cells: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-        max: z.ZodOptional<z.ZodObject<{
-            tokens: z.ZodOptional<z.ZodNumber>;
-            fraction: z.ZodOptional<z.ZodNumber>;
-            chars: z.ZodOptional<z.ZodNumber>;
-            rounds: z.ZodOptional<z.ZodNumber>;
-            turns: z.ZodOptional<z.ZodNumber>;
-            cells: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    squeeze: z.ZodOptional<z.ZodObject<{
-        max: z.ZodOptional<z.ZodObject<{
-            tokens: z.ZodOptional<z.ZodNumber>;
-            fraction: z.ZodOptional<z.ZodNumber>;
-            chars: z.ZodOptional<z.ZodNumber>;
-            rounds: z.ZodOptional<z.ZodNumber>;
-            turns: z.ZodOptional<z.ZodNumber>;
-            cells: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    fold: z.ZodOptional<z.ZodObject<{
-        min: z.ZodOptional<z.ZodObject<{
-            tokens: z.ZodOptional<z.ZodNumber>;
-            fraction: z.ZodOptional<z.ZodNumber>;
-            chars: z.ZodOptional<z.ZodNumber>;
-            rounds: z.ZodOptional<z.ZodNumber>;
-            turns: z.ZodOptional<z.ZodNumber>;
-            cells: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    boundary: z.ZodOptional<z.ZodEnum<{
-        round: "round";
-        "user-round": "user-round";
-    }>>;
-    warm: z.ZodOptional<z.ZodEnum<{
-        ignore: "ignore";
-        skip: "skip";
-    }>>;
-    precedence: z.ZodOptional<z.ZodEnum<{
-        caps: "caps";
-        floors: "floors";
-    }>>;
-    reasons: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        keep: z.ZodOptional<z.ZodObject<{
-            min: z.ZodOptional<z.ZodObject<{
-                tokens: z.ZodOptional<z.ZodNumber>;
-                fraction: z.ZodOptional<z.ZodNumber>;
-                chars: z.ZodOptional<z.ZodNumber>;
-                rounds: z.ZodOptional<z.ZodNumber>;
-                turns: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-            max: z.ZodOptional<z.ZodObject<{
-                tokens: z.ZodOptional<z.ZodNumber>;
-                fraction: z.ZodOptional<z.ZodNumber>;
-                chars: z.ZodOptional<z.ZodNumber>;
-                rounds: z.ZodOptional<z.ZodNumber>;
-                turns: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        squeeze: z.ZodOptional<z.ZodObject<{
-            max: z.ZodOptional<z.ZodObject<{
-                tokens: z.ZodOptional<z.ZodNumber>;
-                fraction: z.ZodOptional<z.ZodNumber>;
-                chars: z.ZodOptional<z.ZodNumber>;
-                rounds: z.ZodOptional<z.ZodNumber>;
-                turns: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        fold: z.ZodOptional<z.ZodObject<{
-            min: z.ZodOptional<z.ZodObject<{
-                tokens: z.ZodOptional<z.ZodNumber>;
-                fraction: z.ZodOptional<z.ZodNumber>;
-                chars: z.ZodOptional<z.ZodNumber>;
-                rounds: z.ZodOptional<z.ZodNumber>;
-                turns: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        boundary: z.ZodOptional<z.ZodEnum<{
-            round: "round";
-            "user-round": "user-round";
-        }>>;
-        warm: z.ZodOptional<z.ZodEnum<{
-            ignore: "ignore";
-            skip: "skip";
-        }>>;
-        precedence: z.ZodOptional<z.ZodEnum<{
-            caps: "caps";
-            floors: "floors";
-        }>>;
-    }, z.core.$strict>>>;
-    forced: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"fold-all">, z.ZodLiteral<"same">, z.ZodObject<{
-        keep: z.ZodOptional<z.ZodObject<{
-            min: z.ZodOptional<z.ZodObject<{
-                tokens: z.ZodOptional<z.ZodNumber>;
-                fraction: z.ZodOptional<z.ZodNumber>;
-                chars: z.ZodOptional<z.ZodNumber>;
-                rounds: z.ZodOptional<z.ZodNumber>;
-                turns: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-            max: z.ZodOptional<z.ZodObject<{
-                tokens: z.ZodOptional<z.ZodNumber>;
-                fraction: z.ZodOptional<z.ZodNumber>;
-                chars: z.ZodOptional<z.ZodNumber>;
-                rounds: z.ZodOptional<z.ZodNumber>;
-                turns: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        squeeze: z.ZodOptional<z.ZodObject<{
-            max: z.ZodOptional<z.ZodObject<{
-                tokens: z.ZodOptional<z.ZodNumber>;
-                fraction: z.ZodOptional<z.ZodNumber>;
-                chars: z.ZodOptional<z.ZodNumber>;
-                rounds: z.ZodOptional<z.ZodNumber>;
-                turns: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        fold: z.ZodOptional<z.ZodObject<{
-            min: z.ZodOptional<z.ZodObject<{
-                tokens: z.ZodOptional<z.ZodNumber>;
-                fraction: z.ZodOptional<z.ZodNumber>;
-                chars: z.ZodOptional<z.ZodNumber>;
-                rounds: z.ZodOptional<z.ZodNumber>;
-                turns: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        boundary: z.ZodOptional<z.ZodEnum<{
-            round: "round";
-            "user-round": "user-round";
-        }>>;
-        warm: z.ZodOptional<z.ZodEnum<{
-            ignore: "ignore";
-            skip: "skip";
-        }>>;
-        precedence: z.ZodOptional<z.ZodEnum<{
-            caps: "caps";
-            floors: "floors";
-        }>>;
-    }, z.core.$strict>]>>;
-}, z.core.$strict>;
-export type CutoffBound = z.infer<typeof boundSchema>;
-export type CutoffPatch = z.infer<typeof patchSchema>;
-export type CutoffRecord = z.infer<typeof cutoffRecordSchema>;
-export type CutoffContext = {
-    readonly reason?: string;
-    readonly forced?: boolean;
-};
-export type CutoffSkip = "empty" | "warm" | "nothing-to-fold" | "fold-below-min";
-export type CutoffSplit = {
-    readonly full: Transcript;
-    readonly fold: Transcript;
-    readonly squeeze: Transcript;
-    readonly keep: Transcript;
-    /** Round indices: fold = [0, squeezeFrom), squeeze = [squeezeFrom, keepFrom). */
-    readonly squeezeFrom: number;
-    readonly keepFrom: number;
-    readonly skipped: CutoffSkip | null;
-};
-export declare function resolveCutoff(full: Transcript, record: CutoffRecord, ctx?: CutoffContext): CutoffSplit;
-export {};
-//# sourceMappingURL=cutoff.d.ts.map

package/dist/daemon/session/cutoff.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cutoff.d.ts","sourceRoot":"","sources":["../../../src/daemon/session/cutoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAW,UAAU,EAAkB,MAAM,iBAAiB,CAAC;AAEtE,QAAA,MAAM,WAAW;;;;;;;kBAUN,CAAC;AAOZ,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUN,CAAC;AAEZ,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKb,CAAC;AAEZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AAEjF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,iFAAiF;IACjF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;CACrC,CAAC;AAIF,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,YAAY,EACpB,GAAG,GAAE,aAAkB,GACtB,WAAW,CA2Gb"}

package/dist/daemon/session/cutoff.js

@@ -1,234 +0,0 @@
-/**
- * Cutoff: declarative zone geometry for compaction. Collapse-phase successor
- * of the classify walk (`cohort-compact-strategies-2026-08-24.md`).
- *
- * The transcript is three contiguous zones, oldest → newest:
- *
- *     [ fold ][ squeeze ][ keep ]
- *
- * A cutoff record bounds the zones (min/max per unit); the resolver computes
- * the two boundaries. There are no labels and no per-round program calls —
- * the thirteen cohort classifiers were all instances of "keep the largest
- * suffix under a budget, subject to floors", so the budget IS the strategy.
- *
- * Laws:
- * - The newest round is always keep (host law; turn-replay class).
- * - Boundary legality filters the candidate cut set (`round` default,
- *   `user-round` = cut only where the round has a prompt). Pair-safety is
- *   round grain itself. Legality wins over caps: when the newest round is
- *   prompt-less, `user-round` makes a `rounds: 1` cap unsatisfiable and the
- *   cut degrades to the nearest legal one — named, accepted.
- * - Bounds on one zone compose — every active bound must hold. `fraction`
- *   denominates against the cap riding the transcript; cap 0 makes fraction
- *   bounds inert (skipped, never poisoning).
- * - Selection: the largest keep satisfying caps AND floors (direct scan —
- *   exact even if the token gauge misbehaves). When no cut satisfies both,
- *   precedence decides: soft pressure → floors win (protect the active
- *   work); overflow / forced → caps win (the window must shrink). Explicit
- *   `precedence` overrides. Floors with no active caps fold the most the
- *   floors allow; no active keep bounds at all → nothing to fold.
- * - `fold.min` is the worth-it floor, measured on the whole reclaimable
- *   range `[0, keepFrom)` BEFORE squeeze carves it (squeeze reclaim counts
- *   toward worth; anti-thrash, OpenCode PRUNE_MINIMUM shape).
- * - `warm: "skip"` (default) refuses to fold a transcript with a completion
- *   still in the prompt cache. `forced: { warm: "ignore" }` on a record is
- *   the sovereignty valve — slash compaction overrides the cache guard by
- *   policy, not by mechanism.
- *
- * Residuals stay outside on purpose: Cursor's composer? model predicate,
- * Aider's fold-all-under-4-rounds, Gemini's share-of-current-chars
- * denominator. Honest hacks are not processed.
- */
-import { z } from "zod";
-import { CompletionExpectation } from "../../models/session/index.js";
-import { charsOf, userRoundCount } from "./transcript.js";
-const boundSchema = z
-    .object({
-    tokens: z.number().nonnegative(),
-    fraction: z.number().nonnegative(),
-    chars: z.number().nonnegative(),
-    rounds: z.number().nonnegative(),
-    turns: z.number().nonnegative(),
-    cells: z.number().nonnegative(),
-})
-    .partial()
-    .strict();
-// Each zone exposes only the bounds the resolver reads — no silent config.
-const keepZoneSchema = z.object({ min: boundSchema, max: boundSchema }).partial().strict();
-const squeezeZoneSchema = z.object({ max: boundSchema }).partial().strict();
-const foldZoneSchema = z.object({ min: boundSchema }).partial().strict();
-const patchSchema = z
-    .object({
-    keep: keepZoneSchema,
-    squeeze: squeezeZoneSchema,
-    fold: foldZoneSchema,
-    boundary: z.enum(["round", "user-round"]),
-    warm: z.enum(["skip", "ignore"]),
-    precedence: z.enum(["floors", "caps"]),
-})
-    .partial()
-    .strict();
-const cutoffRecordSchema = patchSchema
-    .extend({
-    reasons: z.record(z.string(), patchSchema).optional(),
-    forced: z.union([z.literal("fold-all"), z.literal("same"), patchSchema]).optional(),
-})
-    .strict();
-const CAP_REASONS = new Set(["overflow", "context-exceeded"]);
-export function resolveCutoff(full, record, ctx = {}) {
-    let effective = {
-        keep: record.keep,
-        squeeze: record.squeeze,
-        fold: record.fold,
-        boundary: record.boundary,
-        warm: record.warm,
-        precedence: record.precedence,
-    };
-    const reasonPatch = ctx.reason != null ? record.reasons?.[ctx.reason] : undefined;
-    if (reasonPatch != null)
-        effective = mergePatch(effective, reasonPatch);
-    if (ctx.forced === true && record.forced != null && record.forced !== "same") {
-        effective = mergePatch(effective, record.forced === "fold-all" ? { keep: { max: { rounds: 1 } } } : record.forced);
-    }
-    const rounds = full.rounds();
-    if (rounds.length === 0)
-        return skip(full, "empty");
-    if (effective.warm !== "ignore" &&
-        full.cells.some((cell) => cell instanceof CompletionExpectation && cell.isWarm)) {
-        return skip(full, "warm");
-    }
-    // Candidate cut i: fold = rounds[0, i), keep = rounds[i, n). i = 0 folds
-    // nothing; the newest round is never foldable (host law), so i ≤ n − 1.
-    const n = rounds.length;
-    const legal = [0];
-    for (let i = 1; i <= n - 1; i++) {
-        if (effective.boundary === "user-round" && rounds[i].prompt === "")
-            continue;
-        legal.push(i);
-    }
-    const legalSet = new Set(legal);
-    const keepMeters = new Map();
-    const metersAt = (i) => {
-        let m = keepMeters.get(i);
-        if (m == null) {
-            m = measure(full.sliceRounds(i, n));
-            keepMeters.set(i, m);
-        }
-        return m;
-    };
-    const caps = effective.keep?.max ?? {};
-    const floors = effective.keep?.min ?? {};
-    const capsActive = activeEntries(caps, full.cap).length > 0;
-    const floorsActive = activeEntries(floors, full.cap).length > 0;
-    const capsOkAt = (i) => satisfiesMax(metersAt(i), caps, full.cap);
-    const floorsOkAt = (i) => satisfiesMin(metersAt(i), floors, full.cap);
-    let keepFrom;
-    if (!capsActive) {
-        // Floors-only: fold the most the floors allow. No active bounds → no cut.
-        keepFrom = floorsActive ? maxLegalWhere(legal, floorsOkAt) : 0;
-    }
-    else {
-        // Largest keep satisfying both axes. Exact by direct scan — does not
-        // lean on gauge monotonicity the way an interval test would.
-        const both = legal.find((i) => capsOkAt(i) && floorsOkAt(i));
-        if (both != null) {
-            keepFrom = both;
-        }
-        else {
-            const precedence = effective.precedence ??
-                (ctx.forced === true || CAP_REASONS.has(ctx.reason ?? "") ? "caps" : "floors");
-            const iCaps = legal.find(capsOkAt) ?? legal[legal.length - 1];
-            const iFloors = maxLegalWhere(legal, floorsOkAt);
-            keepFrom = precedence === "caps" ? iCaps : iFloors;
-        }
-    }
-    if (keepFrom === 0)
-        return skip(full, "nothing-to-fold");
-    // Worth-it floor on the whole reclaimable range, BEFORE squeeze carves it —
-    // squeeze reclaim counts toward worth, and skipping here discards nothing.
-    const foldMin = effective.fold?.min;
-    if (foldMin != null && activeEntries(foldMin, full.cap).length > 0) {
-        if (!satisfiesMin(measure(full.sliceRounds(0, keepFrom)), foldMin, full.cap)) {
-            return skip(full, "fold-below-min");
-        }
-    }
-    // Squeeze zone grows old-ward from the keep boundary, bounded by its caps.
-    let squeezeFrom = keepFrom;
-    const squeezeCaps = effective.squeeze?.max;
-    if (squeezeCaps != null && activeEntries(squeezeCaps, full.cap).length > 0) {
-        for (let j = keepFrom - 1; j >= 0; j--) {
-            if (!legalSet.has(j))
-                continue;
-            const zone = measure(full.sliceRounds(j, keepFrom));
-            if (!satisfiesMax(zone, squeezeCaps, full.cap))
-                break;
-            squeezeFrom = j;
-        }
-    }
-    return {
-        full,
-        fold: full.sliceRounds(0, squeezeFrom),
-        squeeze: full.sliceRounds(squeezeFrom, keepFrom),
-        keep: full.sliceRounds(keepFrom, n),
-        squeezeFrom,
-        keepFrom,
-        skipped: null,
-    };
-}
-function skip(full, skipped) {
-    const empty = full.sliceRounds(0, 0);
-    return { full, fold: empty, squeeze: empty, keep: full, squeezeFrom: 0, keepFrom: 0, skipped };
-}
-function maxLegalWhere(legal, ok) {
-    let found = 0;
-    for (const i of legal) {
-        if (ok(i))
-            found = i;
-    }
-    return found;
-}
-function measure(slice) {
-    return {
-        tokens: slice.tokensUsed(),
-        chars: charsOf(slice.cells),
-        rounds: slice.rounds().length,
-        turns: userRoundCount(slice),
-        cells: slice.cells.length,
-    };
-}
-function satisfiesMax(meters, bound, cap) {
-    for (const [unit, value] of activeEntries(bound, cap)) {
-        if (meterOf(meters, unit, cap) > value)
-            return false;
-    }
-    return true;
-}
-function satisfiesMin(meters, bound, cap) {
-    for (const [unit, value] of activeEntries(bound, cap)) {
-        if (meterOf(meters, unit, cap) < value)
-            return false;
-    }
-    return true;
-}
-/** Callers filter inert units first (`activeEntries`) — fraction implies cap > 0. */
-function meterOf(meters, unit, cap) {
-    if (unit === "fraction")
-        return meters.tokens / cap;
-    return meters[unit];
-}
-/** Bound entries that can measure: fraction is inert when the cap is 0. */
-function activeEntries(bound, cap) {
-    return Object.entries(bound).filter(([unit, value]) => typeof value === "number" && (unit !== "fraction" || cap > 0));
-}
-/** Zone-level replace: a patch that names a zone owns that zone entirely. */
-function mergePatch(base, patch) {
-    return {
-        keep: patch.keep ?? base.keep,
-        squeeze: patch.squeeze ?? base.squeeze,
-        fold: patch.fold ?? base.fold,
-        boundary: patch.boundary ?? base.boundary,
-        warm: patch.warm ?? base.warm,
-        precedence: patch.precedence ?? base.precedence,
-    };
-}
-//# sourceMappingURL=cutoff.js.map

package/dist/daemon/session/cutoff.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cutoff.js","sourceRoot":"","sources":["../../../src/daemon/session/cutoff.ts"],"names":[],"mappings":"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"}

package/dist/daemon/session/transcript.d.ts

@@ -1,100 +0,0 @@
-import { CompletionExpectation, type CompletionMessage, SchemeReplChunk, ToolCallExpectation, TurnCompactChunk, TurnRecallChunk } from "../../models/session/index.js";
-export type MessageRole = "user" | "assistant";
-export declare class MessageChunk {
-    readonly role: MessageRole;
-    readonly text: string;
-    readonly ack: boolean;
-    readonly card: boolean;
-    constructor(role: MessageRole, text: string, flags?: {
-        readonly ack?: boolean;
-        readonly card?: boolean;
-    });
-    asCard(): MessageChunk;
-}
-export type EatCell = CompletionMessage | MessageChunk;
-/** Discriminated events of THE walk. See preamble, THE WALK. */
-export type TranscriptEvent = {
-    readonly kind: "fold";
-    readonly chunk: TurnCompactChunk;
-} | {
-    readonly kind: "completion";
-    readonly chunk: CompletionExpectation;
-} | {
-    readonly kind: "tool";
-    readonly chunk: ToolCallExpectation;
-} | {
-    readonly kind: "scheme";
-    readonly chunk: SchemeReplChunk;
-} | {
-    readonly kind: "recall";
-    readonly chunk: TurnRecallChunk;
-} | {
-    readonly kind: "cell";
-    readonly chunk: MessageChunk | string;
-};
-/** THE transcript walk. Views fold this; see preamble, THE WALK. */
-export declare function walkTranscript(chunks: readonly unknown[]): Generator<TranscriptEvent>;
-export type TranscriptRound = {
-    readonly start: number;
-    readonly end: number;
-    readonly prompt: string;
-    readonly response: CompletionExpectation;
-    readonly toolCalls: ReadonlyArray<ToolCallExpectation | SchemeReplChunk>;
-};
-export declare class Transcript {
-    readonly cells: readonly EatCell[];
-    readonly cap: number;
-    static empty(cap?: number): Transcript;
-    static fromCells(cells: readonly EatCell[], cap?: number, cards?: Iterable<EatCell>): Transcript;
-    /**
-     * Eat as classify should see it: cells after the last folded compact, with
-     * that compact's representation prefixed and marked as prior cards.
-     */
-    static fromWork(work: readonly unknown[], cap?: number): Transcript;
-    /** Gauge reading (`usage.total_tokens`) just before this slice's first cell. */
-    readonly baseGauge: number;
-    private readonly cards;
-    constructor(cells: readonly EatCell[], cap: number, cards?: Iterable<EatCell>, baseGauge?: number);
-    isCard(cell: EatCell): boolean;
-    cardCells(): EatCell[];
-    sliceCells(from: number, to?: number): Transcript;
-    /** The oldest slice owns everything before the first round anchor (prior cards). */
-    sliceRounds(from: number, to: number): Transcript;
-    rounds(): TranscriptRound[];
-    /**
-     * Occupancy of this slice. Gauge diff at the boundary, plus a content
-     * estimate for cells past the last stamped reading. Never a per-cell sum
-     * of `totalTokens` — that is a window gauge, not a weight.
-     */
-    tokensUsed(): number;
-    /**
-     * The frontier is the OLDEST round of this transcript. During the classify
-     * walk `preserve-transcript` runs frontier → newest (chronological), so the
-     * round being decided is the first one.
-     */
-    frontierRound(): Transcript;
-    /** `transcript/newer`: preserve without the frontier — drop the oldest round. */
-    withoutFrontier(): Transcript;
-    /** `transcript/older`: compact without the frontier — drop the newest round. */
-    withoutNewest(): Transcript;
-    completeRounds(): Transcript;
-    partialRound(): Transcript | null;
-    concat(other: Transcript): Transcript;
-}
-/**
- * Content-token stand-in: `ceil(chars / 4)`. Replace this one function when
- * per-cell prompt/response tokens exist on the model.
- */
-export declare function estimateTokens(text: string): number;
-/**
- * Raw content meter (`tokens/count`): what the cells weigh as text, never the
- * window gauge. Occupancy of a slice against the cap is `Transcript.tokensUsed`.
- */
-export declare function contentTokensOf(cells: readonly unknown[]): number;
-export declare function charsOf(cells: readonly unknown[]): number;
-export declare function inferCap(cells: readonly unknown[], fallback?: number): number;
-export declare function payloadSuffix(transcript: Transcript, n: number): EatCell[];
-export declare function paintTranscript(transcript: Transcript): string;
-export declare function userRoundCount(transcript: Transcript): number;
-export declare function textOfCell(cell: unknown): string;
-//# sourceMappingURL=transcript.d.ts.map

package/dist/daemon/session/transcript.d.ts.map

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