agentfootprint 10.2.0 → 10.3.1

package/dist/types/lib/semantics/types.d.ts

@@ -1,323 +0,0 @@
-/**
- * semantics/types — the semantic tool-result vocabulary, as a PURE leaf
- * (9.53.0, the `toolOutcome.ts` precedent).
- *
- * WHY IT LIVES HERE. Two sides read these words and neither may own the
- * other: the agent loop's dispatch boundary (core/agent/stages/toolCalls.ts)
- * recognizes the envelope at run time, and the `check:semantics` build gate
- * (lib/semantics/check.ts) judges the same shapes with no agent anywhere in
- * sight. Declaring the vocabulary in a leaf both sides import keeps the
- * dependency pointing the right way — the loop and the gate depend on the
- * words, never on each other.
- *
- * The one exception to "zero imports" is TYPE-ONLY and deliberate: the
- * envelope's `coverage` field ABSORBS the existing coverage vocabulary
- * (`CoverageItem` / `CoverageInput`, core/agent/coverage/types.ts — itself a
- * pure-data leaf) instead of duplicating it. Two spellings of "ground this
- * result does not cover" would eventually disagree; type-only imports erase
- * at runtime, so this module stays a runtime leaf.
- *
- * ## What the envelope is
- *
- * A tool that answers "how many IOPS did fc1/3 do last hour?" today returns
- * prose or an ad-hoc object, and every caveat that makes the number honest —
- * the collection interval, whether the values are counters that must not be
- * summed, when the world was actually measured, which clusters were not
- * collected — is re-implemented by hand inside every tool and held in place
- * by review. Culture scales to one disciplined author; it does not scale to
- * a hundred tools. The semantic envelope makes those caveats TYPED DATA that
- * travel with the values, so honesty is inherited, not re-authored — and so
- * a build gate can refuse a triage tool that forgot its own limits.
- *
- * It is a SIBLING recognizer beside the effects envelope and the coverage
- * primitives — its own reserved marker (`af_semantics`, the
- * `af_absent`/`af_coverage` family), never new keys on the effects envelope.
- * The three compose on one result: `{ content: describedResult({…}), effects:
- * […], status }` is a tool that returns typed data AND proposes a transition.
- */
-import type { CoverageDeclaration, CoverageItem } from '../../core/agent/coverage/types.js';
-import type { DeclaredPeriod, PeriodOnWire } from '../../core/agent/coverage/period.js';
-/**
- * The reserved key that makes a semantic envelope recognizable. Reserved
- * vocabulary on the tool-result wire (the `af_absent` / `af_coverage`
- * precedent): a plain object carrying `af_semantics: true` that validates
- * cleanly is an envelope; every other value any tool has ever returned keeps
- * its bytes.
- */
-export declare const SEMANTICS_MARKER = "af_semantics";
-/**
- * One measured point. `t` is the tool's own clock words (an ISO string or an
- * epoch number — the library never reinterprets it), `entity` is what was
- * measured, `metric` names the measurement, `value` is the reading.
- */
-export interface SemanticSeriesPoint {
-    readonly t: string | number;
-    readonly entity: string;
-    readonly metric: string;
-    readonly value: number | string | boolean | null;
-}
-/**
- * One row of typed facts about one entity. The columns are the tool's own —
- * this library requires only that every row says WHAT it is about.
- */
-export interface SemanticFact {
-    readonly entity: string;
-    readonly [field: string]: unknown;
-}
-/** One typed relationship — "this VM rides that datastore", "this zone
- *  contains that WWPN". `kind` names the relationship in the tool's words. */
-export interface SemanticEdge {
-    readonly from: string;
-    readonly to: string;
-    readonly kind: string;
-    readonly [field: string]: unknown;
-}
-/**
- * The grain — what one value MEANS, stated when it is not what a reader
- * would assume. This is the field that stops a model from adding
- * `jobs_local` to `jobs_replicated_in` and announcing a fleet size nobody
- * has.
- */
-export interface SemanticGrain {
-    /** The collection interval the values live on ('30m', '1h', 'daily'). */
-    readonly interval?: string;
-    /** How the values were folded ('avg', 'max', 'sum', 'count', …). */
-    readonly aggregation?: string;
-    /**
-     * Whether the values are counters. MUST be stated (true or false) whenever
-     * `aggregation` is counter-looking (see
-     * {@link COUNTER_AGGREGATION_WORDS}): summing two counters double-counts,
-     * and a reader cannot tell a counter from a gauge by looking at a number.
-     */
-    readonly is_counter?: boolean;
-    /** What was folded away ('per-port rows collapsed to per-switch'). */
-    readonly collapsed?: string;
-}
-/**
- * Where the values came from and how old they are. `measured_at` is when the
- * WORLD was measured — not when the tool ran; a tool that reads a nightly
- * export and answers in 4ms is serving yesterday.
- */
-export interface SemanticProvenance {
-    /** When the world was measured (the tool's own clock words). Required
-     *  whenever the envelope carries `series` or `facts`. */
-    readonly measured_at: string;
-    /** How stale the data was when the tool answered, in seconds. */
-    readonly age_seconds?: number;
-    /** The system of record the values were read from. Required with
-     *  `measured_at`. */
-    readonly source: string;
-    /** For file-fed collectors: the export the values rode in on. */
-    readonly source_export_date?: string;
-}
-/**
- * The ask-vs-answer decision, as data. A tool that matched three volumes for
- * one WWN should not pick one silently — it should hand the question and the
- * candidates back, typed, so the loop (or a UI) can ask.
- */
-export interface SemanticClarify {
-    readonly question: string;
-    /** The candidates the question is choosing between. May be empty — an open
-     *  question is still a question. */
-    readonly candidates: readonly unknown[];
-}
-/**
- * Rendering HINTS — the tool never renders. A UI that understands them draws
- * a better table; one that does not loses nothing, because everything load-
- * bearing is in the data fields. Dropped from the model's view entirely.
- */
-export interface SemanticRender {
-    /** The default presentation ('table', 'chart', 'prose', …). A hint. */
-    readonly default: string;
-    /** Column order for a tabular view. */
-    readonly columns?: readonly string[];
-    /** Sort hint ('avg_iops desc'). */
-    readonly sort?: string;
-    /** A note about what filtering already happened ('replicas excluded'). */
-    readonly filter_note?: string;
-    /** Chart-shape hint ('line per entity'). */
-    readonly chart_hint?: string;
-}
-/**
- * The envelope's coverage, normalized — the SAME three-list vocabulary the
- * `coverage()` / `absent()` primitives speak (checked / not checked / cannot
- * cover), in the snake_case spelling every rendered tool shape uses because
- * a model reads it more often than code does. Declared through
- * {@link DescribedResultDeclaration.coverage} with the exact `CoverageDeclaration`
- * input the `coverage()` primitive takes; the dispatch loop declares it
- * through the same channel (`tools.coverage_declared`, tracked state, the
- * final-answer limits block) — absorbed, never duplicated.
- */
-export interface SemanticCoverage {
-    readonly checked?: readonly CoverageItem[];
-    readonly not_checked?: readonly CoverageItem[];
-    readonly cannot_cover?: readonly CoverageItem[];
-}
-/**
- * {@link SemanticGrain}, spelled as code: `isCounter` is `is_counter` on the
- * wire.
- *
- * @inline
- */
-interface DescribedGrain {
-    /** The collection interval the values live on ('30m', '1h', 'daily'). */
-    readonly interval?: string;
-    /** How the values were folded ('avg', 'max', 'sum', 'count', …). */
-    readonly aggregation?: string;
-    /**
-     * Whether the values are counters — cumulative readings a reader must never
-     * add together. MUST be stated (true or false) whenever `aggregation` is
-     * counter-looking (see {@link COUNTER_AGGREGATION_WORDS}).
-     */
-    readonly isCounter?: boolean;
-    /** What was folded away ('per-port rows collapsed to per-switch'). */
-    readonly collapsed?: string;
-}
-/**
- * {@link SemanticProvenance}, spelled as code: `measuredAt`, `ageSeconds` and
- * `sourceExportDate` are `measured_at`, `age_seconds` and
- * `source_export_date` on the wire.
- *
- * @inline
- */
-interface DescribedProvenance {
-    /**
-     * When the WORLD was measured, in the tool's own clock words — never
-     * parsed. Take it from the data: the export's time for a file, the moment
-     * of the read for a live query, the newest sample for a series, and the END
-     * of the window for a value computed over one.
-     */
-    readonly measuredAt: string;
-    /** How stale the data was when the tool answered, in seconds. */
-    readonly ageSeconds?: number;
-    /** The system of record the values were read from. */
-    readonly source: string;
-    /** For file-fed collectors: the export the values rode in on. */
-    readonly sourceExportDate?: string;
-}
-/**
- * {@link SemanticRender}, spelled as code: `filterNote` and `chartHint` are
- * `filter_note` and `chart_hint` on the wire.
- *
- * @inline
- */
-interface DescribedRender {
-    /** The default presentation ('table', 'chart', 'prose', …). A hint. */
-    readonly default: string;
-    /** Column order for a tabular view. */
-    readonly columns?: readonly string[];
-    /** Sort hint ('avg_iops desc'). */
-    readonly sort?: string;
-    /** A note about what filtering already happened ('replicas excluded'). */
-    readonly filterNote?: string;
-    /** Chart-shape hint ('line per entity'). */
-    readonly chartHint?: string;
-}
-/**
- * What a tool author passes to `describedResult()` — the
- * result fields in ONE spelling, camelCase, respelled to
- * the unchanged snake_case wire ({@link ToolSemantics}).
- *
- * `provenance` is REQUIRED whenever `series` or `facts` is present, and the
- * compiler says so: a number with no source and no age is refused at run time
- * anyway, inside the tool, where the model reads the refusal. A declaration
- * with only `edges` or only a `clarify` question needs none.
- *
- * At least one of `series`, `facts`, `edges` or a non-null `clarify` must be
- * present — an envelope with no data and no question declares nothing. There
- * is no `notCovered`: the prose list the model reads is derived from
- * `coverage`, so the two can never disagree.
- */
-export type DescribedResultDeclaration = {
-    /** Measured points — `{ t, entity, metric, value }`. Needs `grain`. */
-    readonly series?: readonly SemanticSeriesPoint[];
-    /** Typed rows about entities — every row names its `entity`. */
-    readonly facts?: readonly SemanticFact[];
-    /** Typed relationships — `{ from, to, kind }`. */
-    readonly edges?: readonly SemanticEdge[];
-    /** What one value MEANS. Required with `series`. */
-    readonly grain?: DescribedGrain;
-    /** Where the values came from and how old they are. Required with
-     *  `series` or `facts`. */
-    readonly provenance?: DescribedProvenance;
-    /**
-     * What the READ behind the data covered in time (honesty step 7b) — the
-     * instants it asked for (`queried`), what the store holds (`held`, or
-     * `'unknown'` said out loud) and when the read ran (`readAt`). Every value
-     * is an ISO 8601 instant with a zone; the model reads it as declared, and
-     * the results layer files its verdict.
-     */
-    readonly period?: DeclaredPeriod;
-    /** The coverage()-vocabulary declaration this result absorbs. */
-    readonly coverage?: CoverageDeclaration;
-    /** A question the result hands back instead of picking silently. `null`
-     *  states "ambiguity was considered; there is none". It does not pause the
-     *  run — the model reads it and decides what to ask. */
-    readonly clarify?: SemanticClarify | null;
-    /** Hints for a UI. The model never reads them. */
-    readonly render?: DescribedRender;
-} & ({
-    readonly provenance: DescribedProvenance;
-} | {
-    readonly series?: undefined;
-    readonly facts?: undefined;
-});
-/**
- * The rendered semantic envelope — the exact object a tool hands back.
- * Field names are snake_case and English on purpose (the `ToolAbsence`
- * precedent): this value is read by a language model far more often than by
- * code, and `af_semantics` is the only field that exists for the machine.
- */
-export interface ToolSemantics {
-    readonly af_semantics: true;
-    readonly series?: readonly SemanticSeriesPoint[];
-    readonly facts?: readonly SemanticFact[];
-    readonly edges?: readonly SemanticEdge[];
-    readonly grain?: SemanticGrain;
-    readonly provenance?: SemanticProvenance;
-    /** What the read behind the data covered in time — honesty step 7b; minted
-     *  only by `describedResult()`. The model reads it as declared. */
-    readonly period?: PeriodOnWire;
-    readonly coverage?: SemanticCoverage;
-    /** DERIVED from `coverage` (not checked + cannot cover), one prose line
-     *  per item — never author-set, so the list and the lists cannot drift. */
-    readonly not_covered?: readonly string[];
-    readonly clarify?: SemanticClarify | null;
-    readonly render?: SemanticRender;
-    /** The static sentence. Never interpolated — see `envelope.ts`. */
-    readonly note: string;
-}
-/**
- * The declared class of a tool's RESULTS — what kind of answer this tool
- * gives, stated by whoever wrote it (`defineTool({ resultClass })`; the
- * `capabilities` law: declared, never inferred). The `check:semantics` gate
- * keys its per-class rules on it:
- *
- *   • `'triage'` — a verdict about health or fault. Every sample result must
- *     declare coverage: a triage that cannot say what it did NOT check turns
- *     "everything looks fine" into a claim about ground it never stood on.
- *   • `'inventory'` — a population listing. Every sample result must declare
- *     coverage ("4 of 5 clusters"), and one with `facts` but no `render`
- *     hint is warned at.
- *
- * Two classes, deliberately closed: each carries a rule the gate can PROVE.
- * A class with no rule would be dead vocabulary.
- */
-export type ToolResultClass = 'triage' | 'inventory';
-/** The closed set, as data — validators and docs read one list. */
-export declare const RESULT_CLASSES: readonly ToolResultClass[];
-/**
- * Aggregation words that suggest the values are counters — the words that
- * make `grain.is_counter` REQUIRED (stated true or false). Matched as whole
- * tokens, singular or plural, case-insensitive.
- */
-export declare const COUNTER_AGGREGATION_WORDS: readonly string[];
-/**
- * The static sentence every semantic envelope carries in the model's view.
- * Never interpolated (the `ABSENCE_NOTE` law): everything else the model
- * reads is the tool's own data, and a note that quoted any of it back would
- * hand the evidence corpus a second copy of values it already indexes.
- */
-export declare const SEMANTICS_NOTE: string;
-export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/types/lib/semantics/types.d.ts.map

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

package/dist/types/lib/time-travel/epochs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"epochs.d.ts","sourceRoot":"","sources":["../../../../src/lib/time-travel/epochs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG9C,OAAO,EAAa,KAAK,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhF;oCACoC;AACpC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C;;uCAEmC;IACnC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChD,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnD;AAED;8BAC8B;AAC9B,MAAM,WAAW,aAAa;IAC5B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC;0DACsD;IACtD,QAAQ,CAAC,GAAG,EAAE,SAAS,YAAY,EAAE,CAAC;IACtC,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;0CAEsC;IACtC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IACzC;mFAC+E;IAC/E,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,kDAAkD;IAClD,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,qDAAqD;IACrD,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B;;gEAE4D;IAC5D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,CAOtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,MAAM,EAAE,CAO9F;AAoCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,aAAa,EAAE,CASxE;AAgED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAGxE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAG3E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAG7E"}

package/dist/types/lib/time-travel/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * time-travel/ — the agent's stops on a reader's cursor, and what the model
- * was handed at each of them.
- *
- * Role: Fold. See README.md for what a milestone stop is, what a receipt and a
- * served view are, and how one strategy and one epoch owner serve both chart
- * shapes.
- */
-export { milestoneOf, milestoneStops, milestoneStopsStrategy } from './milestoneStops.js';
-export { epochAt, epochLocations, llmCallMountKeys, readAfterCall, readAtCall, readRunConstant, recordingOf, type EpochLocation, type RecordingLike, } from './epochs.js';
-export { keyedFold, type FoldBasis, type FoldSourceLike, type KeyedFold } from './keyedFold.js';
-export { buildReceipt, messageDigestInput, toolDigestInput, receiptHash, stableJson, transformHashOf, TRANSFORM_HASH_PREFIX, FORCED_OUTPUT_TOOL_KEY, RECEIPT_BOUNDARY, RECEIPT_HASH_CHARS, RECEIPT_KEY, UNSERIALIZABLE, type Receipt, type ReceiptAttentionOmission, type ReceiptCacheMarker, type ReceiptMessage, type ReceiptParams, type ReceiptPiece, type ReceiptRequestOnlyMessage, type RequestMeasurement, type RequestJsonSize, type StoredReceipt, } from './receipt.js';
-export { sha256Hex } from './sha256.js';
-export { receiptAt, servedAt, servedViews, SERVED_GAPS, UNGAPPED_FIELDS, type ServedGap, type ServedGapCause, type ServedGapKind, type ServedPiece, type ServedRequestOnly, type ServedView, } from './servedView.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/time-travel/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/time-travel/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EACL,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,eAAe,EACf,WAAW,EACX,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,WAAW,EACX,UAAU,EACV,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,KAAK,OAAO,EACZ,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EACL,SAAS,EACT,QAAQ,EACR,WAAW,EACX,WAAW,EACX,eAAe,EACf,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,UAAU,GAChB,MAAM,iBAAiB,CAAC"}

package/dist/types/lib/time-travel/keyedFold.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyedFold.d.ts","sourceRoot":"","sources":["../../../../src/lib/time-travel/keyedFold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,UAAU,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjD;AAmCD;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC5C;AAqGD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,SAAS,CAmGvE"}

package/dist/types/lib/time-travel/milestoneStops.d.ts

@@ -1,150 +0,0 @@
-/**
- * milestoneStops — the agent's own scrub stops, derived from its commit log.
- *
- * Role:  Fold. It reads a finished run's commit log and answers one question —
- *        "which positions in this run is a reader allowed to stop at?" It
- *        executes nothing, records nothing, and stores nothing beside the log.
- * Reads: a recorded commit log (plus the execution tree when the caller has
- *        it), and `conventions.ts` · `milestoneFor` for the domain vocabulary.
- * Emits: N/A.
- *
- * WHY THIS FILE EXISTS. footprintjs ships the reader's cursor (`timeTravel`)
- * and one stop grammar — `commitStops`, one stop per executed stage — because
- * that is the only grammar the substrate itself knows. It does NOT know what an
- * LLM turn is. agentfootprint does: `milestoneFor` has classified a local stage
- * id into an iteration / slot / llm-turn / tool-call / decision since 9.x, and
- * until 9.87 every consumer that wanted a milestone slider mapped that
- * classifier onto commits by hand. This is that mapping, once, on the strategy
- * seam the port opened — so the agent SUPPLIES the stops for its own runs and
- * every reader gets the same axis.
- *
- * WHAT IT IS (9.89.0). A FILTER over the port's own axis. footprintjs 9.18
- * shipped `filterStops(stops, keep)` — the bookend guard, the re-partition and
- * a `meta` slot on the stop — because two consumers had each re-derived all
- * three by hand against 9.17, this file among them. The hand-rolled copies are
- * gone: the one owner of the `[start, …stages, end]` contract is the library
- * that returns it, and this strategy is one expression over it. The axis is
- * byte-for-byte the 9.88.0 axis (`test/lib/time-travel/milestone-stops-equivalence.test.ts` pins
- * that against a verbatim copy of the 9.88.0 implementation); what is new is that the milestone now RIDES on the
- * stop as `meta`, and that a start which absorbed pre-milestone stages says so
- * with `prologue: true`.
- *
- * WHAT IT IS NOT. Not a second cursor. A strategy only says where the one
- * cursor may rest; `timeTravel` still owns the position, the folds and the
- * marks. And not a re-walk: a milestone that was never committed gets no stop,
- * because a cursor that stops where no evidence exists is telling a story
- * rather than reading one.
- */
-import type { StageSnapshot } from 'footprintjs/advanced';
-import type { CommitBundle, Stop, TimeTravelStrategy } from 'foottrace';
-import { type Milestone } from '../../conventions.js';
-/**
- * The milestone a stop stands for, or `null` when it stands for none (the
- * `'start'` / `'end'` bookends).
- *
- * A stop that {@link milestoneStops} made carries its milestone as
- * `stop.meta`, and that is what is read — the classification the strategy
- * made when it put the stop on the axis, not a second run of the classifier.
- * A stop from ANOTHER strategy — the port's own `commitStops`, or a consumer's
- * filter that kept the stop without a milestone meta — has none, so the answer
- * falls back to where it always came from: `milestoneFor` over the stop's
- * `runtimeStageId`. Same classifier, same answer; a `meta` of some other
- * vocabulary is not mistaken for ours.
- *
- * @example
- * ```ts
- * const stop = cursor.at()!;
- * milestoneOf(stop)?.kind;   // 'llm-turn'
- * ```
- */
-export declare function milestoneOf(stop: Stop<unknown>): Milestone | null;
-/**
- * Derive one stop per committed MILESTONE from a recorded commit log.
- *
- * The rule, in one sentence: take footprintjs's own per-stage axis, keep the
- * stages `milestoneFor` classifies, and give the survivors the log back.
- *
- * **Composed, never re-derived.** The hard parts of the per-stage axis are
- * already solved upstream and are not repeated here: one stop per
- * `runtimeStageId` at its FIRST commit (a subflow mount commits twice, a
- * parallel fork child commits twice and siblings interleave — every repeat is
- * an empty bundle), the authoritative mount set read off the execution tree,
- * the `'start'` / `'end'` bookends, and the id-less leading commit that carries
- * a subflow's `inputMapper` seed. And since 9.89.0 the COMPOSITION itself is
- * the port's too: `filterStops` checks the `[start, …stages, end]` shape,
- * keeps what `keep` keeps, and re-partitions the log. A second implementation
- * of any of that would be a second chance to disagree with the library about
- * what a stage is.
- *
- * **The survivors re-partition the log.** A stage that classifies `null` is not
- * a stop, but its commits still happened, so they are folded into the stop that
- * PRECEDES them: every kept stop's `lastCommitIdx` is extended to just before
- * the next kept stop begins. Nothing is orphaned, and `stateAt(stop)` remains
- * exactly "the state that existed when the next milestone's stage started".
- * Commits before the FIRST milestone belong to `'start'` for the same reason —
- * so on a drilled cursor `'start'` reads as "what this subflow began with,
- * after its plumbing ran".
- *
- * **What that costs `'start'`, and the flag that says so.** On footprintjs's
- * own axis `'start'` is the fold base: the state before ANY stage ran. Here it
- * absorbs every stage that ran before the first milestone, so `stateAt(start)`
- * is the state the first milestone READ, not the run's raw base — a real agent
- * seeds a couple of dozen keys in `seed` before anything a reader would scrub
- * to. That is the right answer for this axis (the stops must still partition
- * the log), and since 9.18 the port marks it: the returned start carries
- * `prologue: true` whenever it absorbed a stage, so a renderer that means
- * "before anything ran" checks `kind === 'start' && !prologue` instead of
- * assuming it from the kind.
- *
- * **The milestone rides on the stop.** Every kept stop carries its
- * classification as `meta` — `Stop<Milestone>` — so a reader asks
- * `stop.meta?.kind` (or {@link milestoneOf}, which reads the same slot) rather
- * than re-running the classifier over the id. The bookends carry none.
- *
- * **A log with no milestones in it at all.** A non-empty log the classifier
- * recognises nothing in — a non-agent chart handed this strategy — yields the
- * two bookends and nothing between them: `'start'` folds the whole log,
- * `'end'` folds the whole log, and `jumpTo` any stage id refuses with
- * `reason: 'miss'`. An axis with nowhere meaningful to stand, which is the
- * truthful shape for a run that has no milestones — not an error, and not the
- * empty `[]` that says the log itself was empty.
- *
- * **It does not know which log it was given.** The classifier reads the LOCAL
- * segment of a stage id, so `sf-llm-call#3` on a run's outer log and
- * `sf-llm-call/call-llm#7` on that mount's drilled inner history are both
- * classified without the strategy being told which one it is holding. That is
- * what lets one strategy serve `reactMode: 'dynamic'` (the `call-llm` bundle is
- * in the outer log → an llm-turn stop on the outer cursor) and
- * `'dynamic-grouped'` (the outer log holds `sf-llm-call` mounts → iteration
- * stops; `drill()` gives the inner cursor, where the same strategy finds the
- * llm-turn, tool-call and decision stops).
- *
- * @param commitLog     the run's `commitLog`, or a subflow's own `history`.
- * @param executionTree the run's `executionTree`, when the caller has it — it
- *   is what makes a mount stop say `kind: 'mount'` rather than being guessed
- *   from bundle shape.
- *
- * @example
- * ```ts
- * import { timeTravel } from 'foottrace';
- * import { milestoneStopsStrategy } from 'agentfootprint';
- *
- * const cursor = timeTravel(agent.getSnapshot()!, { strategy: milestoneStopsStrategy });
- * cursor.stops.map((s) => [s.label, s.meta?.kind]);
- * // measured on a two-turn `dynamic` run — 42 commits, 15 stops:
- * // [['Run start', undefined], ['Iteration', 'iteration'],
- * //  ['System prompt', 'slot'], ['Messages', 'slot'], ['Tools', 'slot'],
- * //  ['LLM turn', 'llm-turn'], ['Route', 'decision'], ['Tool call', 'tool-call'],
- * //  … the second turn …, ['Run end', undefined]]
- * cursor.stops[0].prologue; // true — `seed` and the plumbing ran before the first Iteration
- * ```
- */
-export declare function milestoneStops(commitLog: readonly CommitBundle[], executionTree?: StageSnapshot): Stop<Milestone>[];
-/**
- * `milestoneStops` as a footprintjs `TimeTravelStrategy` — what you hand
- * `timeTravel(snapshot, { strategy })`. Typed over {@link Milestone}, so the
- * cursor's stops are `Stop<Milestone>` and `cursor.at()?.meta?.kind` is typed;
- * it is still assignable wherever a bare `TimeTravelStrategy` is expected.
- */
-export declare const milestoneStopsStrategy: TimeTravelStrategy<Milestone>;
-//# sourceMappingURL=milestoneStops.d.ts.map

package/dist/types/lib/time-travel/milestoneStops.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"milestoneStops.d.ts","sourceRoot":"","sources":["../../../../src/lib/time-travel/milestoneStops.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,sBAAsB,CAAC;AAS9B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CAGjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,YAAY,EAAE,EAClC,aAAa,CAAC,EAAE,aAAa,GAC5B,IAAI,CAAC,SAAS,CAAC,EAAE,CAKnB;AA6BD;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,SAAS,CAAgC,CAAC"}