@unbrained/pm-cli 2026.10.14 → 2026.10.17

package/dist/sdk/docs.d.ts

@@ -9,40 +9,40 @@ import { type LinkedPathValidation } from "./linked-artifacts.js";
 /** Documents the docs command options payload exchanged by command, SDK, and package integrations. */
 export interface DocsCommandOptions {
 /** Value that configures or reports add for this contract. */
-add?: string[];
+add?:string[];
 /** Value that configures or reports add glob for this contract. */
-addGlob?: string[];
+addGlob?:string[];
 /** Value that configures or reports remove for this contract. */
-remove?: string[];
+remove?:string[];
 /** Value that configures or reports migrate for this contract. */
-migrate?: string[];
+migrate?:string[];
 /** GH-170 (pm-pfnx): standalone note applied to every --add/--add-glob link in this invocation. */
-note?: string;
+note?:string;
 /** Value that configures or reports list for this contract. */
-list?: boolean;
+list?:boolean;
 /** Value that configures or reports validate paths for this contract. */
-validatePaths?: boolean;
+validatePaths?: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;
 }
 /** Documents the docs result payload exchanged by command, SDK, and package integrations. */
 export interface DocsResult {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Value that configures or reports docs for this contract. */
-docs: LinkedDoc[];
+docs:LinkedDoc[];
 /** Value that configures or reports changed for this contract. */
-changed: boolean;
+changed:boolean;
 /** Value that configures or reports count for this contract. */
-count: number;
+count:number;
 /** Value that configures or reports migrations applied for this contract. */
-migrations_applied?: number;
+migrations_applied?:number;
 /** Value that configures or reports validation for this contract. */
-validation?: LinkedPathValidation;
+validation?:LinkedPathValidation;
 }
 /** Implements run docs for the public runtime surface of this module. */
-export declare function runDocs(id: string, options: DocsCommandOptions, global: GlobalOptions): Promise<DocsResult>;
+export declare function runDocs(id:string,options:DocsCommandOptions,global:GlobalOptions):Promise<DocsResult>;

package/dist/sdk/duplicates.d.ts

@@ -5,36 +5,36 @@
  * canonical-item guidance for CLI, MCP, and embedded SDK consumers.
  */
 import type { GlobalOptions } from "../core/shared/command-types.js";
-import { type DuplicateCluster, type DuplicateClustersResult } from "./similarity.js";
+import { type DuplicateCluster,type DuplicateClustersResult } from "./similarity.js";
 /** Options shared by the `pm duplicates` command and SDK action. */
 export interface DuplicatesCommandOptions {
 /** Compare all pairs instead of using lossless prefix filtering. */
-exhaustive?: boolean;
+exhaustive?:boolean;
 /** Lifecycle statuses to include; omitted means every status. */
-status?: readonly string[];
+status?:readonly string[];
 /** Inclusive creation timestamp lower bound. */
-since?: string;
+since?:string;
 /** Minimum similarity score from zero through one. */
-threshold?: number;
+threshold?:number;
 /** Maximum connected clusters to return. */
-limit?: number;
+limit?:number;
 }
 /** Duplicate cluster enriched with deterministic close/merge guidance. */
 export interface ActionableDuplicateCluster extends DuplicateCluster {
 /** Lexically first item id, used as the stable default canonical candidate. */
-canonical_id: string;
+canonical_id:string;
 /** Exact remediation command template for non-canonical members. */
-close_command: string;
+close_command:string;
 }
 /** Agent-facing duplicate discovery result. */
-export interface DuplicatesResult extends Omit<DuplicateClustersResult, "clusters"> {
+export interface DuplicatesResult extends Omit<DuplicateClustersResult,"clusters"> {
 /** Bounded, deterministic duplicate clusters. */
-clusters: ActionableDuplicateCluster[];
+clusters:ActionableDuplicateCluster[];
 /** Concise remediation policy shared by every presentation surface. */
-guidance: {
-strategy: "review_then_close_duplicate";
-command: "pm close <duplicate-id> --duplicate-of <canonical-id>";
+guidance:{
+strategy:"review_then_close_duplicate";
+command:"pm close <duplicate-id> --duplicate-of <canonical-id>";
 };
 }
 /** Discover existing duplicate clusters without creating or mutating an item. */
-export declare function runDuplicates(global: GlobalOptions, options?: DuplicatesCommandOptions): Promise<DuplicatesResult>;
+export declare function runDuplicates(global:GlobalOptions,options?:DuplicatesCommandOptions):Promise<DuplicatesResult>;

package/dist/sdk/environment/agent-environment.d.ts

@@ -1,296 +1,296 @@
 import { type WorkspaceRecipe } from "../workspace-recipe.js";
 /** Schema identifier for a portable observation contract. */
-export declare const PM_OBSERVATION_SCHEMA: "pm.agent-observation/v1";
+export declare const PM_OBSERVATION_SCHEMA:"pm.agent-observation/v1";
 /** Schema identifier for a deterministic verdict contract. */
-export declare const PM_VERDICT_SCHEMA: "pm.agent-verdict/v1";
+export declare const PM_VERDICT_SCHEMA:"pm.agent-verdict/v1";
 /** Schema identifier for a bounded agent-environment episode. */
-export declare const PM_EPISODE_SCHEMA: "pm.agent-episode/v1";
+export declare const PM_EPISODE_SCHEMA:"pm.agent-episode/v1";
 /** A JSON-compatible object used as immutable recorded workspace state. */
-export type RecordedStateObject = Readonly<Record<string, unknown>>;
+export type RecordedStateObject = Readonly<Record<string,unknown>>;
 /** One declared read and its guaranteed token ceiling. */
 export interface ObservationReadDeclaration {
 /** Public SDK or CLI command name used to collect the read. */
-command: string;
+command:string;
 /** Maximum tokens this read may consume. */
-budget_tokens: number;
+budget_tokens:number;
 }
 /** Emitted-byte calibration for a representative observation corpus. */
 export interface ObservationCalibration {
 /** Stable measurement basis; serialized payload bytes are authoritative. */
-basis: "emitted_bytes";
+basis:"emitted_bytes";
 /** Historical emitted-byte measurements used to calibrate expectations. */
-samples: readonly number[];
+samples:readonly number[];
 /** Expected serialized payload size before an observation is served. */
-expected_emitted_bytes: number;
+expected_emitted_bytes:number;
 /** Accepted drift around the expected emitted-byte measurement. */
-tolerance_bytes: number;
+tolerance_bytes:number;
 }
 /** Declares whether observation cost varies with corpus size. */
 export type ObservationCorpusDependence = {
-readonly kind: "independent";
+readonly kind:"independent";
 } | {
-readonly kind: "bounded";
-readonly dimension: string;
-readonly maximum: number;
+readonly kind:"bounded";
+readonly dimension:string;
+readonly maximum:number;
 };
 /** One ordered disclosure tier in an observation degradation ladder. */
 export interface ObservationTier {
 /** Stable tier identity included in every observation receipt. */
-id: string;
+id:string;
 /** Maximum tokens this tier is permitted to emit. */
-max_tokens: number;
+max_tokens:number;
 /** Dot-separated recorded-state fields disclosed by the tier. */
-fields: readonly string[];
+fields:readonly string[];
 }
 /** Portable declaration for a bounded, calibrated observation. */
 export interface ObservationContract {
 /** Versioned schema identity. */
-schema: typeof PM_OBSERVATION_SCHEMA;
+schema:typeof PM_OBSERVATION_SCHEMA;
 /** Stable contract identity. */
-id: string;
+id:string;
 /** Positive contract revision. */
-version: number;
+version:number;
 /** Reads whose ceilings form the guaranteed collection cost. */
-reads: readonly ObservationReadDeclaration[];
+reads:readonly ObservationReadDeclaration[];
 /** Emitted-byte calibration visible before collection starts. */
-calibration: ObservationCalibration;
+calibration:ObservationCalibration;
 /** Explicit corpus-size dependence of the cost model. */
-corpus_dependence: ObservationCorpusDependence;
+corpus_dependence:ObservationCorpusDependence;
 /** Ordered richest-to-smallest degradation ladder. */
-tiers: readonly ObservationTier[];
+tiers:readonly ObservationTier[];
 }
 /** Pre-call observation-cost description available to schedulers. */
 export interface ObservationCostDescription {
 /** Stable observation identity. */
-contract_id: string;
+contract_id:string;
 /** Observation revision. */
-contract_version: number;
+contract_version:number;
 /** Sum of all declared collection ceilings. */
-guaranteed_ceiling_tokens: number;
+guaranteed_ceiling_tokens:number;
 /** Calibrated expected serialized payload size. */
-expected_emitted_bytes: number;
+expected_emitted_bytes:number;
 /** Conservative token estimate derived from emitted bytes. */
-expected_tokens: number;
+expected_tokens:number;
 /** Accepted emitted-byte calibration drift. */
-tolerance_bytes: number;
+tolerance_bytes:number;
 /** Stable calibration basis. */
-calibration_basis: "emitted_bytes";
+calibration_basis:"emitted_bytes";
 /** Declared corpus-size dependence. */
-corpus_dependence: ObservationCorpusDependence;
+corpus_dependence:ObservationCorpusDependence;
 }
 /** Audit receipt emitted for every served or refused observation. */
 export interface ObservationReceipt {
 /** Stable observation identity. */
-contract_id: string;
+contract_id:string;
 /** Observation revision. */
-contract_version: number;
+contract_version:number;
 /** Tier whose payload was returned, or null after truthful refusal. */
-served_tier: string | null;
+served_tier:string | null;
 /** Whether a smaller tier was attempted or served. */
-degraded: boolean;
+degraded:boolean;
 /** Tier identities evaluated in deterministic order. */
-attempted_tiers: readonly string[];
+attempted_tiers:readonly string[];
 /** Exact serialized payload bytes, or null when nothing was served. */
-emitted_bytes: number | null;
+emitted_bytes:number | null;
 /** Conservative token estimate, or null when nothing was served. */
-estimated_tokens: number | null;
+estimated_tokens:number | null;
 /** Stable measurement basis. */
-calibration_basis: "emitted_bytes";
+calibration_basis:"emitted_bytes";
 }
 /** Successful bounded observation with its explicit receipt. */
 export interface ServedObservation<T> {
 /** Discriminator for a payload-bearing response. */
-status: "served";
+status:"served";
 /** Payload produced by the declared tier. */
-payload: T;
+payload:T;
 /** Cost and degradation evidence. */
-receipt: ObservationReceipt;
+receipt:ObservationReceipt;
 }
 /** Refusal returned when no declared tier can fit the caller's ceiling. */
 export interface RefusedObservation {
 /** Discriminator for a payload-free refusal. */
-status: "refused";
+status:"refused";
 /** Stable reason callers can route without parsing prose. */
-reason: "no_declared_tier_fits_budget";
+reason:"no_declared_tier_fits_budget";
 /** Cost and degradation evidence. */
-receipt: ObservationReceipt;
+receipt:ObservationReceipt;
 }
 /** Complete outcome of attempting one declared observation. */
 export type ObservationResult<T> = ServedObservation<T> | RefusedObservation;
 /** Caller-imposed ceiling for one observation response. */
 export interface ObservationRequest {
 /** Maximum response tokens accepted by the caller. */
-budget_tokens: number;
+budget_tokens:number;
 }
 /** Predicate supported by the versioned total-verdict interpreter. */
 export type VerdictPredicate = {
-readonly id: string;
-readonly kind: "field_equals";
-readonly path: string;
-readonly expected: unknown;
+readonly id:string;
+readonly kind:"field_equals";
+readonly path:string;
+readonly expected:unknown;
 } | {
-readonly id: string;
-readonly kind: "field_present";
-readonly path: string;
+readonly id:string;
+readonly kind:"field_present";
+readonly path:string;
 } | {
-readonly id: string;
-readonly kind: "field_absent";
-readonly path: string;
+readonly id:string;
+readonly kind:"field_absent";
+readonly path:string;
 };
 /** Declarative composition applied to predicate outcomes. */
 export interface VerdictComposition {
 /** Whether every or at least one referenced predicate must satisfy. */
-operator: "all" | "any";
+operator:"all" | "any";
 /** Ordered predicate identities evaluated by the total verdict. */
-predicate_ids: readonly string[];
+predicate_ids:readonly string[];
 }
 /** Portable named and versioned total-verdict declaration. */
 export interface VerdictContract {
 /** Versioned schema identity. */
-schema: typeof PM_VERDICT_SCHEMA;
+schema:typeof PM_VERDICT_SCHEMA;
 /** Stable contract identity. */
-id: string;
+id:string;
 /** Positive contract revision. */
-version: number;
+version:number;
 /** Predicates evaluated exclusively over recorded state. */
-predicates: readonly VerdictPredicate[];
+predicates:readonly VerdictPredicate[];
 /** Explicit deterministic predicate composition. */
-composition: VerdictComposition;
+composition:VerdictComposition;
 }
 /** Recorded state and stable snapshot identity supplied by an adapter. */
 export interface WorkspaceRecordedState {
 /** Stable identity of the exact state being evaluated. */
-snapshot_id: string;
+snapshot_id:string;
 /** Recorded, JSON-compatible project state. */
-state: RecordedStateObject;
+state:RecordedStateObject;
 }
 /** Per-predicate evidence in a deterministic total verdict. */
 export interface PredicateVerdict {
 /** Declared predicate identity. */
-id: string;
+id:string;
 /** Whether the predicate is satisfied by recorded state. */
-outcome: "satisfied" | "violated";
+outcome:"satisfied" | "violated";
 /** Snapshot-qualified JSON pointer to the inspected field. */
-evidence_pointer: string;
+evidence_pointer:string;
 /** Hash of the observed value without duplicating potentially private data. */
-evidence_digest: string;
+evidence_digest:string;
 }
 /** Total, reproducible result produced by a verdict contract. */
 export interface VerdictResult {
 /** Stable verdict identity. */
-contract_id: string;
+contract_id:string;
 /** Verdict revision. */
-contract_version: number;
+contract_version:number;
 /** Exact recorded-state snapshot evaluated. */
-snapshot_id: string;
+snapshot_id:string;
 /** Total outcome, including an explicit empty-contract state. */
-outcome: "satisfied" | "violated" | "not_applicable";
+outcome:"satisfied" | "violated" | "not_applicable";
 /** Satisfied fraction, or null when no predicates are declared. */
-score: number | null;
+score:number | null;
 /** Explicitly separates evaluation from reward or learning signals. */
-policy: "verdict_only_no_reward";
+policy:"verdict_only_no_reward";
 /** Stable explanation for a not-applicable verdict. */
-reason?: "no_predicates_declared";
+reason?:"no_predicates_declared";
 /** Ordered predicate evidence. */
-predicates: readonly PredicateVerdict[];
+predicates:readonly PredicateVerdict[];
 }
 /** Hard limits enforced within one isolated episode. */
 export interface EpisodeLimits {
 /** Maximum ordinary project-management actions. */
-max_actions: number;
+max_actions:number;
 /** Maximum observations, including the close-time grading read. */
-max_observations: number;
+max_observations:number;
 /** Per-observation response ceiling. */
-max_tokens_per_observation: number;
+max_tokens_per_observation:number;
 }
 /** Portable specification shared by evaluation and training harnesses. */
 export interface EpisodeSpecification {
 /** Versioned schema identity. */
-schema: typeof PM_EPISODE_SCHEMA;
+schema:typeof PM_EPISODE_SCHEMA;
 /** Stable episode identity and session provenance key. */
-id: string;
+id:string;
 /** Positive episode revision. */
-version: number;
+version:number;
 /** Consumer intent without coupling the runtime to a training framework. */
-mode: "benchmark" | "evaluation" | "training" | "scale_transfer";
+mode:"benchmark" | "evaluation" | "training" | "scale_transfer";
 /** Deterministic workspace construction recipe. */
-recipe: WorkspaceRecipe;
+recipe:WorkspaceRecipe;
 /** Canonical pm items that define the task set. */
-task_item_ids: readonly string[];
+task_item_ids:readonly string[];
 /** State fields that observations may disclose. */
-observable_fields: readonly string[];
+observable_fields:readonly string[];
 /** Grading-only fields that must never enter observations. */
-withheld_fields: readonly string[];
+withheld_fields:readonly string[];
 /** Bounded observation declaration. */
-observation: ObservationContract;
+observation:ObservationContract;
 /** Recorded-state verdict declaration. */
-verdict: VerdictContract;
+verdict:VerdictContract;
 /** Hard action and observation limits. */
-limits: EpisodeLimits;
+limits:EpisodeLimits;
 }
 /** Reset receipt returned by an episode adapter. */
 export interface EpisodeResetReceipt {
 /** Adapter-defined isolated workspace identity. */
-workspace_id: string;
+workspace_id:string;
 /** Stable state identity after reset. */
-state_id: string;
+state_id:string;
 }
 /** Action receipt returned by an episode adapter. */
 export interface EpisodeActionReceipt<TOutput> {
 /** Stable state identity after the action. */
-state_id: string;
+state_id:string;
 /** Adapter-defined ordinary command result. */
-output: TOutput;
+output:TOutput;
 }
 /** Host boundary for ordinary pm SDK actions and recorded-state reads. */
-export interface EpisodeRuntimeAdapter<TAction, TOutput = unknown> {
+export interface EpisodeRuntimeAdapter<TAction,TOutput = unknown> {
 /** Construct a fresh isolated workspace using the declared recipe. */
-reset(recipe: WorkspaceRecipe): Promise<EpisodeResetReceipt>;
+reset(recipe:WorkspaceRecipe):Promise<EpisodeResetReceipt>;
 /** Execute one ordinary action, normally by calling `PmClient.run`. */
-execute(action: TAction): Promise<EpisodeActionReceipt<TOutput>>;
+execute(action:TAction):Promise<EpisodeActionReceipt<TOutput>>;
 /** Read immutable grading state from the workspace system of record. */
-readRecordedState(): Promise<WorkspaceRecordedState>;
+readRecordedState():Promise<WorkspaceRecordedState>;
 }
 /** One deterministic entry in a portable episode trajectory. */
 export interface EpisodeTrajectoryEntry {
 /** Monotonic event number within the isolated episode. */
-sequence: number;
+sequence:number;
 /** Stable event classification. */
-kind: "reset" | "observation" | "action" | "verdict" | "close";
+kind:"reset" | "observation" | "action" | "verdict" | "close";
 /** Snapshot, state, or observation tier associated with the event. */
-state_id: string;
+state_id:string;
 }
 /** Closed episode evidence without reward or framework-specific shaping. */
 export interface ClosedEpisode {
 /** Deterministic total verdict. */
-verdict: VerdictResult;
+verdict:VerdictResult;
 /** Complete bounded trajectory. */
-trajectory: readonly EpisodeTrajectoryEntry[];
+trajectory:readonly EpisodeTrajectoryEntry[];
 /** Explicitly absent to prevent verdicts from becoming reward signals. */
-reward?: never;
+reward?:never;
 }
 /** Isolated runtime returned for one declared agent episode. */
-export interface PmEpisodeSession<TAction, TOutput> {
+export interface PmEpisodeSession<TAction,TOutput> {
 /** Observe recorded state through the declared disclosure ladder. */
-observe(): Promise<ObservationResult<RecordedStateObject>>;
+observe():Promise<ObservationResult<RecordedStateObject>>;
 /** Execute one bounded ordinary project-management action. */
-step(action: TAction): Promise<EpisodeActionReceipt<TOutput>>;
+step(action:TAction):Promise<EpisodeActionReceipt<TOutput>>;
 /** Evaluate the current recorded state without closing the session. */
-score(): Promise<VerdictResult>;
+score():Promise<VerdictResult>;
 /** Evaluate and close the episode, returning immutable evidence. */
-close(): Promise<ClosedEpisode>;
+close():Promise<ClosedEpisode>;
 }
 /** Validate, clone, and freeze a portable observation declaration. */
-export declare function defineObservationContract(declaration: ObservationContract): ObservationContract;
+export declare function defineObservationContract(declaration:ObservationContract):ObservationContract;
 /** Describe guaranteed and calibrated observation cost before collection. */
-export declare function describeObservationCost(contract: ObservationContract): ObservationCostDescription;
+export declare function describeObservationCost(contract:ObservationContract):ObservationCostDescription;
 /** Serve the richest declared tier that fits both caller and tier ceilings. */
-export declare function serveDeclaredObservation<T>(contract: ObservationContract, collect: (tier: ObservationTier) => Promise<T>, request: ObservationRequest): Promise<ObservationResult<T>>;
+export declare function serveDeclaredObservation<T>(contract:ObservationContract,collect:(tier:ObservationTier) => Promise<T>,request:ObservationRequest):Promise<ObservationResult<T>>;
 /** Validate, clone, and freeze a portable total-verdict declaration. */
-export declare function defineVerdictContract(declaration: VerdictContract): VerdictContract;
+export declare function defineVerdictContract(declaration:VerdictContract):VerdictContract;
 /** Evaluate a total verdict exclusively from one immutable recorded snapshot. */
-export declare function evaluateVerdictContract(contract: VerdictContract, recorded: WorkspaceRecordedState): VerdictResult;
+export declare function evaluateVerdictContract(contract:VerdictContract,recorded:WorkspaceRecordedState):VerdictResult;
 /** Validate, clone, and freeze a portable episode specification. */
-export declare function defineEpisodeSpecification(declaration: EpisodeSpecification): EpisodeSpecification;
+export declare function defineEpisodeSpecification(declaration:EpisodeSpecification):EpisodeSpecification;
 /** Open one isolated, deterministic episode around an adapter's ordinary actions. */
-export declare function openPmEpisode<TAction, TOutput = unknown>(specification: EpisodeSpecification, adapter: EpisodeRuntimeAdapter<TAction, TOutput>): Promise<PmEpisodeSession<TAction, TOutput>>;
+export declare function openPmEpisode<TAction,TOutput = unknown>(specification:EpisodeSpecification,adapter:EpisodeRuntimeAdapter<TAction,TOutput>):Promise<PmEpisodeSession<TAction,TOutput>>;

package/dist/sdk/environment/host-environment-errors.d.ts

@@ -2,4 +2,4 @@
  * @module sdk/host-environment-errors
  * Public SDK compatibility surface for path-redacted host filesystem refusals.
  */
-export { classifyHostEnvironmentFault, translateHostEnvironmentFault, withHostEnvironmentBoundary, type HostEnvironmentBoundaryOptions, type HostEnvironmentFaultCodeOverrides, } from "../../core/fs/host-environment-errors.js";
+export { classifyHostEnvironmentFault,translateHostEnvironmentFault,withHostEnvironmentBoundary,type HostEnvironmentBoundaryOptions,type HostEnvironmentFaultCodeOverrides,} from "../../core/fs/host-environment-errors.js";

package/dist/sdk/environment/project-runtime-compatibility.d.ts

@@ -5,79 +5,81 @@ export declare const HISTORY_ITEM_HASH_VERSION_3_INTRODUCED_IN = "2026.8.31";
 /** One discovered project pin that can prove the active executable is stale. */
 export interface ProjectRuntimeVersionPin {
 /** Representative date-version extracted from the project declaration. */
-version: string;
+version:string;
 /** Redaction-safe origin of the pin. */
-source: "package.json" | "installed-package" | "package-lock.json" | "pnpm-lock.yaml" | "yarn.lock";
+source:"package.json" | "installed-package" | "package-lock.json" | "pnpm-lock.yaml" | "yarn.lock";
 /** Whether the declaration selects one runtime, a minimum, or a bounded range. */
-constraint: "exact" | "minimum" | "range";
+constraint:"exact" | "minimum" | "range";
 /** Original package declaration when it conveys more than the representative version. */
-declaration?: string;
+declaration?:string;
 /** Whether the declaration permits a reader that understands history item-hash epoch 3. */
-history_epoch_compatible?: boolean;
+history_epoch_compatible?:boolean;
 }
 /** Structured result returned by the read-only compatibility probe. */
 export interface ProjectRuntimeCompatibilityResult {
 /** Whether the invocation can write with the active runtime. */
-compatible: boolean;
+compatible:boolean;
 /** Active executable package version. */
-executing_version: string;
+executing_version:string;
 /** Highest project pin discovered without exposing local paths. */
-project_version?: string;
+project_version?:string;
 /** Origin of the highest project pin. */
-source?: ProjectRuntimeVersionPin["source"];
+source?:ProjectRuntimeVersionPin["source"];
 /** Canonical command selected from the invocation. */
-command?: string;
+command?:string;
 /** Whether the selected invocation can mutate project state. */
-mutating: boolean;
+mutating:boolean;
 /** Whether the active executable is older than the strongest project pin. */
-stale?: boolean;
+stale?:boolean;
 /** Whether this mutation would write a history epoch a project pin cannot read. */
-history_epoch_incompatible?: boolean;
+history_epoch_incompatible?:boolean;
 /** Item-hash epoch the executing runtime writes. */
-writer_item_hash_version?: 2 | 3;
+writer_item_hash_version?:2 | 3;
 /** Project runtime declaration that cannot read the writer epoch. */
-incompatible_project_version?: string;
+incompatible_project_version?:string;
 /** Origin of the incompatible project runtime declaration. */
-incompatible_source?: ProjectRuntimeVersionPin["source"];
+incompatible_source?:ProjectRuntimeVersionPin["source"];
 /** Non-blocking diagnostic attached to stale read-only invocations. */
-warning?: ProjectRuntimeCompatibilityWarning;
+warning?:ProjectRuntimeCompatibilityWarning;
 /** Whether the explicit one-invocation recovery override was accepted. */
-override_applied: boolean;
+override_applied:boolean;
 }
 /** Structured, package-manager-neutral warning returned for a stale read. */
 export interface ProjectRuntimeCompatibilityWarning {
 /** Stable warning code for filtering and automation. */
-code: "project_runtime_stale_read";
+code:"project_runtime_stale_read";
 /** Active executable package version. */
-executing_version: string;
+executing_version:string;
 /** Strongest newer project version pin. */
-project_version: string;
+project_version:string;
 /** Redaction-safe origin of the project pin. */
-source: ProjectRuntimeVersionPin["source"];
+source:ProjectRuntimeVersionPin["source"];
 /** Concise explanation of the mismatch. */
-message: string;
+message:string;
 /** Package-manager-neutral recovery actions. */
-next_steps: string[];
+next_steps:string[];
 }
 /** Compare pm date versions without accepting arbitrary semver-like prose. */
-export declare function comparePmDateVersions(left: string, right: string): number | null;
+export declare function comparePmDateVersions(left:string,right:string):number | null;
 /** Resolve the item-hash epoch written by a known pm runtime release. */
-export declare function historyItemHashVersionForRuntime(version: string): 2 | 3;
+export declare function historyItemHashVersionForRuntime(version:string):2 | 3;
 /** Discover declared, installed, and lock-resolved versions without network I/O. */
-export declare function discoverProjectRuntimeVersionPins(projectRoot: string): ProjectRuntimeVersionPin[];
+export declare function discoverProjectRuntimeVersionPins(projectRoot:string):ProjectRuntimeVersionPin[];
+/** Refuse guarded-format writes while the owning project still selects a host predating format admission. */
+export declare function assertProjectRuntimeFormatGuard(projectRoot:string,formatVersion:number):void;
 /** Classify mutation-capable invocations while preserving explicit read modes. */
-export declare function isProjectMutatingInvocation(argv: readonly string[]): boolean;
+export declare function isProjectMutatingInvocation(argv:readonly string[]):boolean;
 /** Inspect whether one invocation is compatible with the project's newest pin. */
-export declare function inspectProjectRuntimeCompatibility(options: {
-executingVersion: string;
-projectRoot: string;
-argv: readonly string[];
-allowStale?: boolean;
-}): ProjectRuntimeCompatibilityResult;
+export declare function inspectProjectRuntimeCompatibility(options:{
+executingVersion:string;
+projectRoot:string;
+argv:readonly string[];
+allowStale?:boolean;
+}):ProjectRuntimeCompatibilityResult;
 /** Refuse stale mutations with a stable SDK error and package-neutral recovery. */
-export declare function assertProjectRuntimeCompatibility(options: {
-executingVersion: string;
-projectRoot: string;
-argv: readonly string[];
-allowStale?: boolean;
-}): ProjectRuntimeCompatibilityResult;
+export declare function assertProjectRuntimeCompatibility(options:{
+executingVersion:string;
+projectRoot:string;
+argv:readonly string[];
+allowStale?:boolean;
+}):ProjectRuntimeCompatibilityResult;