@unbrained/pm-cli 2026.10.14 → 2026.10.15

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 {};

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

@@ -1,132 +1,132 @@
-import { type HistoryCompactBulkSkipReason, type HistoryCompactScope } from "../core/history/history-compact-bulk.js";
+import { type HistoryCompactBulkSkipReason,type HistoryCompactScope } from "../core/history/history-compact-bulk.js";
 import { type BulkIdsValue } from "../core/io/bulk-ids-input.js";
 import type { GlobalOptions } from "../core/shared/command-types.js";
 /** Documents the history compact command options payload exchanged by command, SDK, and package integrations. */
 export interface HistoryCompactCommandOptions {
 /** Value that configures or reports before for this contract. */
-before?: string;
+before?:string;
 /** Value that configures or reports dry run for this contract. */
-dryRun?: boolean;
+dryRun?:boolean;
 /** Value that configures or reports author for this contract. */
-author?: string;
+author?:string;
 /** Human-readable explanation suitable for logs and agent-facing output. */
-message?: string;
+message?:string;
 /** Value that configures or reports force for this contract. */
-force?: boolean;
+force?:boolean;
 }
 type HistoryCompactBoundaryKind = "default" | "version" | "timestamp";
 /** Documents the history compact result payload exchanged by command, SDK, and package integrations. */
 export interface HistoryCompactResult {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Value that configures or reports dry run for this contract. */
-dry_run: boolean;
+dry_run:boolean;
 /** Value that configures or reports changed for this contract. */
-changed: boolean;
+changed:boolean;
 /** Value that configures or reports compact boundary for this contract. */
-compact_boundary: {
-kind: HistoryCompactBoundaryKind;
-before: string | null;
-entries_compacted: number;
-entries_retained: number;
-first_retained_entry: number | null;
+compact_boundary:{
+kind:HistoryCompactBoundaryKind;
+before:string | null;
+entries_compacted:number;
+entries_retained:number;
+first_retained_entry:number | null;
 };
 /** Value that configures or reports history for this contract. */
-history: {
-path: string;
-entries_scanned: number;
-entries_after: number;
-baseline_entry_added: boolean;
-audit_entry_added: boolean;
-verify_ok: boolean;
-verify_errors: string[];
+history:{
+path:string;
+entries_scanned:number;
+entries_after:number;
+baseline_entry_added:boolean;
+audit_entry_added:boolean;
+verify_ok:boolean;
+verify_errors:string[];
 };
 /** Value that configures or reports item for this contract. */
-item: {
-exists: boolean;
-path: string | null;
-matched_chain_before: boolean | null;
+item:{
+exists:boolean;
+path:string | null;
+matched_chain_before:boolean | null;
 };
 /** Value that configures or reports warnings for this contract. */
-warnings: string[];
+warnings:string[];
 /** ISO 8601 timestamp recording when generated occurred. */
-generated_at: string;
+generated_at:string;
 }
 /** Implements run history compact for the public runtime surface of this module. */
-export declare function runHistoryCompact(id: string, options: HistoryCompactCommandOptions, global: GlobalOptions): Promise<HistoryCompactResult>;
+export declare function runHistoryCompact(id:string,options:HistoryCompactCommandOptions,global:GlobalOptions):Promise<HistoryCompactResult>;
 /** Default entry floor below which a stream is treated as already compact. */
 export declare const HISTORY_COMPACT_BULK_DEFAULT_MIN_ENTRIES = 3;
 /** Documents the bulk history compact command options payload exchanged by command, SDK, and package integrations. */
 export interface HistoryCompactBulkCommandOptions {
 /** Value that configures or reports ids for this contract. */
-ids?: BulkIdsValue;
+ids?:BulkIdsValue;
 /** Value that configures or reports scope for this contract. */
-scope?: HistoryCompactScope;
+scope?:HistoryCompactScope;
 /** Value that configures or reports all over for this contract. */
-allOver?: number;
+allOver?:number;
 /** Value that configures or reports min entries for this contract. */
-minEntries?: number;
+minEntries?:number;
 /** Value that configures or reports dry run for this contract. */
-dryRun?: boolean;
+dryRun?:boolean;
 /** Value that configures or reports author for this contract. */
-author?: string;
+author?:string;
 /** Human-readable explanation suitable for logs and agent-facing output. */
-message?: string;
+message?:string;
 /** Value that configures or reports force for this contract. */
-force?: boolean;
+force?:boolean;
 }
 /** Per-item outcome row in a bulk compaction pass. */
 export interface HistoryCompactBulkItemResult {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Value that configures or reports outcome for this contract. */
-outcome: "compacted" | "skipped" | "errored";
+outcome:"compacted" | "skipped" | "errored";
 /** Value that configures or reports entries before for this contract. */
-entries_before: number;
+entries_before:number;
 /** Value that configures or reports entries after for this contract. */
-entries_after: number | null;
+entries_after:number | null;
 /** Value that configures or reports skip reason for this contract. */
-skip_reason: HistoryCompactBulkSkipReason | null;
+skip_reason:HistoryCompactBulkSkipReason | null;
 /** Value that configures or reports changed for this contract. */
-changed: boolean;
+changed:boolean;
 /** Value that configures or reports error for this contract. */
-error: string | null;
+error:string | null;
 }
 /** Documents the bulk history compact result payload exchanged by command, SDK, and package integrations. */
 export interface HistoryCompactBulkResult {
 /** Value that configures or reports bulk for this contract. */
-bulk: true;
+bulk:true;
 /** Value that configures or reports dry run for this contract. */
-dry_run: boolean;
+dry_run:boolean;
 /** Value that configures or reports mode for this contract. */
-mode: "ids" | "scan";
+mode:"ids" | "scan";
 /** Value that configures or reports scope for this contract. */
-scope: HistoryCompactScope | null;
+scope:HistoryCompactScope | null;
 /** Value that configures or reports criteria for this contract. */
-criteria: {
-min_entries: number;
-all_over: number | null;
-policy_threshold_applied: boolean;
+criteria:{
+min_entries:number;
+all_over:number | null;
+policy_threshold_applied:boolean;
 };
 /** Value that configures or reports totals for this contract. */
-totals: {
-streams_considered: number;
-selected: number;
-items_compacted: number;
-items_skipped: number;
-items_errored: number;
+totals:{
+streams_considered:number;
+selected:number;
+items_compacted:number;
+items_skipped:number;
+items_errored:number;
 };
 /** Value that configures or reports results for this contract. */
-results: HistoryCompactBulkItemResult[];
+results:HistoryCompactBulkItemResult[];
 /** ISO 8601 timestamp recording when generated occurred. */
-generated_at: string;
+generated_at:string;
 }
 /** Enforce the `pm history-compact` target contract shared by the CLI and MCP surfaces: exactly one selection mode — a single item `<id>`, an explicit `--ids` list, or a scan selector (`--all-over` / `--closed` / `--all-streams`). */
-export declare function assertHistoryCompactTarget(id: string | undefined, bulk: {
-ids?: string[];
-allOver?: number;
-scope?: HistoryCompactScope;
-}): void;
+export declare function assertHistoryCompactTarget(id:string | undefined,bulk:{
+ids?:string[];
+allOver?:number;
+scope?:HistoryCompactScope;
+}):void;
 /**
  * Bulk history compaction: compact every history stream matching the requested
  * selection (explicit `--ids`, a `--scope` lifecycle filter, and/or an
@@ -139,5 +139,5 @@ scope?: HistoryCompactScope;
  * given, the policy's `max_entries` is used as the scan threshold so the
  * configured policy drives the sweep.
  */
-export declare function runHistoryCompactBulk(options: HistoryCompactBulkCommandOptions, global: GlobalOptions): Promise<HistoryCompactBulkResult>;
+export declare function runHistoryCompactBulk(options:HistoryCompactBulkCommandOptions,global:GlobalOptions):Promise<HistoryCompactBulkResult>;
 export {};

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

@@ -1,17 +1,17 @@
 import type { GlobalOptions } from "../core/shared/command-types.js";
-import { type HistoryCompactBulkResult, type HistoryCompactResult } from "./history-compact.js";
+import { type HistoryCompactBulkResult,type HistoryCompactResult } from "./history-compact.js";
 /** Minimal action context required by MCP history maintenance adapters. */
 export interface HistoryMcpActionContext {
 /** Optional positional item id used by single-stream mode. */
-id?: string;
+id?:string;
 /** Alias-rich MCP options normalized by the selected history adapter. */
-options: Record<string, unknown>;
+options:Record<string,unknown>;
 /** Force flag forwarded to integrity-sensitive maintenance engines. */
-force?: boolean;
+force?:boolean;
 /** Global tracker and output controls shared with native command handlers. */
-global: GlobalOptions;
+global:GlobalOptions;
 }
 /** Dispatch single-stream or all-stream history repair from an MCP payload. */
-export declare function runMcpHistoryRepairAction(context: HistoryMcpActionContext): Promise<unknown>;
+export declare function runMcpHistoryRepairAction(context:HistoryMcpActionContext):Promise<unknown>;
 /** Dispatch single or bounded bulk history compaction from an MCP payload. */
-export declare function runMcpHistoryCompactAction(context: HistoryMcpActionContext): Promise<HistoryCompactResult | HistoryCompactBulkResult>;
+export declare function runMcpHistoryCompactAction(context:HistoryMcpActionContext):Promise<HistoryCompactResult | HistoryCompactBulkResult>;