@unbrained/pm-cli 2026.10.13 → 2026.10.15

package/dist/core/governance/metadata-coverage.d.ts

@@ -15,39 +15,39 @@
 /** Minimal structural shape this module needs from an item's item metadata. */
 export interface CoverageItem {
 /** Schema type that determines the shape and validation rules for this value. */
-type: string;
+type:string;
 /** Lifecycle state reported for status. */
-status: string;
+status:string;
 /** Value that configures or reports assignee for this contract. */
-assignee?: string;
+assignee?:string;
 /** Value that configures or reports tags for this contract. */
-tags?: string[];
+tags?:string[];
 /** Value that configures or reports parent for this contract. */
-parent?: string;
+parent?:string;
 /** Value that configures or reports priority for this contract. */
-priority?: number;
+priority?:number;
 /** Value that configures or reports acceptance criteria for this contract. */
-acceptance_criteria?: string;
+acceptance_criteria?:string;
 /** Value that configures or reports estimated minutes for this contract. */
-estimated_minutes?: number;
+estimated_minutes?:number;
 /** Value that configures or reports resolution for this contract. */
-resolution?: string;
+resolution?:string;
 /** Value that configures or reports reviewer for this contract. */
-reviewer?: string;
+reviewer?:string;
 /** Value that configures or reports risk for this contract. */
-risk?: string;
+risk?:string;
 /** Confidence is a string-like enum or a numeric score depending on workspace. */
-confidence?: string | number;
+confidence?:string | number;
 /** Value that configures or reports sprint for this contract. */
-sprint?: string;
+sprint?:string;
 /** Value that configures or reports release for this contract. */
-release?: string;
-[key: string]: unknown;
+release?:string;
+[key:string]:unknown;
 }
 /** Lifecycle buckets used by grouped breakdowns and distributions. */
 export type LifecycleBucket = "open" | "in_progress" | "blocked" | "draft" | "closed" | "canceled" | "other";
 /** Stable rendering order for lifecycle buckets. */
-export declare const LIFECYCLE_BUCKET_ORDER: readonly LifecycleBucket[];
+export declare const LIFECYCLE_BUCKET_ORDER:readonly LifecycleBucket[];
 /**
  * Classifies a raw status string into a lifecycle bucket and reports whether a
  * status is terminal (closed/canceled). Callers build this from their resolved
@@ -55,26 +55,26 @@ export declare const LIFECYCLE_BUCKET_ORDER: readonly LifecycleBucket[];
  */
 export interface LifecycleClassifier {
 /** Value that configures or reports classify for this contract. */
-classify(status: string): LifecycleBucket;
+classify(status:string):LifecycleBucket;
 /** Whether terminal applies to this operation. */
-isTerminal(status: string): boolean;
+isTerminal(status:string):boolean;
 }
 /** The subset of a resolved runtime status registry this module consumes. */
 export interface StatusRegistryLike {
 /** Value that configures or reports alias to id for this contract. */
-alias_to_id: Map<string, string>;
+alias_to_id:Map<string,string>;
 /** Value that configures or reports terminal statuses for this contract. */
-terminal_statuses: Set<string>;
+terminal_statuses:Set<string>;
 /** Value that configures or reports terminal canceled statuses for this contract. */
-terminal_canceled_statuses: Set<string>;
+terminal_canceled_statuses:Set<string>;
 /** Value that configures or reports blocked statuses for this contract. */
-blocked_statuses: Set<string>;
+blocked_statuses:Set<string>;
 /** Value that configures or reports draft statuses for this contract. */
-draft_statuses: Set<string>;
+draft_statuses:Set<string>;
 /** Value that configures or reports active statuses for this contract. */
-active_statuses: Set<string>;
+active_statuses:Set<string>;
 /** Lifecycle state reported for openthe record. */
-open_status: string;
+open_status:string;
 }
 /**
  * Adapt a resolved runtime status registry into a {@link LifecycleClassifier}.
@@ -82,54 +82,54 @@ open_status: string;
  * Precedence is deliberate and disjoint: canceled → closed → blocked → draft →
  * open → in_progress (active but not the default open status) → other.
  */
-export declare function lifecycleClassifierFromStatusRegistry(registry: StatusRegistryLike): LifecycleClassifier;
+export declare function lifecycleClassifierFromStatusRegistry(registry:StatusRegistryLike):LifecycleClassifier;
 /** True when an item has no non-empty acceptance_criteria. */
-export declare function isAcMissing(item: CoverageItem): boolean;
+export declare function isAcMissing(item:CoverageItem):boolean;
 /** True when an item has no finite estimated_minutes. */
-export declare function isEstimateMissing(item: CoverageItem): boolean;
+export declare function isEstimateMissing(item:CoverageItem):boolean;
 /**
  * True when a terminal (closed/canceled) item has no non-empty resolution.
  * Resolution is only expected on terminal items, so open items are never
  * considered "resolution-missing".
  */
-export declare function isResolutionMissing(item: CoverageItem, classifier: LifecycleClassifier): boolean;
+export declare function isResolutionMissing(item:CoverageItem,classifier:LifecycleClassifier):boolean;
 /** True when an item has no non-empty reviewer. */
-export declare function isReviewerMissing(item: CoverageItem): boolean;
+export declare function isReviewerMissing(item:CoverageItem):boolean;
 /** True when an item has no non-empty risk level. */
-export declare function isRiskMissing(item: CoverageItem): boolean;
+export declare function isRiskMissing(item:CoverageItem):boolean;
 /**
  * True when an item has no confidence value. Confidence is a string-like enum
  * or a numeric score depending on workspace, so a finite number counts as
  * present and only blank/absent values are treated as missing.
  */
-export declare function isConfidenceMissing(item: CoverageItem): boolean;
+export declare function isConfidenceMissing(item:CoverageItem):boolean;
 /** True when an item has no non-empty sprint. */
-export declare function isSprintMissing(item: CoverageItem): boolean;
+export declare function isSprintMissing(item:CoverageItem):boolean;
 /** True when an item has no non-empty release. */
-export declare function isReleaseMissing(item: CoverageItem): boolean;
+export declare function isReleaseMissing(item:CoverageItem):boolean;
 /** Selection flags for {@link filterMissingMetadata}. */
 export interface MissingMetadataFilters {
 /** Value that configures or reports ac missing for this contract. */
-acMissing?: boolean;
+acMissing?:boolean;
 /** Value that configures or reports estimates missing for this contract. */
-estimatesMissing?: boolean;
+estimatesMissing?:boolean;
 /** Value that configures or reports resolution missing for this contract. */
-resolutionMissing?: boolean;
+resolutionMissing?:boolean;
 /** Value that configures or reports reviewer missing for this contract. */
-reviewerMissing?: boolean;
+reviewerMissing?:boolean;
 /** Value that configures or reports risk missing for this contract. */
-riskMissing?: boolean;
+riskMissing?:boolean;
 /** Value that configures or reports confidence missing for this contract. */
-confidenceMissing?: boolean;
+confidenceMissing?:boolean;
 /** Value that configures or reports sprint missing for this contract. */
-sprintMissing?: boolean;
+sprintMissing?:boolean;
 /** Value that configures or reports release missing for this contract. */
-releaseMissing?: boolean;
+releaseMissing?:boolean;
 /** Match items missing ANY of the tracked metadata fields (union). */
-metadataMissing?: boolean;
+metadataMissing?:boolean;
 }
 /** True when any missing-metadata filter is requested. */
-export declare function hasMissingMetadataFilter(filters: MissingMetadataFilters): boolean;
+export declare function hasMissingMetadataFilter(filters:MissingMetadataFilters):boolean;
 /**
  * Does a single item satisfy the requested missing-metadata filters?
  *
@@ -141,77 +141,77 @@ export declare function hasMissingMetadataFilter(filters: MissingMetadataFilters
  * deliberately excludes the governance fields so the long-standing flag keeps
  * its original meaning. When no filter is requested the item passes.
  */
-export declare function itemMatchesMissingMetadata(item: CoverageItem, filters: MissingMetadataFilters, classifier: LifecycleClassifier): boolean;
+export declare function itemMatchesMissingMetadata(item:CoverageItem,filters:MissingMetadataFilters,classifier:LifecycleClassifier):boolean;
 /** Filter a list of items by the requested missing-metadata predicates. */
-export declare function filterMissingMetadata<T extends CoverageItem>(items: readonly T[], filters: MissingMetadataFilters, classifier: LifecycleClassifier): T[];
+export declare function filterMissingMetadata<T extends CoverageItem>(items:readonly T[],filters:MissingMetadataFilters,classifier:LifecycleClassifier):T[];
 /** Coverage-tracked metadata fields. */
 export type CoverageField = "acceptance_criteria" | "estimated_minutes" | "resolution" | "tags" | "parent";
 /** Stable ordering of coverage fields for rendering. */
-export declare const COVERAGE_FIELD_ORDER: readonly CoverageField[];
+export declare const COVERAGE_FIELD_ORDER:readonly CoverageField[];
 /** Coverage of a single field: present vs applicable, with a rounded percent. */
 export interface FieldCoverage {
 /** Value that configures or reports present for this contract. */
-present: number;
+present:number;
 /** Items for which the field is expected (all items, except resolution = terminal only). */
-applicable: number;
+applicable:number;
 /** present/applicable * 100, rounded to one decimal; 100 when applicable is 0. */
-percent: number;
+percent:number;
 }
 /**
  * Documents the metadata coverage report payload exchanged by command, SDK, and package integrations.
  */
 export interface MetadataCoverageReport {
 /** Value that configures or reports overall for this contract. */
-overall: Record<CoverageField, FieldCoverage>;
+overall:Record<CoverageField,FieldCoverage>;
 /** Schema type that determines the shape and validation rules for this value. */
-by_type: Record<string, Record<CoverageField, FieldCoverage>>;
+by_type:Record<string,Record<CoverageField,FieldCoverage>>;
 }
 /**
  * Compute metadata coverage overall and per item type. For each tracked field
  * we report present/applicable counts and a rounded percentage. Resolution is
  * scoped to terminal items (its only applicable population).
  */
-export declare function computeMetadataCoverage(items: readonly CoverageItem[], classifier: LifecycleClassifier): MetadataCoverageReport;
+export declare function computeMetadataCoverage(items:readonly CoverageItem[],classifier:LifecycleClassifier):MetadataCoverageReport;
 /** Dimensions a breakdown can group by. */
 export type GroupDimension = "assignee" | "priority" | "tag" | "parent" | "type" | "status";
 /** Explicit label for an empty/blank group value for a given dimension. */
-export declare function emptyGroupLabel(dimension: GroupDimension): string;
+export declare function emptyGroupLabel(dimension:GroupDimension):string;
 /**
  * Documents the group row payload exchanged by command, SDK, and package integrations.
  */
 export interface GroupRow {
 /** Display label; explicit "(unassigned)"-style label for blank keys. */
-label: string;
+label:string;
 /** Stable structured key (null for the empty/blank group). */
-key: string | null;
+key:string | null;
 /** Value that configures or reports buckets for this contract. */
-buckets: Record<LifecycleBucket, number>;
+buckets:Record<LifecycleBucket,number>;
 /** Value that configures or reports total for this contract. */
-total: number;
+total:number;
 }
 /**
  * Documents the grouped breakdown payload exchanged by command, SDK, and package integrations.
  */
 export interface GroupedBreakdown {
 /** Value that configures or reports dimension for this contract. */
-dimension: GroupDimension;
+dimension:GroupDimension;
 /** Value that configures or reports rows for this contract. */
-rows: GroupRow[];
+rows:GroupRow[];
 /** Distinct items observed (an item can contribute to multiple tag rows). */
-total_items: number;
+total_items:number;
 }
 /**
  * Documents the group options payload exchanged by command, SDK, and package integrations.
  */
 export interface GroupOptions {
 /** For dimension="tag": only consider tags starting with this prefix. */
-tagPrefix?: string;
+tagPrefix?:string;
 }
 /**
  * Group items by a dimension into lifecycle-bucketed rows. Blank keys render
  * with an explicit "(unassigned)"-style label. Rows are sorted by total
  * descending, then label ascending, with the empty group sorted last on ties.
  */
-export declare function groupItemsByDimension(items: readonly CoverageItem[], dimension: GroupDimension, classifier: LifecycleClassifier, options?: GroupOptions): GroupedBreakdown;
+export declare function groupItemsByDimension(items:readonly CoverageItem[],dimension:GroupDimension,classifier:LifecycleClassifier,options?:GroupOptions):GroupedBreakdown;
 /** Lifecycle-bucket distribution across all items (for stats lifecycle section). */
-export declare function computeLifecycleDistribution(items: readonly CoverageItem[], classifier: LifecycleClassifier): Record<LifecycleBucket, number>;
+export declare function computeLifecycleDistribution(items:readonly CoverageItem[],classifier:LifecycleClassifier):Record<LifecycleBucket,number>;

package/dist/core/history/digest.d.ts

@@ -1,12 +1,12 @@
 /** Digest algorithms supported for item anchors and immutable record envelopes. */
-export declare const HISTORY_HASH_ALGORITHMS: readonly ["sha256", "sha512"];
+export declare const HISTORY_HASH_ALGORITHMS:readonly ["sha256","sha512"];
 /** Explicit algorithm accepted by history writers. */
 export type HistoryHashAlgorithm = (typeof HISTORY_HASH_ALGORITHMS)[number];
 /** Historical default, fixed permanently so unlabeled records remain readable. */
-export declare const LEGACY_HISTORY_HASH_ALGORITHM: "sha256";
+export declare const LEGACY_HISTORY_HASH_ALGORITHM:"sha256";
 /** Algorithm written on new records unless a caller explicitly selects another. */
-export declare const CURRENT_HISTORY_HASH_ALGORITHM: "sha256";
+export declare const CURRENT_HISTORY_HASH_ALGORITHM:"sha256";
 /** Validate a persisted algorithm before passing it to the crypto provider. */
-export declare function resolveHistoryHashAlgorithm(value?: string): HistoryHashAlgorithm;
+export declare function resolveHistoryHashAlgorithm(value?:string):HistoryHashAlgorithm;
 /** Hash canonical UTF-8 bytes using the declared algorithm, rejecting unknown labels. */
-export declare function historyDigest(value: string, algorithm?: string): string;
+export declare function historyDigest(value:string,algorithm?:string):string;

package/dist/core/history/drift-cache.d.ts

@@ -1,4 +1,4 @@
 /** Remove the derived drift cache after a history mutation; a missing or concurrently removed cache is already invalidated. */
-export declare function invalidateHistoryDriftCache(pmRoot: string): Promise<void>;
+export declare function invalidateHistoryDriftCache(pmRoot:string):Promise<void>;
 /** Resolve a conventional tracker root from a history stream path and invalidate its derived verification cache. */
-export declare function invalidateHistoryDriftCacheForPath(historyPath: string): Promise<void>;
+export declare function invalidateHistoryDriftCacheForPath(historyPath:string):Promise<void>;

package/dist/core/history/drift-scan.d.ts

@@ -3,39 +3,39 @@ import type { ItemMetadata } from "../../types/index.js";
 /** Documents the drift scan result payload exchanged by command, SDK, and package integrations. */
 export interface DriftScanResult {
 /** Repeated genesis ordinals and observed sequence, keyed by affected item. */
-identityDiscontinuities?: Array<HistoryIdentityDiscontinuity & {
-item_id: string;
+identityDiscontinuities?:Array<HistoryIdentityDiscontinuity & {
+item_id:string;
 }>;
 /** Value that configures or reports missing streams for this contract. */
-missingStreams: string[];
+missingStreams:string[];
 /** Value that configures or reports unreadable streams for this contract. */
-unreadableStreams: string[];
+unreadableStreams:string[];
 /** Value that configures or reports hash mismatches for this contract. */
-hashMismatches: string[];
+hashMismatches:string[];
 /** Value that configures or reports chain mismatches for this contract. */
-chainMismatches: string[];
+chainMismatches:string[];
 /** Streams written with a hash capability newer than this runtime understands. */
-versionSkews: string[];
+versionSkews:string[];
 /** Value that configures or reports drifted items for this contract. */
-driftedItems: string[];
+driftedItems:string[];
 /** Governed singleton files whose JSON differs from workspace-history replay. */
-workspaceStateMismatches: string[];
+workspaceStateMismatches:string[];
 /** Governed singleton files absent from disk. */
-workspaceStateMissing: string[];
+workspaceStateMissing:string[];
 /** Governed singleton files unreadable as safe workspace-local JSON. */
-workspaceStateUnreadable: string[];
+workspaceStateUnreadable:string[];
 }
 /** Controls how cached history stream verification is trusted when the file stat tuple still matches a previous scan. */
 export type DriftCacheHitVerification = "content_hash" | "metadata";
 /** Documents the history drift scan options shared by health, validate, and repair callers. */
 export interface DriftScanOptions {
 /** Value that configures or reports cache hit verification for this contract. */
-cacheHitVerification?: DriftCacheHitVerification;
+cacheHitVerification?:DriftCacheHitVerification;
 }
 /** Strictly verify one item using the shared stream verifier without reading or writing the corpus cache or inspecting workspace histories and documents. */
-export declare function scanItemHistoryDrift(pmRoot: string, item: ItemMetadata & {
-body: string;
-}): Promise<DriftScanResult>;
+export declare function scanItemHistoryDrift(pmRoot:string,item:ItemMetadata & {
+body:string;
+}):Promise<DriftScanResult>;
 /**
  * Scan every item's history stream for drift (missing/unreadable streams, broken
  * hash chains, and item/history hash mismatches).
@@ -46,6 +46,6 @@ body: string;
  * content hash on metadata hits; latency-sensitive health checks can opt into
  * trusting the stat tuple and skip rereading unchanged streams.
  */
-export declare function scanHistoryDrift(pmRoot: string, items: Array<ItemMetadata & {
-body: string;
-}>, options?: DriftScanOptions): Promise<DriftScanResult>;
+export declare function scanHistoryDrift(pmRoot:string,items:Array<ItemMetadata & {
+body:string;
+}>,options?:DriftScanOptions):Promise<DriftScanResult>;

package/dist/core/history/event-classification.d.ts

@@ -6,16 +6,16 @@
  */
 import type { HistoryEntry } from "../../types/index.js";
 /** Current version of the public history-event classification policy. */
-export declare const HISTORY_EVENT_CLASSIFICATION_VERSION: 1;
+export declare const HISTORY_EVENT_CLASSIFICATION_VERSION:1;
 /** Semantic effect of an immutable history event on project recency. */
 export type HistoryEventClass = "substantive" | "maintenance";
 /** Operations whose meaning is always governance or storage maintenance. */
-export declare const MAINTENANCE_HISTORY_OPERATIONS: readonly ["docs_add", "files_add", "history:author-acknowledge", "history_author_acknowledge", "history_compact", "history_compact_baseline", "history_redact", "history_repair", "history_salvage", "normalize", "release", "test_run_track", "tests_add", "tests_remove", "tests_update", "update_audit", "update_ownership_bypass"];
+export declare const MAINTENANCE_HISTORY_OPERATIONS:readonly ["docs_add","files_add","history:author-acknowledge","history_author_acknowledge","history_compact","history_compact_baseline","history_redact","history_repair","history_salvage","normalize","release","test_run_track","tests_add","tests_remove","tests_update","update_audit","update_ownership_bypass"];
 /** Operations whose meaning always advances lifecycle or working context. */
-export declare const SUBSTANTIVE_HISTORY_OPERATIONS: readonly ["append", "cancel", "claim", "close", "comment_add", "create", "learning_add", "note_add", "reopen"];
+export declare const SUBSTANTIVE_HISTORY_OPERATIONS:readonly ["append","cancel","claim","close","comment_add","create","learning_add","note_add","reopen"];
 /**
  * Classify an immutable event using its declared class when present, then the
  * versioned operation/path contract. Unknown events fail closed as substantive
  * so new work cannot silently disappear from temporal relevance.
  */
-export declare function classifyHistoryEvent(entry: Pick<HistoryEntry, "op" | "patch" | "event_class">): HistoryEventClass;
+export declare function classifyHistoryEvent(entry:Pick<HistoryEntry,"op" | "patch" | "event_class">):HistoryEventClass;

package/dist/core/history/event-index.d.ts

@@ -1,84 +1,84 @@
 import type { DatabaseSync } from "node:sqlite";
 import type { HistoryEntry } from "../../types/index.js";
-import { loadDatabaseSync, loadStableDatabaseSync } from "../store/sqlite-runtime.js";
+import { loadDatabaseSync,loadStableDatabaseSync } from "../store/sqlite-runtime.js";
 type DatabaseSyncConstructor = typeof DatabaseSync;
 /** Stable location of one history entry inside its authoritative stream. */
 export interface IndexedHistoryEvent {
 /** History stream subject, normally an item id or `_workspace`. */
-stream_id: string;
+stream_id:string;
 /** Zero-based line position among parsed entries in the stream. */
-stream_offset: number;
+stream_offset:number;
 /** Authoritative history entry. */
-entry: HistoryEntry;
+entry:HistoryEntry;
 }
 /** Index-native filters and continuation bounds for mutation events. */
 export interface HistoryEventIndexQuery {
 /** Return events strictly after this timestamp. */
-after_ts?: string;
+after_ts?:string;
 /** Stream tie-breaker paired with `after_ts`. */
-after_stream_id?: string;
+after_stream_id?:string;
 /** Offset tie-breaker paired with `after_ts` and `after_stream_id`. */
-after_stream_offset?: number;
+after_stream_offset?:number;
 /** Inclusive timestamp lower bound used when no cursor is supplied. */
-since_ts?: string;
+since_ts?:string;
 /** Include only these operation names. */
-ops?: readonly string[];
+ops?:readonly string[];
 /** Include only these authors. */
-authors?: readonly string[];
+authors?:readonly string[];
 /** Include recorded harnesses or alias authors resolving to them. */
-harnesses?: readonly string[];
+harnesses?:readonly string[];
 /** Legacy author literals accepted by the requested harness vocabulary. */
-harness_alias_authors?: readonly string[];
+harness_alias_authors?:readonly string[];
 /** Include only these privacy-safe invocation fingerprints. */
-agent_instances?: readonly string[];
+agent_instances?:readonly string[];
 /** Exact extensible provenance dimension predicates. */
-provenance?: ReadonlyArray<{
-dimension: string;
-values: readonly string[];
+provenance?:ReadonlyArray<{
+dimension:string;
+values:readonly string[];
 }>;
 /** Include only these stream subjects. */
-stream_ids?: readonly string[];
+stream_ids?:readonly string[];
 /** Maximum events returned. */
-limit: number;
+limit:number;
 }
 /** Bounded mutation-event query result from the persistent projection. */
 export interface HistoryEventIndexQueryResult {
 /** Ordered event rows. */
-events: IndexedHistoryEvent[];
+events:IndexedHistoryEvent[];
 /** Whether another matching event exists. */
-has_more: boolean;
+has_more:boolean;
 }
 /** Latest substantive immutable event for each requested history stream. */
-export type LatestSubstantiveHistoryEvents = Readonly<Record<string, IndexedHistoryEvent>>;
+export type LatestSubstantiveHistoryEvents = Readonly<Record<string,IndexedHistoryEvent>>;
 /** Rebuild the complete optional event projection from authoritative streams. */
-export declare function rebuildHistoryEventIndex(pmRoot: string): Promise<boolean>;
+export declare function rebuildHistoryEventIndex(pmRoot:string):Promise<boolean>;
 /**
  * Query authoritative history streams when the optional SQLite accelerator is
  * unavailable. The result preserves the index contract at higher read cost.
  */
-export declare function queryHistoryEventStreams(pmRoot: string, query: HistoryEventIndexQuery): Promise<HistoryEventIndexQueryResult>;
+export declare function queryHistoryEventStreams(pmRoot:string,query:HistoryEventIndexQuery):Promise<HistoryEventIndexQueryResult>;
 /**
  * Serialize an authoritative append with its optional SQLite projection.
  * The database write lock spans the file append and size capture, so compliant
  * cross-process writers cannot certify a newer stream size with older rows.
  */
-export declare function appendHistoryEntryWithEventIndex(historyPath: string, entry: HistoryEntry, append: () => Promise<void>): Promise<void>;
+export declare function appendHistoryEntryWithEventIndex(historyPath:string,entry:HistoryEntry,append:() => Promise<void>):Promise<void>;
 /** Invalidate the optional event projection after a non-append rewrite. */
-export declare function removeHistoryEventIndexForHistoryPath(historyPath: string): Promise<void>;
+export declare function removeHistoryEventIndexForHistoryPath(historyPath:string):Promise<void>;
 /** Query the optional event projection without scanning history streams. */
-export declare function queryHistoryEventIndex(pmRoot: string, query: HistoryEventIndexQuery): Promise<HistoryEventIndexQueryResult | null>;
-declare function collectLatestSubstantiveEvents(events: readonly IndexedHistoryEvent[], requested: ReadonlySet<string>): Record<string, IndexedHistoryEvent>;
+export declare function queryHistoryEventIndex(pmRoot:string,query:HistoryEventIndexQuery):Promise<HistoryEventIndexQueryResult | null>;
+declare function collectLatestSubstantiveEvents(events:readonly IndexedHistoryEvent[],requested:ReadonlySet<string>):Record<string,IndexedHistoryEvent>;
 /**
  * Read one latest substantive coordinate per requested stream. The optional
  * SQLite projection is preferred; individual authoritative streams are the
  * fail-closed fallback and remain the source of truth.
  */
-export declare function readLatestSubstantiveHistoryEvents(pmRoot: string, streamIds: readonly string[]): Promise<LatestSubstantiveHistoryEvents>;
+export declare function readLatestSubstantiveHistoryEvents(pmRoot:string,streamIds:readonly string[]):Promise<LatestSubstantiveHistoryEvents>;
 /** Test-only dependency seam for runtimes without `node:sqlite`. */
-export declare const _testOnly: {
-collectLatestSubstantiveEvents: typeof collectLatestSubstantiveEvents;
-loadDatabaseSync: typeof loadDatabaseSync;
-loadStableDatabaseSync: typeof loadStableDatabaseSync;
-setDatabaseSync(databaseSync: DatabaseSyncConstructor | null): () => void;
+export declare const _testOnly:{
+collectLatestSubstantiveEvents:typeof collectLatestSubstantiveEvents;
+loadDatabaseSync:typeof loadDatabaseSync;
+loadStableDatabaseSync:typeof loadStableDatabaseSync;
+setDatabaseSync(databaseSync:DatabaseSyncConstructor | null):() => void;
 };
 export {};

package/dist/core/history/history-compact-bulk.d.ts

@@ -26,33 +26,33 @@ export type HistoryCompactBulkSkipReason = "no_stream" | "already_compact" | "sc
  */
 export interface HistoryCompactBulkCandidate {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Value that configures or reports entries for this contract. */
-entries: number;
+entries:number;
 /** Value that configures or reports bucket for this contract. */
-bucket: LifecycleBucket | null;
+bucket:LifecycleBucket | null;
 }
 /** Selection criteria resolved from the command flags + policy defaults. */
 export interface HistoryCompactBulkCriteria {
 /** Explicit, ordered list of item ids to compact. When non-empty the selection runs in "ids" mode: scope/allOver are ignored and only the `minEntries` floor applies. Duplicates are collapsed, preserving first-seen order. */
-ids?: string[];
+ids?:string[];
 /** Lifecycle scope filter for scan mode (ignored in ids mode). */
-scope?: HistoryCompactScope;
+scope?:HistoryCompactScope;
 /** Streams with at most this many entries are skipped as `already_compact` (compaction collapses a stream to a 2-entry baseline+audit pair, so smaller streams gain nothing). Applies in both modes. */
-minEntries: number;
+minEntries:number;
 /** Scan mode only: when set, only streams with strictly more entries than this are selected. Streams above `minEntries` but at/below `allOver` are skipped as `below_threshold`. */
-allOver?: number;
+allOver?:number;
 }
 /** Per-candidate selection outcome. */
 export interface HistoryCompactBulkSelectionRow {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Value that configures or reports entries for this contract. */
-entries: number;
+entries:number;
 /** Value that configures or reports selected for this contract. */
-selected: boolean;
+selected:boolean;
 /** Value that configures or reports skip reason for this contract. */
-skip_reason: HistoryCompactBulkSkipReason | null;
+skip_reason:HistoryCompactBulkSkipReason | null;
 }
 /**
  * Decide which history streams to compact.
@@ -61,4 +61,4 @@ skip_reason: HistoryCompactBulkSkipReason | null;
  * honouring only the `minEntries` floor) and "scan" mode otherwise (every
  * candidate, filtered by scope and entry thresholds, ordered deepest-first).
  */
-export declare function selectHistoryCompactBulkTargets(candidates: HistoryCompactBulkCandidate[], criteria: HistoryCompactBulkCriteria): HistoryCompactBulkSelectionRow[];
+export declare function selectHistoryCompactBulkTargets(candidates:HistoryCompactBulkCandidate[],criteria:HistoryCompactBulkCriteria):HistoryCompactBulkSelectionRow[];

package/dist/core/history/history-diff.d.ts

@@ -2,28 +2,28 @@ import type { HistoryEntry } from "../../types/index.js";
 /** Documents the history field change payload exchanged by command, SDK, and package integrations. */
 export interface HistoryFieldChange {
 /** Value that configures or reports field for this contract. */
-field: string;
+field:string;
 /** Value that configures or reports before for this contract. */
-before: unknown;
+before:unknown;
 /** Value that configures or reports after for this contract. */
-after: unknown;
+after:unknown;
 }
 /** Documents the history diff value entry payload exchanged by command, SDK, and package integrations. */
 export interface HistoryDiffValueEntry {
 /** 1-based position in the FULL stream (fullEntries index + 1). */
-index: number;
+index:number;
 /** Value that configures or reports ts for this contract. */
-ts: string;
+ts:string;
 /** Value that configures or reports op for this contract. */
-op: string;
+op:string;
 /** Value that configures or reports author for this contract. */
-author: string;
+author:string;
 /** Number of JSON-patch operations in this entry (entry.patch.length). */
-patch_ops: number;
+patch_ops:number;
 /** Unique field names touched by this entry, sorted by localeCompare. */
-changed_fields: string[];
+changed_fields:string[];
 /** Per-field before/after values, sorted by field name (localeCompare). */
-changes: HistoryFieldChange[];
+changes:HistoryFieldChange[];
 }
 /**
  * Map a JSON-Patch path string to a human-readable changed-field name.
@@ -36,7 +36,7 @@ changes: HistoryFieldChange[];
  *  - "/" (root pointer, empty segment after strip) → "root"
  *  - anything else                               → decoded first path segment
  */
-export declare function patchPathToChangedField(path: string): string;
+export declare function patchPathToChangedField(path:string):string;
 /**
  * Replay a full history entry stream and produce enriched diff entries with
  * per-field before/after values.
@@ -49,7 +49,7 @@ export declare function patchPathToChangedField(path: string): string;
  *   emitted, and each emitted entry's `changes` and `changed_fields` are
  *   restricted to that single field.
  */
-export declare function computeHistoryDiff(fullEntries: HistoryEntry[], options?: {
-windowStartIndex?: number;
-field?: string;
-}): HistoryDiffValueEntry[];
+export declare function computeHistoryDiff(fullEntries:HistoryEntry[],options?:{
+windowStartIndex?:number;
+field?:string;
+}):HistoryDiffValueEntry[];