@unbrained/pm-cli 2026.10.13 → 2026.10.15

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

@@ -1,7 +1,7 @@
 import { type HistoryHashAlgorithm } from "./digest.js";
 import { canonicalDocument } from "../item/item-format.js";
 import { type HistoryItemHashVersion } from "./history.js";
-import type { HistoryEntry, HistoryPatchOp, ItemDocument } from "../../types/index.js";
+import type { HistoryEntry,HistoryPatchOp,ItemDocument } from "../../types/index.js";
 /**
  * Shared history replay/patch mechanics single-sourced for the history, restore,
  * history-redact, and history-repair commands plus the health/validate drift checks.
@@ -12,104 +12,104 @@ import type { HistoryEntry, HistoryPatchOp, ItemDocument } from "../../types/ind
  */
 export interface ReplayDocument {
 /** Value that configures or reports metadata for this contract. */
-metadata: Record<string, unknown>;
+metadata:Record<string,unknown>;
 /** Value that configures or reports body for this contract. */
-body: string;
+body:string;
 }
 /** Public contract for empty replay document, shared by SDK and presentation-layer consumers. */
-export declare const EMPTY_REPLAY_DOCUMENT: ReplayDocument;
+export declare const EMPTY_REPLAY_DOCUMENT:ReplayDocument;
 /** Implements clone empty replay document for the public runtime surface of this module. */
-export declare function cloneEmptyReplayDocument(): ReplayDocument;
+export declare function cloneEmptyReplayDocument():ReplayDocument;
 /** Implements replay hash for the public runtime surface of this module. */
-export declare function replayHash(document: ReplayDocument, version?: HistoryItemHashVersion, algorithm?: HistoryHashAlgorithm): string;
+export declare function replayHash(document:ReplayDocument,version?:HistoryItemHashVersion,algorithm?:HistoryHashAlgorithm):string;
 /**
  * Return hash candidates that preserve the semantic variant within an epoch.
  * Duplicate values are intentional: before and after candidates use the same
  * index when a patch introduces a field that distinguishes legacy epoch 2.
  */
-export declare function replayHashVerificationCandidates(document: ReplayDocument, version: HistoryItemHashVersion, algorithm?: HistoryHashAlgorithm): [string, ...string[]];
+export declare function replayHashVerificationCandidates(document:ReplayDocument,version:HistoryItemHashVersion,algorithm?:HistoryHashAlgorithm):[string,...string[]];
 /** Implements replay to item document for the public runtime surface of this module. */
-export declare function replayToItemDocument(document: ReplayDocument): ItemDocument;
+export declare function replayToItemDocument(document:ReplayDocument):ItemDocument;
 /** Converts a materialized replay document into a canonical item document. Use this when callers have already rejected the empty/deleted replay state and need restored metadata validated through the normal item-metadata rules. */
-export declare function replayToCanonicalItemDocument(document: ReplayDocument, options?: Parameters<typeof canonicalDocument>[1]): ItemDocument;
+export declare function replayToCanonicalItemDocument(document:ReplayDocument,options?:Parameters<typeof canonicalDocument>[1]):ItemDocument;
 /** Canonicalize an item document into the ordered replay form used when comparing a replayed chain against the on-disk item (restore + history-repair reconciliation). */
-export declare function toReplayDocument(document: ItemDocument): ReplayDocument;
+export declare function toReplayDocument(document:ItemDocument):ReplayDocument;
 /** Implements normalize replay patch path for the public runtime surface of this module. */
-export declare function normalizeReplayPatchPath(path: string): string;
+export declare function normalizeReplayPatchPath(path:string):string;
 /** Implements normalize replay patch ops for the public runtime surface of this module. */
-export declare function normalizeReplayPatchOps(patch: HistoryPatchOp[] | unknown): HistoryPatchOp[];
+export declare function normalizeReplayPatchOps(patch:HistoryPatchOp[] | unknown):HistoryPatchOp[];
 /** Restricts replay apply result values accepted by command, SDK, and storage contracts. */
 export type ReplayApplyResult = {
-ok: true;
-document: ReplayDocument;
+ok:true;
+document:ReplayDocument;
 } | {
-ok: false;
-error: unknown;
+ok:false;
+error:unknown;
 };
 /** Strictly apply a history patch (front_matter->metadata normalized) to a replay document. Returns a result envelope rather than throwing so each caller can format its own error contract. */
-export declare function tryApplyReplayPatch(current: ReplayDocument, patch: HistoryPatchOp[]): ReplayApplyResult;
+export declare function tryApplyReplayPatch(current:ReplayDocument,patch:HistoryPatchOp[]):ReplayApplyResult;
 /** Verify a chain and report the explicit or auto-detected item hash epoch. */
-export declare function verifyHistoryChainWithVersion(entries: HistoryEntry[]): {
-ok: boolean;
-errors: string[];
-item_hash_version?: HistoryItemHashVersion;
+export declare function verifyHistoryChainWithVersion(entries:HistoryEntry[]):{
+ok:boolean;
+errors:string[];
+item_hash_version?:HistoryItemHashVersion;
 };
 /** Deterministically verify a history chain while preserving the legacy result shape. */
-export declare function verifyHistoryChain(entries: HistoryEntry[]): {
-ok: boolean;
-errors: string[];
+export declare function verifyHistoryChain(entries:HistoryEntry[]):{
+ok:boolean;
+errors:string[];
 };
 /** Documents the lenient apply result payload exchanged by command, SDK, and package integrations. */
 export interface LenientApplyResult {
 /** Value that configures or reports document for this contract. */
-document: ReplayDocument;
+document:ReplayDocument;
 /** Value that configures or reports converted replace to add for this contract. */
-convertedReplaceToAdd: number;
+convertedReplaceToAdd:number;
 /** Value that configures or reports skipped ops for this contract. */
-skippedOps: number;
+skippedOps:number;
 }
 /** Apply a legacy patch op-by-op, recovering from drift that strict replay rejects: a `replace` whose path no longer exists is retried as `add`, and any op that still cannot apply against the current replay state is skipped. The resulting document is what the repaired entry's recomputed patch should target. */
-export declare function lenientApplyReplayPatch(current: ReplayDocument, patch: HistoryPatchOp[]): LenientApplyResult;
+export declare function lenientApplyReplayPatch(current:ReplayDocument,patch:HistoryPatchOp[]):LenientApplyResult;
 /** Documents the reanchor entry detail payload exchanged by command, SDK, and package integrations. */
 export interface ReanchorEntryDetail {
 /** Value that configures or reports index for this contract. */
-index: number;
+index:number;
 /** Value that configures or reports rehashed for this contract. */
-rehashed: boolean;
+rehashed:boolean;
 /** Value that configures or reports patch repaired for this contract. */
-patch_repaired: boolean;
+patch_repaired:boolean;
 /** Value that configures or reports converted replace to add for this contract. */
-converted_replace_to_add: number;
+converted_replace_to_add:number;
 /** Value that configures or reports skipped ops for this contract. */
-skipped_ops: number;
+skipped_ops:number;
 }
 /** Documents the reanchor result payload exchanged by command, SDK, and package integrations. */
 export interface ReanchorResult {
 /** Value that configures or reports entries for this contract. */
-entries: HistoryEntry[];
+entries:HistoryEntry[];
 /** Value that configures or reports final document for this contract. */
-finalDocument: ReplayDocument;
+finalDocument:ReplayDocument;
 /** Value that configures or reports entries rehashed for this contract. */
-entriesRehashed: number;
+entriesRehashed:number;
 /** Value that configures or reports entries patch repaired for this contract. */
-entriesPatchRepaired: number;
+entriesPatchRepaired:number;
 /** Value that configures or reports converted replace to add for this contract. */
-convertedReplaceToAdd: number;
+convertedReplaceToAdd:number;
 /** Value that configures or reports skipped ops for this contract. */
-skippedOps: number;
+skippedOps:number;
 /** Value that configures or reports details for this contract. */
-details: ReanchorEntryDetail[];
+details:ReanchorEntryDetail[];
 /** Hash epoch retained while rebuilding the stream. */
-itemHashVersion: HistoryItemHashVersion;
+itemHashVersion:HistoryItemHashVersion;
 /** Whether rewritten entries explicitly carry the hash epoch field. */
-explicitItemHashVersion: boolean;
+explicitItemHashVersion:boolean;
 }
 /** Controls whether re-anchoring preserves historical writer transitions or emits one exact hash surface. */
 export interface ReanchorHistoryOptions {
 /** Keep one semantic hash candidate for the complete rewritten stream so adjacent stored endpoints are identical. */
-continuousHashSurface?: boolean;
+continuousHashSurface?:boolean;
 /** Rebase an entry's patch onto its new replay position, retaining the original patch as immutable rewrite evidence. */
-projectPatch?: (entry: HistoryEntry, current: ReplayDocument) => HistoryPatchOp[];
+projectPatch?:(entry:HistoryEntry,current:ReplayDocument) => HistoryPatchOp[];
 }
 /**
  * Resolve the hash epoch a repair must retain.
@@ -119,8 +119,8 @@ projectPatch?: (entry: HistoryEntry, current: ReplayDocument) => HistoryPatchOp[
  * authoritative; fully implicit legacy streams stay on epoch 1. Only an
  * irreconcilably mixed stream falls forward to the current epoch.
  */
-export declare function resolveHistoryRepairItemHashVersion(entries: HistoryEntry[]): HistoryItemHashVersion;
+export declare function resolveHistoryRepairItemHashVersion(entries:HistoryEntry[]):HistoryItemHashVersion;
 /** Re-anchor a drifted history chain: replay every entry from empty, recompute the before/after hashes, and only rewrite a patch when the original op set no longer strictly applies (legacy drift). Clean entries keep their patch verbatim so the on-disk diff stays minimal. The returned chain verifies via verifyHistoryChain. */
-export declare function reanchorHistoryEntries(entries: HistoryEntry[], itemHashVersion?: HistoryItemHashVersion, options?: ReanchorHistoryOptions): ReanchorResult;
+export declare function reanchorHistoryEntries(entries:HistoryEntry[],itemHashVersion?:HistoryItemHashVersion,options?:ReanchorHistoryOptions):ReanchorResult;
 /** Implements history entries to raw for the public runtime surface of this module. */
-export declare function historyEntriesToRaw(entries: HistoryEntry[]): string;
+export declare function historyEntriesToRaw(entries:HistoryEntry[]):string;

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

@@ -1,3 +1,3 @@
 import { PmCliError } from "../shared/errors.js";
 /** Return a bounded recovery error only when verified history proves deletion. */
-export declare function buildDeletedItemError(pmRoot: string, rawId: string, idPrefix: string): Promise<PmCliError | undefined>;
+export declare function buildDeletedItemError(pmRoot:string,rawId:string,idPrefix:string):Promise<PmCliError | undefined>;

package/dist/core/history/version-address.d.ts

@@ -8,6 +8,6 @@ import type { HistoryEntry } from "../../types/index.js";
  * version addresses. Legacy checkpoints cannot prove their original ordinal;
  * refusing them prevents silently selecting a different historical state.
  */
-export declare function historyVersionOffset(history: readonly HistoryEntry[], allowUnknown: true): number | null;
+export declare function historyVersionOffset(history:readonly HistoryEntry[],allowUnknown:true):number | null;
 /** Resolve a required durable offset, refusing ambiguous legacy checkpoints. */
-export declare function historyVersionOffset(history: readonly HistoryEntry[], allowUnknown?: false): number;
+export declare function historyVersionOffset(history:readonly HistoryEntry[],allowUnknown?:false):number;

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

@@ -2,117 +2,117 @@ import type { HistoryEntry } from "../../types.js";
 /** Synthetic item id used to expose the singleton workspace audit stream. */
 export declare const WORKSPACE_HISTORY_ID = "_workspace";
 /** Return the canonical workspace history stream path. */
-export declare function getWorkspaceHistoryPath(pmRoot: string): string;
+export declare function getWorkspaceHistoryPath(pmRoot:string):string;
 /** One singleton-document mutation appended to workspace history. */
 export interface WorkspaceHistoryChange {
 /** Tracker root containing the workspace history stream. */
-pmRoot: string;
+pmRoot:string;
 /** Repository-relative or tracker-relative document identity. */
-documentPath: string;
+documentPath:string;
 /** Document value observed before the mutation. */
-before: unknown;
+before:unknown;
 /** Document value persisted by the mutation. */
-after: unknown;
+after:unknown;
 /** Stable operation name. */
-op: string;
+op:string;
 /** Optional operation key that makes retries return the original entry. */
-idempotencyKey?: string;
+idempotencyKey?:string;
 /** Attributable mutation actor. */
-author: string;
+author:string;
 /** Optional human-readable rationale. */
-message?: string;
+message?:string;
 /** Lock time-to-live in seconds. */
-lockTtlSeconds: number;
+lockTtlSeconds:number;
 /** Maximum lock wait in milliseconds. */
-lockWaitMs: number;
+lockWaitMs:number;
 }
 /** Options for one lock-scoped audited workspace singleton write. */
 export interface WorkspaceJsonWriteOptions {
 /** Tracker root containing the singleton. */
-pmRoot: string;
+pmRoot:string;
 /** Absolute singleton path. */
-filePath: string;
+filePath:string;
 /** Fully serialized JSON value to persist. */
-raw: string;
+raw:string;
 /** Stable operation name. */
-op: string;
+op:string;
 /** Optional operation identity that prevents replaying a completed write. */
-idempotencyKey?: string;
+idempotencyKey?:string;
 /** Attributable mutation actor. */
-author: string;
+author:string;
 /** Lock time-to-live in seconds. */
-lockTtlSeconds: number;
+lockTtlSeconds:number;
 /** Maximum lock wait in milliseconds. */
-lockWaitMs: number;
+lockWaitMs:number;
 /** Optional human-readable rationale. */
-message?: string;
+message?:string;
 /** Whether creating a previously absent singleton produces a history entry. */
-recordCreation?: boolean;
+recordCreation?:boolean;
 }
 /** Result of deriving one audited singleton snapshot while its lock is held. */
 export interface WorkspaceJsonMutation<Result> {
 /** Fully serialized JSON value to persist. */
-raw: string;
+raw:string;
 /** Caller-defined result derived from the same locked before-state. */
-result: Result;
+result:Result;
 }
 /** Options for deriving and writing one audited singleton under one lock. */
-export interface WorkspaceJsonMutationOptions<Result> extends Omit<WorkspaceJsonWriteOptions, "raw"> {
+export interface WorkspaceJsonMutationOptions<Result> extends Omit<WorkspaceJsonWriteOptions,"raw"> {
 /** Derive the next snapshot and receipt from the locked serialized state. */
-mutate: (beforeRaw: string | null) => WorkspaceJsonMutation<Result> | Promise<WorkspaceJsonMutation<Result>>;
+mutate:(beforeRaw:string | null) => WorkspaceJsonMutation<Result> | Promise<WorkspaceJsonMutation<Result>>;
 /** Preview the locked mutation without writing the singleton or its history. */
-dryRun?: boolean;
+dryRun?:boolean;
 }
 /** Options for one append-only workspace audit event that leaves state unchanged. */
 export interface WorkspaceAuditEventOptions {
 /** Tracker root containing the workspace history stream. */
-pmRoot: string;
+pmRoot:string;
 /** Stable operation name. */
-op: string;
+op:string;
 /** Attributable reviewer or operator. */
-author: string;
+author:string;
 /** Structured, non-secret audit metadata. */
-context: Record<string, unknown>;
+context:Record<string,unknown>;
 /** Human-readable rationale. */
-message: string;
+message:string;
 /** Lock time-to-live in seconds. */
-lockTtlSeconds: number;
+lockTtlSeconds:number;
 /** Maximum lock wait in milliseconds. */
-lockWaitMs: number;
+lockWaitMs:number;
 }
 /** Agreement between the replayed workspace stream and governed singleton files. */
 export interface WorkspaceHistoryStateAgreement {
 /** Whether every governed singleton is readable and equals its replayed value. */
-ok: boolean;
+ok:boolean;
 /** Number of singleton documents represented by the latest replayed state. */
-document_count: number;
+document_count:number;
 /** Governed documents whose on-disk JSON equals the replayed value. */
-matching_documents: string[];
+matching_documents:string[];
 /** Governed documents whose on-disk JSON differs from the replayed value. */
-mismatched_documents: string[];
+mismatched_documents:string[];
 /** Governed documents absent from disk. */
-missing_documents: string[];
+missing_documents:string[];
 /** Governed documents that cannot be read as safe workspace-local JSON. */
-unreadable_documents: string[];
+unreadable_documents:string[];
 }
 /** Authorized append-only reconciliation of one out-of-band singleton state. */
-export interface WorkspaceJsonReconciliationOptions extends Omit<WorkspaceJsonWriteOptions, "raw" | "recordCreation"> {
+export interface WorkspaceJsonReconciliationOptions extends Omit<WorkspaceJsonWriteOptions,"raw" | "recordCreation"> {
 /** Closed Decision item authorizing acceptance of the on-disk state. */
-authorizationDecision: string;
+authorizationDecision:string;
 }
 /** Restore one governed singleton from a recorded workspace history version. */
-export interface WorkspaceJsonRestoreOptions extends Omit<WorkspaceJsonWriteOptions, "raw" | "recordCreation"> {
+export interface WorkspaceJsonRestoreOptions extends Omit<WorkspaceJsonWriteOptions,"raw" | "recordCreation"> {
 /** One-based workspace history version whose document value is restored. */
-targetVersion: number;
+targetVersion:number;
 }
 /** Receipt returned after a singleton is restored from workspace history. */
 export interface WorkspaceJsonRestoreResult {
 /** Tracker-relative singleton identity. */
-document_path: string;
+document_path:string;
 /** One-based workspace history version used as the restore source. */
-restored_from_version: number;
+restored_from_version:number;
 /** Whether the on-disk singleton and latest history state changed. */
-changed: boolean;
+changed:boolean;
 }
 /**
  * Compare every singleton represented by the verified workspace stream with
@@ -120,47 +120,47 @@ changed: boolean;
  * this state-agreement check separately proves that every current singleton
  * mutation is represented by that chain.
  */
-export declare function inspectWorkspaceHistoryState(pmRoot: string): Promise<WorkspaceHistoryStateAgreement>;
+export declare function inspectWorkspaceHistoryState(pmRoot:string):Promise<WorkspaceHistoryStateAgreement>;
 /**
  * Append one workspace document mutation under the dedicated workspace-history
  * lock. Existing history is verified and replayed before the new entry is
  * derived, so concurrent writers cannot fork the chain.
  */
-export declare function appendWorkspaceHistoryChange(change: WorkspaceHistoryChange): Promise<{
-entry: HistoryEntry;
-historyPath: string;
+export declare function appendWorkspaceHistoryChange(change:WorkspaceHistoryChange):Promise<{
+entry:HistoryEntry;
+historyPath:string;
 }>;
 /** Append a verified no-state-change event to the workspace audit stream. */
-export declare function appendWorkspaceAuditEvent(options: WorkspaceAuditEventOptions): Promise<{
-entry: HistoryEntry;
-historyPath: string;
+export declare function appendWorkspaceAuditEvent(options:WorkspaceAuditEventOptions):Promise<{
+entry:HistoryEntry;
+historyPath:string;
 }>;
 /**
  * Derive and persist an audited singleton mutation from one lock-protected
  * before-state, preventing read-modify-write callers from losing updates.
  */
-export declare function mutateWorkspaceJsonWithHistory<Result>(params: WorkspaceJsonMutationOptions<Result> & {
-idempotencyKey?: undefined;
-}): Promise<{
-changed: boolean;
-result: Result;
-replayed?: false;
+export declare function mutateWorkspaceJsonWithHistory<Result>(params:WorkspaceJsonMutationOptions<Result> & {
+idempotencyKey?:undefined;
+}):Promise<{
+changed:boolean;
+result:Result;
+replayed?:false;
 }>;
 /** Mutate an audited singleton while reporting a completed operation replay. */
-export declare function mutateWorkspaceJsonWithHistory<Result>(params: WorkspaceJsonMutationOptions<Result>): Promise<{
-changed: boolean;
-result: Result;
-replayed?: false;
+export declare function mutateWorkspaceJsonWithHistory<Result>(params:WorkspaceJsonMutationOptions<Result>):Promise<{
+changed:boolean;
+result:Result;
+replayed?:false;
 } | {
-changed: false;
-result: undefined;
-replayed: true;
+changed:false;
+result:undefined;
+replayed:true;
 }>;
 /**
  * Atomically persist one caller-serialized JSON singleton and its audit entry
  * under the workspace-history lock, with compensation if history append fails.
  */
-export declare function writeWorkspaceJsonWithHistory(params: WorkspaceJsonWriteOptions): Promise<boolean>;
+export declare function writeWorkspaceJsonWithHistory(params:WorkspaceJsonWriteOptions):Promise<boolean>;
 /**
  * Append an authorized reconciliation event that adopts a reviewed on-disk
  * singleton after an out-of-band change. The existing stream is never edited:
@@ -168,14 +168,14 @@ export declare function writeWorkspaceJsonWithHistory(params: WorkspaceJsonWrite
  * singleton becomes the after-state, with the authorizing Decision recorded in
  * structured context.
  */
-export declare function reconcileWorkspaceJsonHistory(options: WorkspaceJsonReconciliationOptions): Promise<{
-changed: boolean;
-entry?: HistoryEntry;
-historyPath: string;
+export declare function reconcileWorkspaceJsonHistory(options:WorkspaceJsonReconciliationOptions):Promise<{
+changed:boolean;
+entry?:HistoryEntry;
+historyPath:string;
 }>;
 /**
  * Restore one governed JSON singleton to the value recorded at a one-based
  * workspace history version, then append the restore as a new history state so
  * replay remains forward-only and independently verifiable.
  */
-export declare function restoreWorkspaceJsonFromHistory(options: WorkspaceJsonRestoreOptions): Promise<WorkspaceJsonRestoreResult>;
+export declare function restoreWorkspaceJsonFromHistory(options:WorkspaceJsonRestoreOptions):Promise<WorkspaceJsonRestoreResult>;

package/dist/core/io/body-file.d.ts

@@ -10,6 +10,6 @@
  * injectable so the pure resolution logic stays fully unit-coverable without
  * touching disk.
  */
-export type BodyFileReader = (path: string) => Promise<string>;
+export type BodyFileReader = (path:string) => Promise<string>;
 /** Implements resolve body file content for the public runtime surface of this module. */
-export declare function resolveBodyFileContent(bodyFile: string, inlineBody: string | undefined, readFileImpl?: BodyFileReader): Promise<string>;
+export declare function resolveBodyFileContent(bodyFile:string,inlineBody:string | undefined,readFileImpl?:BodyFileReader):Promise<string>;

package/dist/core/io/bulk-ids-input.d.ts

@@ -1,24 +1,24 @@
 /** File reader injected by tests or host runtimes that virtualize argv files. */
-export type BulkIdsFileReader = (path: string) => Promise<string>;
+export type BulkIdsFileReader = (path:string) => Promise<string>;
 /** Stdin reader injected by tests or hosts that do not use process stdin. */
-export type BulkIdsStdinReader = (optionName: string) => Promise<string>;
+export type BulkIdsStdinReader = (optionName:string) => Promise<string>;
 /** Dependencies used to resolve CLI-only external ID sources. */
 export interface BulkIdsInputReaders {
 /** Read a UTF-8 `@path` payload. */
-readFile?: BulkIdsFileReader;
+readFile?:BulkIdsFileReader;
 /** Read the complete stdin payload for `-`. */
-readStdin?: BulkIdsStdinReader;
+readStdin?:BulkIdsStdinReader;
 }
 /** Transport-native bulk ID shapes accepted by SDK and MCP adapters. */
 export type BulkIdsValue = string | number | readonly (string | number)[] | undefined;
 /** Parse comma- or line-delimited item IDs with stable first-seen deduplication. */
-export declare function parseBulkIdsText(raw: string): string[];
+export declare function parseBulkIdsText(raw:string):string[];
 /** Normalize SDK/MCP scalar-or-array ID input into the list query's CSV form. */
-export declare function normalizeBulkIdsValue(value: BulkIdsValue): string | undefined;
+export declare function normalizeBulkIdsValue(value:BulkIdsValue):string | undefined;
 /**
  * Resolve one CLI `--ids` value. `-` reads newline/comma-delimited stdin and
  * `@path` reads the same grammar from a UTF-8 file; ordinary argv text accepts
  * the grammar inline. The return value is canonical CSV for existing list
  * filtering and unmatched-id accounting.
  */
-export declare function resolveCliBulkIdsInput(value: string | undefined, optionName?: string, readers?: BulkIdsInputReaders): Promise<string | undefined>;
+export declare function resolveCliBulkIdsInput(value:string | undefined,optionName?:string,readers?:BulkIdsInputReaders):Promise<string | undefined>;

package/dist/core/item/actionability.d.ts

@@ -1,35 +1,35 @@
 import type { RuntimeStatusRegistry } from "../schema/runtime-schema.js";
-import type { ItemMetadata, ItemStatus } from "../../types/index.js";
+import type { ItemMetadata,ItemStatus } from "../../types/index.js";
 import { type ItemTypeRegistry } from "./type-registry.js";
 /** Resolve dispatch semantics once for SDK callers, honoring custom and extension type aliases before built-in defaults. */
-export declare function resolveItemExecutionRole(type: string, registry?: ItemTypeRegistry): "agent" | "human" | "gate";
+export declare function resolveItemExecutionRole(type:string,registry?:ItemTypeRegistry):"agent" | "human" | "gate";
 /** Built-in ordering kinds that must remain reachable by blocker resolution. */
-export declare const ACTIONABILITY_ORDERING_KINDS: readonly string[];
+export declare const ACTIONABILITY_ORDERING_KINDS:readonly string[];
 /** Collects the blocker item ids declared by an item: the legacy scalar `blocked_by` field plus every `blocked_by` dependency edge. Ids are trimmed, de-duplicated, and returned in stable lexicographic order. This is the single source of truth for "what must close before this item can proceed", shared by `pm next` readiness classification and the close-time auto-unblock sweep. */
-export declare function collectBlockedByIds(item: Pick<ItemMetadata, "blocked_by" | "dependencies">): string[];
+export declare function collectBlockedByIds(item:Pick<ItemMetadata,"blocked_by" | "dependencies">):string[];
 /** Build every forward and reverse blocker set in one corpus pass. */
-export declare function indexBlockedByIds(corpus: readonly ItemMetadata[]): Map<string, string[]>;
+export declare function indexBlockedByIds(corpus:readonly ItemMetadata[]):Map<string,string[]>;
 /** Collect blockers from both an item's forward declarations and corpus-level reverse `blocks` edges. */
-export declare function collectBlockedByIdsFromCorpus(item: ItemMetadata, corpus: readonly ItemMetadata[]): string[];
+export declare function collectBlockedByIdsFromCorpus(item:ItemMetadata,corpus:readonly ItemMetadata[]):string[];
 /** A blocker reference resolved against the corpus and annotated with its state. */
 export interface ResolvedBlocker {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Value that configures or reports title for this contract. */
-title: string | null;
+title:string | null;
 /** Lifecycle state reported for status. */
-status: ItemStatus | null;
+status:ItemStatus | null;
 /** True when the blocker no longer gates work because the referenced item is terminal. */
-resolved: boolean;
+resolved:boolean;
 /** Whether this blocker is a cross-system locator requiring an external resolver. */
-external?: boolean;
+external?:boolean;
 /** Last holder mutation timestamp, used as a conservative external-block staleness marker. */
-blocked_since?: string;
+blocked_since?:string;
 /** Resolver identity when an integration resolved this external blocker; null means unverifiable. */
-resolver?: string | null;
+resolver?:string | null;
 }
 /** Resolves an item's blockers against a corpus index with reverse `blocks` support. */
-export declare function resolveItemBlockers(item: Pick<ItemMetadata, "blocked_by" | "dependencies"> & Partial<Pick<ItemMetadata, "id" | "updated_at">>, itemsById: Map<string, ItemMetadata>, statusRegistry: RuntimeStatusRegistry): ResolvedBlocker[];
+export declare function resolveItemBlockers(item:Pick<ItemMetadata,"blocked_by" | "dependencies"> & Partial<Pick<ItemMetadata,"id" | "updated_at">>,itemsById:Map<string,ItemMetadata>,statusRegistry:RuntimeStatusRegistry):ResolvedBlocker[];
 /**
  * Collects the normalized (trimmed, lowercased) ids of every corpus item that is
  * blocked under the single shared edge-aware definition: a non-terminal item
@@ -41,44 +41,44 @@ export declare function resolveItemBlockers(item: Pick<ItemMetadata, "blocked_by
  * `pm list-blocked` all derive blocked-ness from this set so they can never
  * silently disagree while auto-unblock keeps status-blocked items rare.
  */
-export declare function collectDependencyBlockedIds(corpus: ItemMetadata[], statusRegistry: RuntimeStatusRegistry): Set<string>;
+export declare function collectDependencyBlockedIds(corpus:ItemMetadata[],statusRegistry:RuntimeStatusRegistry):Set<string>;
 /** A classified actionable item plus the context an agent needs to act on it. */
 export interface ActionableEntry {
 /** Value that configures or reports item for this contract. */
-item: ItemMetadata;
+item:ItemMetadata;
 /** Blockers that still gate the item (resolved blockers are filtered out). */
-open_blockers: ResolvedBlocker[];
+open_blockers:ResolvedBlocker[];
 /** Ids of non-terminal items whose `blocked_by` points at this item. */
-unblocks: string[];
+unblocks:string[];
 }
 /** Result of partitioning a candidate set into ready vs blocked leaf work. */
 export interface ActionabilityReport {
 /** Active leaves with no open blockers — ready to work on now. */
-ready: ActionableEntry[];
+ready:ActionableEntry[];
 /** Active leaves with at least one open blocker — waiting to become ready. */
-blocked: ActionableEntry[];
+blocked:ActionableEntry[];
 /** Active containers with unresolved descendants, including their blocker evidence. */
-containers: ActionableEntry[];
+containers:ActionableEntry[];
 /** Unblocked leaf work that requires a human decision. */
-decisions: ActionableEntry[];
+decisions:ActionableEntry[];
 /** Unblocked leaf outcome gates held out of automatic dispatch. */
-gates: ActionableEntry[];
+gates:ActionableEntry[];
 /** Active candidates considered before the leaf/blocker split. */
-active_count: number;
+active_count:number;
 /** Active candidates skipped because they still have open descendants. */
-container_count: number;
+container_count:number;
 }
 /** Explicit dispatch opt-ins; dependency and lifecycle blocking always remain enforced. */
 export interface ActionabilitySelectionOptions {
 /** Include human decision work in the executable selection. */
-includeDecisions?: boolean;
+includeDecisions?:boolean;
 /** Include outcome gates in the executable selection. */
-includeGates?: boolean;
+includeGates?:boolean;
 /** Include containers whose descendants are still unfinished. */
-includeContainers?: boolean;
+includeContainers?:boolean;
 }
 /** Select dispatch candidates from a classified report while retaining held-out worklists. Ownership and ranking remain caller responsibilities. */
-export declare function selectActionableEntries(report: ActionabilityReport, statusRegistry: RuntimeStatusRegistry, options?: ActionabilitySelectionOptions, typeRegistry?: ItemTypeRegistry): Pick<ActionabilityReport, "ready" | "decisions" | "gates">;
+export declare function selectActionableEntries(report:ActionabilityReport,statusRegistry:RuntimeStatusRegistry,options?:ActionabilitySelectionOptions,typeRegistry?:ItemTypeRegistry):Pick<ActionabilityReport,"ready" | "decisions" | "gates">;
 /**
  * Partitions a candidate set into ready vs blocked leaf work using the corpus to
  * resolve blockers, descendants, and downstream dependents.
@@ -90,4 +90,4 @@ export declare function selectActionableEntries(report: ActionabilityReport, sta
  * blockers and the non-terminal items it would unblock. Returned lists preserve
  * the candidate order so the caller can apply its own ranking.
  */
-export declare function computeActionabilityReport(candidates: ItemMetadata[], corpus: ItemMetadata[], statusRegistry: RuntimeStatusRegistry, typeRegistry?: ItemTypeRegistry): ActionabilityReport;
+export declare function computeActionabilityReport(candidates:ItemMetadata[],corpus:ItemMetadata[],statusRegistry:RuntimeStatusRegistry,typeRegistry?:ItemTypeRegistry):ActionabilityReport;

package/dist/core/item/dependency-reference.d.ts

@@ -5,6 +5,6 @@
  * tracker so scheduling and graph governance do not confuse them with typos.
  */
 /** Return whether a dependency target is an explicit cross-system locator rather than a local pm item id. */
-export declare function isExternalDependencyReference(target: string | undefined): boolean;
+export declare function isExternalDependencyReference(target:string | undefined):boolean;
 /** Return whether dependency provenance explicitly places a target outside the local workspace. */
-export declare function isExternalDependencySourceKind(sourceKind: string | undefined): boolean;
+export declare function isExternalDependencySourceKind(sourceKind:string | undefined):boolean;