@unbrained/pm-cli 2026.10.14 → 2026.10.17

package/dist/sdk/history/attestation-contract.d.ts

@@ -3,101 +3,101 @@
  */
 import type { HistoryHashAlgorithm } from "../../core/history/digest.js";
 /** Wire format, hashing rules and trust boundary for detached history proofs. */
-export declare const PM_HISTORY_ATTESTATION_CONTRACT: {
-readonly format: "pm-history-attestation";
-readonly version: 1;
-readonly stream_hash: "exact_file_bytes";
-readonly rollup_hash: "stable_json_without_workspace_digest";
-readonly ordering: "stream_id_code_unit_ascending";
-readonly consistency: "per_stream_snapshot_with_change_detection";
-readonly trust: "independently_retained_bundle";
+export declare const PM_HISTORY_ATTESTATION_CONTRACT:{
+readonly format:"pm-history-attestation";
+readonly version:1;
+readonly stream_hash:"exact_file_bytes";
+readonly rollup_hash:"stable_json_without_workspace_digest";
+readonly ordering:"stream_id_code_unit_ascending";
+readonly consistency:"per_stream_snapshot_with_change_detection";
+readonly trust:"independently_retained_bundle";
 };
 /** Last maintenance event, bounded independently of stream length. */
 export interface HistoryAttestationMaintenance {
 /** Maintenance operation recorded in the stream. */
-op: string;
+op:string;
 /** Timestamp claimed by the recorded event; not trusted wall-clock proof. */
-ts: string;
+ts:string;
 /** Record digest when the event carries whole-record integrity. */
-record_hash: string | null;
+record_hash:string | null;
 }
 /** Constant-size commitment for one item, deleted-item or workspace stream. */
 export interface HistoryAttestationStream {
 /** Filename stem; no path components are allowed. */
-id: string;
+id:string;
 /** Number of nonblank JSONL records. */
-entries: number;
+entries:number;
 /** Exact byte length, including whitespace and line endings. */
-bytes: number;
+bytes:number;
 /** Digest of the complete file using the bundle's algorithm. */
-stream_digest: string;
+stream_digest:string;
 /** Latest item-state anchor, absent for an empty stream. */
-latest_after_hash: string | null;
+latest_after_hash:string | null;
 /** Latest whole-record digest, absent for legacy or empty streams. */
-latest_record_hash: string | null;
+latest_record_hash:string | null;
 /** Algorithm used by the latest entry, absent for empty streams. */
-latest_hash_algorithm: HistoryHashAlgorithm | null;
+latest_hash_algorithm:HistoryHashAlgorithm | null;
 /** Number of retained rewrite evidence records across the stream. */
-rewrite_count: number;
+rewrite_count:number;
 /** SHA-256 commitment to the pruned prefix, when a compact checkpoint exists. */
-checkpoint_digest: string | null;
+checkpoint_digest:string | null;
 /** Last maintenance operation visible in this snapshot. */
-last_maintenance: HistoryAttestationMaintenance | null;
+last_maintenance:HistoryAttestationMaintenance | null;
 }
 /** Versioned detached proof; no item content, actors or filesystem roots are embedded. */
 export interface HistoryAttestation {
 /** Identifies the public wire format. */
-format: typeof PM_HISTORY_ATTESTATION_CONTRACT.format;
+format:typeof PM_HISTORY_ATTESTATION_CONTRACT.format;
 /** Format revision governing canonicalization and verification. */
-version: 1;
+version:1;
 /** Algorithm for stream byte commitments and the workspace rollup. */
-hash_algorithm: HistoryHashAlgorithm;
+hash_algorithm:HistoryHashAlgorithm;
 /** Export timestamp bound by the rollup; an assertion, not an external timestamp. */
-generated_at: string;
+generated_at:string;
 /** Sorted complete inventory of retained history streams. */
-streams: HistoryAttestationStream[];
+streams:HistoryAttestationStream[];
 /** Digest of every other field using deterministic stable JSON. */
-workspace_digest: string;
+workspace_digest:string;
 }
 /** Workspace selection without settings, extensions, locks or derived caches. */
 export interface HistoryAttestationOptions {
 /** Explicit tracker root containing the history directory. */
-pmRoot?: string;
+pmRoot?:string;
 /** Directory used for ordinary tracker discovery when pmRoot is omitted. */
-cwd?: string;
+cwd?:string;
 }
 /** Optional reproducibility controls for proof export. */
 export interface ExportAttestationOptions extends HistoryAttestationOptions {
 /** Defaults to SHA-256; independent of each stream's record algorithm. */
-hashAlgorithm?: HistoryHashAlgorithm;
+hashAlgorithm?:HistoryHashAlgorithm;
 /** RFC 3339 timestamp for reproducible exports; defaults to current time. */
-generatedAt?: string;
+generatedAt?:string;
 }
 /** Exact comparison against an independently retained proof. */
 export interface HistoryAttestationVerification {
 /** True only when all attested streams verify and the complete inventory matches. */
-ok: boolean;
+ok:boolean;
 /** Rollup from the validated input bundle. */
-workspace_digest: string;
+workspace_digest:string;
 /** Number of current streams inspected, including added streams. */
-streams_checked: number;
+streams_checked:number;
 /** Streams whose bytes differ, even when their rewritten chains remain valid. */
-changed_streams: string[];
+changed_streams:string[];
 /** Attested streams absent from the current inventory. */
-missing_streams: string[];
+missing_streams:string[];
 /** Current streams absent from the attested inventory. */
-added_streams: string[];
+added_streams:string[];
 /** Streams that cannot be decoded, read or verified. */
-invalid_streams: string[];
+invalid_streams:string[];
 /** Digest transitions with bounded maintenance context; never silently accepted as unchanged. */
-transitions: Array<{
+transitions:Array<{
 /** Changed stream identity. */
-id: string;
+id:string;
 /** Previously attested exact-byte digest. */
-before_digest: string;
+before_digest:string;
 /** Current exact-byte digest, or null if unreadable. */
-after_digest: string | null;
+after_digest:string | null;
 /** Current maintenance marker, useful when reviewing an intentional rewrite. */
-last_maintenance: HistoryAttestationMaintenance | null;
+last_maintenance:HistoryAttestationMaintenance | null;
 }>;
 }

package/dist/sdk/history/attestation-scan.d.ts

@@ -3,14 +3,14 @@ import type { HistoryAttestationStream } from "./attestation-contract.js";
 /** Snapshot row retained even when a stream is malformed or unreadable. */
 export interface AttestationScanRow {
 /** Filename stem from the complete directory inventory. */
-id: string;
+id:string;
 /** Byte digest when reading succeeded. */
-digest: string | null;
+digest:string | null;
 /** Verified payload-free stream summary, or null on invalid input. */
-stream: HistoryAttestationStream | null;
+stream:HistoryAttestationStream | null;
 }
 /**
  * Capture all retained streams and reject observed concurrent changes. This is
  * a per-stream snapshot, not a transaction across unrelated history writers.
  */
-export declare function scanAttestationStreams(pmRoot: string, algorithm: HistoryHashAlgorithm): Promise<AttestationScanRow[]>;
+export declare function scanAttestationStreams(pmRoot:string,algorithm:HistoryHashAlgorithm):Promise<AttestationScanRow[]>;

package/dist/sdk/history/attestation.d.ts

@@ -1,8 +1,8 @@
-import { type ExportAttestationOptions, type HistoryAttestation, type HistoryAttestationOptions, type HistoryAttestationVerification } from "./attestation-contract.js";
+import { type ExportAttestationOptions,type HistoryAttestation,type HistoryAttestationOptions,type HistoryAttestationVerification } from "./attestation-contract.js";
 export * from "./attestation-contract.js";
 /** Validate untrusted JSON and its rollup before treating it as an expected commitment. */
-export declare function parseHistoryAttestation(value: unknown): HistoryAttestation;
+export declare function parseHistoryAttestation(value:unknown):HistoryAttestation;
 /** Export every retained item/workspace stream; refuse incomplete or invalid evidence. */
-export declare function exportAttestation(options?: ExportAttestationOptions): Promise<HistoryAttestation>;
+export declare function exportAttestation(options?:ExportAttestationOptions):Promise<HistoryAttestation>;
 /** Compare exact bytes with a trusted detached bundle; append and maintenance changes remain visible. */
-export declare function verifyAttestation(bundleInput: unknown, options?: HistoryAttestationOptions): Promise<HistoryAttestationVerification>;
+export declare function verifyAttestation(bundleInput:unknown,options?:HistoryAttestationOptions):Promise<HistoryAttestationVerification>;

package/dist/sdk/history/maintenance.d.ts

@@ -2,70 +2,70 @@ import { type VerifiedHistoryRewriteState } from "../../core/history/history-rew
 import { verifyHistoryChain } from "../../core/history/replay.js";
 import type { ItemTypeRegistry } from "../../core/item/type-registry.js";
 import { readLocatedItem } from "../../core/store/item-store.js";
-import type { HistoryEntry, PmSettings } from "../../types/index.js";
+import type { HistoryEntry,PmSettings } from "../../types/index.js";
 import type { HistorySubject } from "./subject.js";
 /** Built-in maintenance policies; each keeps its established diagnostics and hook names. */
 export type HistoryMaintenanceOperation = "history-redact" | "history-repair" | "history-compact";
 /** Shared execution controls for a preview or audited stream rewrite. */
 export interface HistoryMaintenanceOptions {
 /** Compute and verify the plan without acquiring a write lock or persisting it. */
-dryRun?: boolean;
+dryRun?:boolean;
 /** Explicit principal override; otherwise use the workspace identity policy. */
-author?: string;
+author?:string;
 /** Explicit ownership or stale-lock override passed through the existing governance checks. */
-force?: boolean;
+force?:boolean;
 }
 /** Inputs captured before a transform, bound to the later under-lock drift checks. */
 export interface HistoryMaintenanceSnapshot {
 /** Original bytes used to decode `entries`, never a second independent read. */
-raw: string;
+raw:string;
 /** Original stream, including historical anchors and immutable record evidence. */
-entries: HistoryEntry[];
+entries:HistoryEntry[];
 /** Chain verdict for the original entries; repair may deliberately accept drift. */
-verification: ReturnType<typeof verifyHistoryChain>;
+verification:ReturnType<typeof verifyHistoryChain>;
 /** Current item bytes and document, or null for a deleted item's retained history. */
-loadedItem: Awaited<ReturnType<typeof readLocatedItem>> | null;
+loadedItem:Awaited<ReturnType<typeof readLocatedItem>> | null;
 /** Resolved identity shared by audit entry construction and lock ownership. */
-author: string;
+author:string;
 }
 /** Verified outcome supplied to the operation's existing public result renderer. */
 export interface HistoryMaintenanceOutcome {
 /** Verification of the exact planned entries before persistence. */
-verification: ReturnType<typeof verifyHistoryChain>;
+verification:ReturnType<typeof verifyHistoryChain>;
 /** Governance and write-hook warnings, empty for a preview or unchanged plan. */
-warnings: string[];
+warnings:string[];
 }
 /** Operation-owned transform with optional transactional item changes and receipt checks. */
 export interface HistoryMaintenancePlan<Result> {
 /** Whether the transformation warrants persistence when not previewing. */
-changed: boolean;
+changed:boolean;
 /** Final stream including any operation-specific baseline or audit marker. */
-rewrittenEntries: HistoryEntry[];
+rewrittenEntries:HistoryEntry[];
 /** Additional evidence check executed under the lock before any write. */
-beforeWrite?: () => Promise<void>;
+beforeWrite?:() => Promise<void>;
 /** Override only when history and item bytes must share a rollback transaction. */
-applyRewrite?: (verified: VerifiedHistoryRewriteState) => Promise<void>;
+applyRewrite?:(verified:VerifiedHistoryRewriteState) => Promise<void>;
 /** Override when the operation must also dispatch item hooks or derived-index warnings. */
-afterWrite?: () => Promise<string[]>;
+afterWrite?:() => Promise<string[]>;
 /** Preserve the operation's public report shape after preview or application completes. */
-report: (outcome: HistoryMaintenanceOutcome) => Result;
+report:(outcome:HistoryMaintenanceOutcome) => Result;
 }
 /** Resolved workspace and transform supplied by built-ins or SDK integrations. */
 export interface HistoryMaintenanceParams<Result> {
 /** Initialized tracker root whose settings and subject were resolved by the caller. */
-pmRoot: string;
+pmRoot:string;
 /** Live item or retained deleted-item history selected for maintenance. */
-subject: HistorySubject;
+subject:HistorySubject;
 /** Workspace policy used consistently for the snapshot and locked write. */
-settings: PmSettings;
+settings:PmSettings;
 /** Active item-folder mapping, including package-provided types. */
-typeRegistry: ItemTypeRegistry;
+typeRegistry:ItemTypeRegistry;
 /** Maintenance policy whose diagnostic and hook compatibility must be preserved. */
-operation: HistoryMaintenanceOperation;
+operation:HistoryMaintenanceOperation;
 /** Preview and ownership controls. */
-options: HistoryMaintenanceOptions;
+options:HistoryMaintenanceOptions;
 /** Pure planning or evidence reads; persistence belongs in the returned transaction callbacks. */
-transform: (snapshot: HistoryMaintenanceSnapshot) => HistoryMaintenancePlan<Result> | Promise<HistoryMaintenancePlan<Result>>;
+transform:(snapshot:HistoryMaintenanceSnapshot) => HistoryMaintenancePlan<Result> | Promise<HistoryMaintenancePlan<Result>>;
 }
 /** Verify every transform before writing and reject concurrent item or stream changes under the lock. */
-export declare function runHistoryMaintenance<Result>(params: HistoryMaintenanceParams<Result>): Promise<Result>;
+export declare function runHistoryMaintenance<Result>(params:HistoryMaintenanceParams<Result>):Promise<Result>;

package/dist/sdk/history/salvage.d.ts

@@ -1,35 +1,35 @@
 import { type HistoryItemHashVersion } from "../../core/history/history.js";
 import type { ItemTypeRegistry } from "../../core/item/type-registry.js";
-import type { HistoryEntry, PmSettings } from "../../types/index.js";
+import type { HistoryEntry,PmSettings } from "../../types/index.js";
 import type { HistorySubject } from "../history-redact.js";
-import type { HistoryRepairCommandOptions, HistoryRepairResult } from "../history-repair.js";
+import type { HistoryRepairCommandOptions,HistoryRepairResult } from "../history-repair.js";
 /** Evidence describing only the discarded suffix, without retaining its contents. */
 export interface HistorySalvageReceipt {
 /** One-based physical line where invalid trailing bytes begin. */
-first_invalid_line: number;
+first_invalid_line:number;
 /** UTF-8 bytes removed from the suffix. */
-discarded_bytes: number;
+discarded_bytes:number;
 /** SHA-256 of the removed bytes for local backup comparison. */
-discarded_sha256: string;
+discarded_sha256:string;
 /** Number of complete verified records retained. */
-retained_entries: number;
+retained_entries:number;
 }
 /**
  * Select a hash-verified prefix. Any parseable JSON after the first invalid
  * line makes the corruption interior and therefore unsalvageable by truncation.
  */
-export declare function inspectHistoryTail(raw: string): {
-entries: HistoryEntry[];
-prefix: string;
-receipt: HistorySalvageReceipt | null;
-itemHashVersion: HistoryItemHashVersion;
+export declare function inspectHistoryTail(raw:string):{
+entries:HistoryEntry[];
+prefix:string;
+receipt:HistorySalvageReceipt | null;
+itemHashVersion:HistoryItemHashVersion;
 };
 /** Salvage one explicitly selected stream under its normal ownership and lock policy. */
-export declare function salvageHistoryTail(params: {
-pmRoot: string;
-subject: HistorySubject;
-settings: PmSettings;
-typeRegistry: ItemTypeRegistry;
-options: HistoryRepairCommandOptions;
-author: string;
-}): Promise<HistoryRepairResult>;
+export declare function salvageHistoryTail(params:{
+pmRoot:string;
+subject:HistorySubject;
+settings:PmSettings;
+typeRegistry:ItemTypeRegistry;
+options:HistoryRepairCommandOptions;
+author:string;
+}):Promise<HistoryRepairResult>;

package/dist/sdk/history/subject.d.ts

@@ -1,19 +1,19 @@
 import { locateItem } from "../../core/store/item-store.js";
 import type { PmSettings } from "../../types/index.js";
 /** Resolve initialized workspace policy once for single-stream and bulk maintenance. */
-export declare function resolveHistoryWorkspace(pmPath: string | undefined): Promise<{
-pmRoot: string;
-settings: PmSettings;
-typeRegistry: import("../../core/item/type-registry.js").ItemTypeRegistry;
+export declare function resolveHistoryWorkspace(pmPath:string | undefined):Promise<{
+pmRoot:string;
+settings:PmSettings;
+typeRegistry:import("../../core/item/type-registry.js").ItemTypeRegistry;
 }>;
 /** Canonical stream address, retaining item location only when the current item exists. */
 export interface HistorySubject {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Filesystem path used for history resolution. */
-historyPath: string;
+historyPath:string;
 /** Current item location, or null when only a deleted item's history remains. */
-located: Awaited<ReturnType<typeof locateItem>>;
+located:Awaited<ReturnType<typeof locateItem>>;
 }
 /** Resolve a current item first, then retained streams under normalized and raw legacy IDs. */
-export declare function resolveHistorySubject(pmRoot: string, id: string, settings: PmSettings, typeToFolder: Record<string, string>): Promise<HistorySubject>;
+export declare function resolveHistorySubject(pmRoot:string,id:string,settings:PmSettings,typeToFolder:Record<string,string>):Promise<HistorySubject>;

package/dist/sdk/history-analytics.d.ts

@@ -5,137 +5,137 @@
  * immutable history event index without introducing telemetry-owned state.
  */
 import { type HarnessSignalDescriptor } from "../core/shared/author.js";
-import type { HistoryEntry, ItemMetadata } from "../types/index.js";
-import { type AgentProvenanceDescriptorCoverage, type AgentProvenanceDimensionCoverage } from "./provenance.js";
+import type { HistoryEntry,ItemMetadata } from "../types/index.js";
+import { type AgentProvenanceDescriptorCoverage,type AgentProvenanceDimensionCoverage } from "./provenance.js";
 /** Bounded immutable-history window controls shared by analytics surfaces. */
 export interface HistoryAnalyticsWindowOptions {
 /** Inclusive ISO timestamp or negative day/hour duration such as -30d. */
-since?: string;
+since?:string;
 /** Maximum indexed events consumed across all pages. */
-eventLimit?: number;
+eventLimit?:number;
 /** Minimum denominator required before a rate is reported. */
-minimumSample?: number;
+minimumSample?:number;
 }
 /** Read receipt proving how much immutable history contributed. */
 export interface HistoryAnalyticsWindowReceipt {
 /** Inclusive lower bound used for the scan. */
-since: string;
+since:string;
 /** Number of indexed immutable events inspected. */
-events: number;
+events:number;
 /** Whether the configured event ceiling omitted matching rows. */
-truncated: boolean;
+truncated:boolean;
 /** Cursor that resumes after the last inspected event when truncated. */
-next_cursor?: string;
+next_cursor?:string;
 /** Derived read source. */
-source: "history_event_index";
+source:"history_event_index";
 }
 /** Live declared-versus-observed provenance report. */
 export interface ProvenanceCoverageAnalytics {
 /** Descriptor coverage for every declared dimension. */
-descriptors: AgentProvenanceDescriptorCoverage[];
+descriptors:AgentProvenanceDescriptorCoverage[];
 /** Per-harness availability over the bounded event window. */
-observations: AgentProvenanceDimensionCoverage[];
+observations:AgentProvenanceDimensionCoverage[];
 /** Declared dimensions with enough explicit samples but no observations. */
-inert: Array<{
-harness: string;
-dimension: string;
-explicit_samples: number;
+inert:Array<{
+harness:string;
+dimension:string;
+explicit_samples:number;
 }>;
 /** Dimensions no configured harness declares. */
-undeclared: string[];
+undeclared:string[];
 /** Stable warning codes suitable for health/gate adapters. */
-warnings: string[];
+warnings:string[];
 /** Bounded source receipt. */
-window: HistoryAnalyticsWindowReceipt;
+window:HistoryAnalyticsWindowReceipt;
 }
 /** One bounded attribution bucket with honest denominator states. */
 export interface FleetAttributionRow {
 /** Recorded grouping value. */
-value: string;
+value:string;
 /** Immutable events attributed to the bucket. */
-events: number;
+events:number;
 /** State-changing events attributed to the bucket. */
-state_events: number;
+state_events:number;
 /** Annotation/evidence events attributed to the bucket. */
-annotation_events: number;
+annotation_events:number;
 /** Terminal transitions attributed to the bucket. */
-closes: number;
+closes:number;
 /** Active transitions after a terminal transition in the observed window. */
-reopens: number;
+reopens:number;
 /** Issue items linked discovered_from to work closed by this bucket. */
-defect_escapes: number;
+defect_escapes:number;
 /** Terminal transitions per observed day, or null for insufficient samples. */
-throughput_per_day: number | null;
+throughput_per_day:number | null;
 /** Reopens divided by closes, or null for insufficient samples. */
-rework_rate: number | null;
+rework_rate:number | null;
 /** Defect escapes divided by closes, or null for insufficient samples. */
-defect_escape_rate: number | null;
+defect_escape_rate:number | null;
 /** Denominator state preventing tiny samples from masquerading as rates. */
-sample_status: "available" | "insufficient";
+sample_status:"available" | "insufficient";
 }
 /** One supported fleet grouping dimension. */
 export interface FleetAttributionDimension {
 /** Stable dimension name. */
-dimension: "harness" | "model" | "author_source";
+dimension:"harness" | "model" | "author_source";
 /** Whether at least one event supplied this dimension. */
-status: "available" | "unavailable";
+status:"available" | "unavailable";
 /** Deterministically sorted bounded aggregate rows. */
-rows: FleetAttributionRow[];
+rows:FleetAttributionRow[];
 }
 /** Observational fleet analytics derived only from immutable history. */
 export interface FleetAttributionAnalytics {
 /** Grouped analytics for every supported provenance dimension. */
-dimensions: FleetAttributionDimension[];
+dimensions:FleetAttributionDimension[];
 /** Minimum close denominator required for rates. */
-minimum_sample: number;
+minimum_sample:number;
 /** Safety statement retained in every transport. */
-policy: "observational_only_not_for_authorization_or_routing";
+policy:"observational_only_not_for_authorization_or_routing";
 /** Bounded source receipt. */
-window: HistoryAnalyticsWindowReceipt;
+window:HistoryAnalyticsWindowReceipt;
 }
 /** One immutable history entry paired with its owning tracked item. */
 export interface HistoryAnalyticsEvent {
 /** Tracked item owning the immutable event. */
-item_id: string;
+item_id:string;
 /** Immutable history entry consumed by analytics. */
-entry: HistoryEntry;
+entry:HistoryEntry;
 }
 /** Reusable bounded history read shared across multiple analytics projections. */
 export interface HistoryAnalyticsWindow {
 /** Immutable events retained by the configured bound. */
-events: HistoryAnalyticsEvent[];
+events:HistoryAnalyticsEvent[];
 /** Receipt describing the bounded source read. */
-receipt: HistoryAnalyticsWindowReceipt;
+receipt:HistoryAnalyticsWindowReceipt;
 }
-declare function parseHistoryAnalyticsLimit(value: number | undefined): number;
-declare function parseMinimumSample(value: number | undefined): number;
-declare function resolveHistoryAnalyticsSince(value: string | undefined): string;
+declare function parseHistoryAnalyticsLimit(value:number | undefined):number;
+declare function parseMinimumSample(value:number | undefined):number;
+declare function resolveHistoryAnalyticsSince(value:string | undefined):string;
 /** Read one reusable bounded immutable-history window. */
-export declare function readHistoryAnalyticsWindow(pmRoot: string, options: HistoryAnalyticsWindowOptions): Promise<HistoryAnalyticsWindow>;
-declare function provenanceValue(entry: HistoryEntry, dimension: FleetAttributionDimension["dimension"]): string | undefined;
-declare function statusFromEntry(entry: HistoryEntry): string | undefined;
-declare function annotationOperation(op: string): boolean;
-declare function buildFleetDimension(dimension: FleetAttributionDimension["dimension"], events: readonly HistoryAnalyticsEvent[], items: readonly Pick<ItemMetadata, "id" | "type" | "dependencies">[], terminalStatuses: ReadonlySet<string>, minimumSample: number, windowDays: number): FleetAttributionDimension;
-declare function resolveHistoryWindowDays(events: readonly HistoryAnalyticsEvent[], since: string): number;
+export declare function readHistoryAnalyticsWindow(pmRoot:string,options:HistoryAnalyticsWindowOptions):Promise<HistoryAnalyticsWindow>;
+declare function provenanceValue(entry:HistoryEntry,dimension:FleetAttributionDimension["dimension"]):string | undefined;
+declare function statusFromEntry(entry:HistoryEntry):string | undefined;
+declare function annotationOperation(op:string):boolean;
+declare function buildFleetDimension(dimension:FleetAttributionDimension["dimension"],events:readonly HistoryAnalyticsEvent[],items:readonly Pick<ItemMetadata,"id" | "type" | "dependencies">[],terminalStatuses:ReadonlySet<string>,minimumSample:number,windowDays:number):FleetAttributionDimension;
+declare function resolveHistoryWindowDays(events:readonly HistoryAnalyticsEvent[],since:string):number;
 /** Evaluate a negative-control-friendly declared-versus-observed coverage gate. */
-export declare function evaluateProvenanceCoverage(entries: readonly HistoryEntry[], descriptors: readonly HarnessSignalDescriptor[], minimumSample: number): Omit<ProvenanceCoverageAnalytics, "window">;
+export declare function evaluateProvenanceCoverage(entries:readonly HistoryEntry[],descriptors:readonly HarnessSignalDescriptor[],minimumSample:number):Omit<ProvenanceCoverageAnalytics,"window">;
 /** Read live, bounded provenance coverage from authoritative history. */
-export declare function runProvenanceCoverageAnalytics(pmRoot: string, descriptors?: readonly HarnessSignalDescriptor[], options?: HistoryAnalyticsWindowOptions): Promise<ProvenanceCoverageAnalytics>;
+export declare function runProvenanceCoverageAnalytics(pmRoot:string,descriptors?:readonly HarnessSignalDescriptor[],options?:HistoryAnalyticsWindowOptions):Promise<ProvenanceCoverageAnalytics>;
 /** Project provenance coverage from an already-read immutable-history window. */
-export declare function projectProvenanceCoverageAnalytics(window: HistoryAnalyticsWindow, descriptors?: readonly HarnessSignalDescriptor[], options?: Pick<HistoryAnalyticsWindowOptions, "minimumSample">): ProvenanceCoverageAnalytics;
+export declare function projectProvenanceCoverageAnalytics(window:HistoryAnalyticsWindow,descriptors?:readonly HarnessSignalDescriptor[],options?:Pick<HistoryAnalyticsWindowOptions,"minimumSample">):ProvenanceCoverageAnalytics;
 /** Derive bounded fleet rates grouped by harness, model, and author source. */
-export declare function runFleetAttributionAnalytics(pmRoot: string, items: readonly Pick<ItemMetadata, "id" | "type" | "dependencies">[], terminalStatuses: ReadonlySet<string>, options?: HistoryAnalyticsWindowOptions): Promise<FleetAttributionAnalytics>;
+export declare function runFleetAttributionAnalytics(pmRoot:string,items:readonly Pick<ItemMetadata,"id" | "type" | "dependencies">[],terminalStatuses:ReadonlySet<string>,options?:HistoryAnalyticsWindowOptions):Promise<FleetAttributionAnalytics>;
 /** Project fleet attribution from an already-read immutable-history window. */
-export declare function projectFleetAttributionAnalytics(window: HistoryAnalyticsWindow, items: readonly Pick<ItemMetadata, "id" | "type" | "dependencies">[], terminalStatuses: ReadonlySet<string>, options?: Pick<HistoryAnalyticsWindowOptions, "minimumSample">): FleetAttributionAnalytics;
+export declare function projectFleetAttributionAnalytics(window:HistoryAnalyticsWindow,items:readonly Pick<ItemMetadata,"id" | "type" | "dependencies">[],terminalStatuses:ReadonlySet<string>,options?:Pick<HistoryAnalyticsWindowOptions,"minimumSample">):FleetAttributionAnalytics;
 /** Pure seams for deterministic analytics and negative-control tests. */
-export declare const _testOnlyHistoryAnalytics: {
-annotationOperation: typeof annotationOperation;
-buildFleetDimension: typeof buildFleetDimension;
-parseHistoryAnalyticsLimit: typeof parseHistoryAnalyticsLimit;
-parseMinimumSample: typeof parseMinimumSample;
-provenanceValue: typeof provenanceValue;
-resolveHistoryAnalyticsSince: typeof resolveHistoryAnalyticsSince;
-resolveHistoryWindowDays: typeof resolveHistoryWindowDays;
-statusFromEntry: typeof statusFromEntry;
+export declare const _testOnlyHistoryAnalytics:{
+annotationOperation:typeof annotationOperation;
+buildFleetDimension:typeof buildFleetDimension;
+parseHistoryAnalyticsLimit:typeof parseHistoryAnalyticsLimit;
+parseMinimumSample:typeof parseMinimumSample;
+provenanceValue:typeof provenanceValue;
+resolveHistoryAnalyticsSince:typeof resolveHistoryAnalyticsSince;
+resolveHistoryWindowDays:typeof resolveHistoryWindowDays;
+statusFromEntry:typeof statusFromEntry;
 };
 export {};