@unbrained/pm-cli 2026.10.13 → 2026.10.15

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

@@ -1,15 +1,15 @@
 /** Normalize a prefix to lowercase ASCII segments followed by one hyphen. */
-export declare function normalizePrefix(input: string | undefined): string;
+export declare function normalizePrefix(input:string | undefined):string;
 /** Remove surrounding whitespace and optional hash shorthand, then lowercase an id. */
-export declare function normalizeRawItemId(input: string): string;
+export declare function normalizeRawItemId(input:string):string;
 /** Apply the normalized workspace prefix unless the supplied id already carries it. */
-export declare function normalizeItemId(input: string, prefix: string): string;
+export declare function normalizeItemId(input:string,prefix:string):string;
 /** Bounds accepted for the configurable random id token length (`ids.token_length`). */
 export declare const ID_TOKEN_LENGTH_MIN = 4;
 /** Upper bound for `ids.token_length`; longer tokens stop improving ergonomics without meaningfully improving uniqueness. */
 export declare const ID_TOKEN_LENGTH_MAX = 12;
 /** Clamp a configured id token length into the supported bounds, falling back to the 4-character default for non-finite input. */
-export declare function clampIdTokenLength(value: number | undefined): number;
+export declare function clampIdTokenLength(value:number | undefined):number;
 /**
  * Mint a new item id as `<prefix><random base36 token>`. The starting token
  * length comes from the workspace `ids.token_length` setting (default 4 for
@@ -21,8 +21,8 @@ export declare function clampIdTokenLength(value: number | undefined): number;
  * For n reserved ids and m unsynchronized creations, choose width L with
  * m*(m-1)/(2*(36^L-n)) below the tolerated per-sync collision probability.
  */
-export declare function generateItemId(pmRoot: string, prefix: string, options?: {
-tokenLength?: number;
-typeToFolder?: Readonly<Record<string, string>>;
-probeExisting?: boolean;
-}): Promise<string>;
+export declare function generateItemId(pmRoot:string,prefix:string,options?:{
+tokenLength?:number;
+typeToFolder?:Readonly<Record<string,string>>;
+probeExisting?:boolean;
+}):Promise<string>;

package/dist/core/item/item-format-version.d.ts

@@ -19,13 +19,14 @@ import type { ItemMetadata } from "../../types/index.js";
 /** The original (and implicit) item-metadata format version. Items missing a `pm_format_version` field are always treated as this version, so the baseline is never written to disk and adds no per-item token cost. */
 export declare const BASELINE_ITEM_FORMAT_VERSION = 1;
 /**
- * The format version this runtime writes and considers current. When a breaking
- * item-metadata change ships, bump this constant and add a migration that
- * rewrites items whose {@link effectiveItemFormatVersion} is lower; items at or
- * above it need no migration. It stays equal to
- * {@link BASELINE_ITEM_FORMAT_VERSION} until the first such change.
+ * Highest item format understood by this runtime. Ordinary records retain the
+ * implicit baseline; linked-test editor stamps require format 2 so earlier
+ * published hosts refuse before dropping fields from their canonical hashes.
+ * Reading legacy records never changes their format or immutable commitments.
  */
-export declare const CURRENT_ITEM_FORMAT_VERSION = 1;
+export declare const CURRENT_ITEM_FORMAT_VERSION = 2;
+/** Resolve the minimum format needed to retain persisted linked-test editor metadata. */
+export declare function requiredItemFormatVersion(metadata:Pick<ItemMetadata,"tests" | "pm_format_version">):number;
 /**
  * Resolve the format version an item is effectively stored at. A present,
  * positive-integer `pm_format_version` is taken verbatim (including versions
@@ -33,7 +34,7 @@ export declare const CURRENT_ITEM_FORMAT_VERSION = 1;
  * an absent, malformed, or sub-baseline value resolves to
  * {@link BASELINE_ITEM_FORMAT_VERSION}.
  */
-export declare function effectiveItemFormatVersion(metadata: Pick<ItemMetadata, "pm_format_version">): number;
+export declare function effectiveItemFormatVersion(metadata:Pick<ItemMetadata,"pm_format_version">):number;
 /**
  * Reduce an item's `pm_format_version` to its persisted form: the baseline
  * version (and any malformed or sub-baseline value) is dropped so it is never
@@ -42,32 +43,33 @@ export declare function effectiveItemFormatVersion(metadata: Pick<ItemMetadata,
  * current corpus and only writes it once an item genuinely advances past the
  * implicit baseline.
  */
-export declare function normalizeItemFormatVersion(value: unknown): number | undefined;
+export declare function normalizeItemFormatVersion(value:unknown):number | undefined;
 /** Relationship between an item's stored format version and the runtime's current version: `outdated` (below current, a migration would rewrite it), `ahead` (above current, written by a newer pm than this one), or `current`. */
 export type ItemFormatVersionStatus = "current" | "outdated" | "ahead";
 /**
  * Classify a single stored format version against the runtime's current
  * version. Defaults to {@link CURRENT_ITEM_FORMAT_VERSION}; the `current`
  * parameter exists so callers (and tests) can evaluate against a hypothetical
- * future version without mutating the module constant.
+ * future version without mutating the module constant. The minimum defaults to
+ * the maximum for compatibility; workspace diagnostics pass the readable baseline.
  */
-export declare function classifyItemFormatVersion(version: number, current?: number): ItemFormatVersionStatus;
+export declare function classifyItemFormatVersion(version:number,current?:number,minimum?:number):ItemFormatVersionStatus;
 /**
  * One item's reference (id or relative path) paired with the format version it
  * is stored at, used as input to {@link scanItemFormatVersions}.
  */
 export interface ItemFormatVersionScanEntry {
 /** Value that configures or reports ref for this contract. */
-ref: string;
+ref:string;
 /** Value that configures or reports version for this contract. */
-version: number;
+version:number;
 }
 /** Sorted references partitioned by how their stored format version compares to the runtime's current version. References at the current version are omitted from both lists. */
 export interface ItemFormatVersionScanResult {
 /** Value that configures or reports outdated for this contract. */
-outdated: string[];
+outdated:string[];
 /** Value that configures or reports ahead for this contract. */
-ahead: string[];
+ahead:string[];
 }
 /** Partition a set of items by format version into `outdated` (need migration) and `ahead` (written by a newer pm) reference lists, each sorted for stable diagnostics. Pushing all comparison branches into this pure, exhaustively tested helper lets `pm health` and `pm validate` emit findings by iterating the result lists, with no version-comparison branching of their own. */
-export declare function scanItemFormatVersions(entries: readonly ItemFormatVersionScanEntry[], current?: number): ItemFormatVersionScanResult;
+export declare function scanItemFormatVersions(entries:readonly ItemFormatVersionScanEntry[],current?:number,minimum?:number):ItemFormatVersionScanResult;

package/dist/core/item/item-format-version.js

@@ -1,2 +1,2 @@
-(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="13e158d2-14a0-5c14-a11c-a374b3e6ceac")}catch{}})();const BASELINE_ITEM_FORMAT_VERSION=1,CURRENT_ITEM_FORMAT_VERSION=1;function effectiveItemFormatVersion(metadata){const raw=metadata.pm_format_version;return typeof raw=="number"&&Number.isInteger(raw)&&raw>=1?raw:1}function normalizeItemFormatVersion(value){if(!(typeof value!="number"||!Number.isInteger(value)||value<=1))return value}function classifyItemFormatVersion(version,current=1){return version<current?"outdated":version>current?"ahead":"current"}function scanItemFormatVersions(entries,current=1){const outdated=[],ahead=[];for(const entry of entries){const status=classifyItemFormatVersion(entry.version,current);status==="outdated"?outdated.push(entry.ref):status==="ahead"&&ahead.push(entry.ref)}return{outdated:outdated.sort((left,right)=>left.localeCompare(right)),ahead:ahead.sort((left,right)=>left.localeCompare(right))}}export{BASELINE_ITEM_FORMAT_VERSION,CURRENT_ITEM_FORMAT_VERSION,classifyItemFormatVersion,effectiveItemFormatVersion,normalizeItemFormatVersion,scanItemFormatVersions};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c35d4830-d7d1-5ee4-99bc-ab52cc3e4e09")}catch{}})();const BASELINE_ITEM_FORMAT_VERSION=1,CURRENT_ITEM_FORMAT_VERSION=2;function requiredItemFormatVersion(metadata){return Math.max(effectiveItemFormatVersion(metadata),metadata.tests?.some(test=>test.updated_by!==void 0||test.updated_at!==void 0)?2:1)}function effectiveItemFormatVersion(metadata){const raw=metadata.pm_format_version;return typeof raw=="number"&&Number.isInteger(raw)&&raw>=1?raw:1}function normalizeItemFormatVersion(value){if(!(typeof value!="number"||!Number.isInteger(value)||value<=1))return value}function classifyItemFormatVersion(version,current=2,minimum=current){return version<minimum?"outdated":version>current?"ahead":"current"}function scanItemFormatVersions(entries,current=2,minimum=current){const outdated=[],ahead=[];for(const entry of entries){const status=classifyItemFormatVersion(entry.version,current,minimum);status==="outdated"?outdated.push(entry.ref):status==="ahead"&&ahead.push(entry.ref)}return{outdated:outdated.sort((left,right)=>left.localeCompare(right)),ahead:ahead.sort((left,right)=>left.localeCompare(right))}}export{BASELINE_ITEM_FORMAT_VERSION,CURRENT_ITEM_FORMAT_VERSION,classifyItemFormatVersion,effectiveItemFormatVersion,normalizeItemFormatVersion,requiredItemFormatVersion,scanItemFormatVersions};
 //# sourceMappingURL=item-format-version.js.map

package/dist/core/item/item-format.d.ts

@@ -1,76 +1,76 @@
-import type { ItemDocument, ItemMetadata, RuntimeSchemaSettings, ItemTestRunSummary, LinkedTest, PlanDecision, PlanDiscovery, PlanStep, PlanStepDoc, PlanStepFile, PlanStepLink, PlanValidationCheck } from "../../types/index.js";
+import type { ItemDocument,ItemMetadata,RuntimeSchemaSettings,ItemTestRunSummary,LinkedTest,PlanDecision,PlanDiscovery,PlanStep,PlanStepDoc,PlanStepFile,PlanStepLink,PlanValidationCheck } from "../../types/index.js";
 import type { ItemFormat } from "../../types/index.js";
-import { type RuntimeFieldRegistry, type RuntimeStatusRegistry } from "../schema/runtime-schema.js";
-declare function firstNonZeroComparison(comparisons: readonly number[]): number;
+import { type RuntimeFieldRegistry,type RuntimeStatusRegistry } from "../schema/runtime-schema.js";
+declare function firstNonZeroComparison(comparisons:readonly number[]):number;
 interface RuntimeSchemaValidationContext {
-statusRegistry?: RuntimeStatusRegistry;
-fieldRegistry?: RuntimeFieldRegistry;
-unknownFieldPolicy: "allow" | "warn" | "reject";
-extensionFieldNames: ReadonlySet<string>;
-onWarning?: (warning: string) => void;
+statusRegistry?:RuntimeStatusRegistry;
+fieldRegistry?:RuntimeFieldRegistry;
+unknownFieldPolicy:"allow" | "warn" | "reject";
+extensionFieldNames:ReadonlySet<string>;
+onWarning?:(warning:string) => void;
 }
 /** Documents the item document format options payload exchanged by command, SDK, and package integrations. */
 export interface ItemDocumentFormatOptions {
 /** Value that configures or reports format for this contract. */
-format?: ItemFormat;
+format?:ItemFormat;
 /** Value that configures or reports schema for this contract. */
-schema?: RuntimeSchemaSettings;
+schema?:RuntimeSchemaSettings;
 /** Value that configures or reports extension field names for this contract. */
-extensionFieldNames?: readonly string[];
+extensionFieldNames?:readonly string[];
 /** Value that configures or reports on warning for this contract. */
-onWarning?: (warning: string) => void;
+onWarning?:(warning:string) => void;
 /** Refuse ahead-of-runtime markers before metadata validation; raw inspection defaults to preserving them. */
-requireSupportedFormat?: boolean;
+requireSupportedFormat?:boolean;
 }
-declare function runtimeFieldRequiredForType(definition: RuntimeFieldRegistry["definitions"][number], typeName: string): boolean;
-declare function buildKnownItemMetadataKeys(runtimeContext: RuntimeSchemaValidationContext): Set<string>;
-declare function normalizeTestRunSummaries(values: ItemTestRunSummary[] | undefined): ItemTestRunSummary[] | undefined;
-declare function sortTests(values: LinkedTest[] | undefined): LinkedTest[] | undefined;
+declare function runtimeFieldRequiredForType(definition:RuntimeFieldRegistry["definitions"][number],typeName:string):boolean;
+declare function buildKnownItemMetadataKeys(runtimeContext:RuntimeSchemaValidationContext):Set<string>;
+declare function normalizeTestRunSummaries(values:ItemTestRunSummary[] | undefined):ItemTestRunSummary[] | undefined;
+declare function sortTests(values:LinkedTest[] | undefined):LinkedTest[] | undefined;
 /** Normalize one linked-test entry consistently for storage and metadata comparisons. */
-export declare function normalizeLinkedTest(value: LinkedTest): LinkedTest;
-declare function normalizePlanStepLinks(value: unknown): PlanStepLink[] | undefined;
-declare function normalizePlanStepFiles(value: unknown): PlanStepFile[] | undefined;
-declare function normalizePlanStepTests(value: unknown): {
-command?: string;
-path?: string;
-note?: string;
+export declare function normalizeLinkedTest(value:LinkedTest):LinkedTest;
+declare function normalizePlanStepLinks(value:unknown):PlanStepLink[] | undefined;
+declare function normalizePlanStepFiles(value:unknown):PlanStepFile[] | undefined;
+declare function normalizePlanStepTests(value:unknown):{
+command?:string;
+path?:string;
+note?:string;
 }[] | undefined;
-declare function normalizePlanStepDocs(value: unknown): PlanStepDoc[] | undefined;
-declare function normalizePlanSteps(value: unknown): PlanStep[] | undefined;
-declare function normalizePlanDecisions(value: unknown): PlanDecision[] | undefined;
-declare function normalizePlanDiscoveries(value: unknown): PlanDiscovery[] | undefined;
-declare function normalizePlanValidation(value: unknown): PlanValidationCheck[] | undefined;
-declare function normalizeTypeOptions(values: Record<string, string> | undefined): Record<string, string> | undefined;
-declare function normalizeBody(body: string): string;
+declare function normalizePlanStepDocs(value:unknown):PlanStepDoc[] | undefined;
+declare function normalizePlanSteps(value:unknown):PlanStep[] | undefined;
+declare function normalizePlanDecisions(value:unknown):PlanDecision[] | undefined;
+declare function normalizePlanDiscoveries(value:unknown):PlanDiscovery[] | undefined;
+declare function normalizePlanValidation(value:unknown):PlanValidationCheck[] | undefined;
+declare function normalizeTypeOptions(values:Record<string,string> | undefined):Record<string,string> | undefined;
+declare function normalizeBody(body:string):string;
 /** Implements normalize item metadata for the public runtime surface of this module. */
-export declare function normalizeItemMetadata(itemMetadata: ItemMetadata, options?: Pick<ItemDocumentFormatOptions, "schema" | "extensionFieldNames" | "onWarning">): ItemMetadata;
+export declare function normalizeItemMetadata(itemMetadata:ItemMetadata,options?:Pick<ItemDocumentFormatOptions,"schema" | "extensionFieldNames" | "onWarning">):ItemMetadata;
 /** Implements split front matter for the public runtime surface of this module. */
-export declare function splitFrontMatter(content: string): {
-frontMatter: string;
-body: string;
+export declare function splitFrontMatter(content:string):{
+frontMatter:string;
+body:string;
 };
 /** Implements parse item document for the public runtime surface of this module. */
-export declare function parseItemDocument(content: string, options?: ItemDocumentFormatOptions): ItemDocument;
+export declare function parseItemDocument(content:string,options?:ItemDocumentFormatOptions):ItemDocument;
 /** Implements serialize item document for the public runtime surface of this module. */
-export declare function serializeItemDocument(document: ItemDocument, options?: ItemDocumentFormatOptions): string;
+export declare function serializeItemDocument(document:ItemDocument,options?:ItemDocumentFormatOptions):string;
 /** Implements canonical document for the public runtime surface of this module. */
-export declare function canonicalDocument(document: ItemDocument, options?: Pick<ItemDocumentFormatOptions, "schema" | "extensionFieldNames" | "onWarning">): ItemDocument;
+export declare function canonicalDocument(document:ItemDocument,options?:Pick<ItemDocumentFormatOptions,"schema" | "extensionFieldNames" | "onWarning">):ItemDocument;
 /** Public contract for test only item format, shared by SDK and presentation-layer consumers. */
-export declare const _testOnlyItemFormat: {
-buildKnownItemMetadataKeys: typeof buildKnownItemMetadataKeys;
-firstNonZeroComparison: typeof firstNonZeroComparison;
-normalizeBody: typeof normalizeBody;
-normalizePlanDecisions: typeof normalizePlanDecisions;
-normalizePlanDiscoveries: typeof normalizePlanDiscoveries;
-normalizePlanStepDocs: typeof normalizePlanStepDocs;
-normalizePlanStepFiles: typeof normalizePlanStepFiles;
-normalizePlanStepLinks: typeof normalizePlanStepLinks;
-normalizePlanSteps: typeof normalizePlanSteps;
-normalizePlanStepTests: typeof normalizePlanStepTests;
-normalizePlanValidation: typeof normalizePlanValidation;
-normalizeTestRunSummaries: typeof normalizeTestRunSummaries;
-normalizeTypeOptions: typeof normalizeTypeOptions;
-runtimeFieldRequiredForType: typeof runtimeFieldRequiredForType;
-sortTests: typeof sortTests;
+export declare const _testOnlyItemFormat:{
+buildKnownItemMetadataKeys:typeof buildKnownItemMetadataKeys;
+firstNonZeroComparison:typeof firstNonZeroComparison;
+normalizeBody:typeof normalizeBody;
+normalizePlanDecisions:typeof normalizePlanDecisions;
+normalizePlanDiscoveries:typeof normalizePlanDiscoveries;
+normalizePlanStepDocs:typeof normalizePlanStepDocs;
+normalizePlanStepFiles:typeof normalizePlanStepFiles;
+normalizePlanStepLinks:typeof normalizePlanStepLinks;
+normalizePlanSteps:typeof normalizePlanSteps;
+normalizePlanStepTests:typeof normalizePlanStepTests;
+normalizePlanValidation:typeof normalizePlanValidation;
+normalizeTestRunSummaries:typeof normalizeTestRunSummaries;
+normalizeTypeOptions:typeof normalizeTypeOptions;
+runtimeFieldRequiredForType:typeof runtimeFieldRequiredForType;
+sortTests:typeof sortTests;
 };
 export {};

package/dist/core/item/item-record.d.ts

@@ -21,4 +21,4 @@ import type { ItemMetadata } from "../../types/index.js";
  * which validate `typeof` at runtime.) `ItemMetadata` is the canonical type,
  * so item-metadata values are accepted as-is.
  */
-export declare function toItemRecord(item: ItemMetadata): Record<string, unknown>;
+export declare function toItemRecord(item:ItemMetadata):Record<string,unknown>;

package/dist/core/item/item-type-definition.d.ts

@@ -3,7 +3,7 @@
  *
  * Defines item parsing, formatting, and lifecycle helpers for Item Type Definition.
  */
-import type { ItemTypeCommandOptionPolicy, ItemTypeDefinition, ItemTypeOptionDefinition } from "../../types/index.js";
+import type { ItemTypeCommandOptionPolicy,ItemTypeDefinition,ItemTypeOptionDefinition } from "../../types/index.js";
 /**
  * Shared, pure normalization for {@link ItemTypeDefinition} objects, single-sourced
  * across the runtime item-type registry and settings persistence (pm-v798).
@@ -20,26 +20,26 @@ import type { ItemTypeCommandOptionPolicy, ItemTypeDefinition, ItemTypeOptionDef
  * options normalization, policy dedupe key + stable sort) is shared.
  */
 /** Dedupe + sort a string list: trim, drop blanks, unique, locale-sorted. */
-export declare function normalizeItemTypeStringList(values: string[] | undefined): string[];
+export declare function normalizeItemTypeStringList(values:string[] | undefined):string[];
 /** Normalize one type-option definition, or null when its key is blank. */
-export declare function normalizeItemTypeOption(option: ItemTypeOptionDefinition): ItemTypeOptionDefinition | null;
+export declare function normalizeItemTypeOption(option:ItemTypeOptionDefinition):ItemTypeOptionDefinition | null;
 /** Resolves a raw policy `command` value to the canonical "create"/"update" type, or null to drop the policy. Lets each layer plug in its own strictness. */
-export type ResolvePolicyCommand = (command: string) => ItemTypeCommandOptionPolicy["command"] | null;
+export type ResolvePolicyCommand = (command:string) => ItemTypeCommandOptionPolicy["command"] | null;
 /** Pass-through resolver used by settings persistence: the value is already typed "create" | "update" by the settings validator, so it is kept verbatim. */
-export declare const keepPolicyCommand: ResolvePolicyCommand;
+export declare const keepPolicyCommand:ResolvePolicyCommand;
 /** Strict resolver used by the runtime registry: trims + lowercases and rejects anything other than "create"/"update". */
-export declare const strictPolicyCommand: ResolvePolicyCommand;
+export declare const strictPolicyCommand:ResolvePolicyCommand;
 /** Normalize one command-option policy, or null when invalid (blank option / rejected command). */
-export declare function normalizeItemTypeCommandOptionPolicy(policy: ItemTypeCommandOptionPolicy, resolvePolicyCommand: ResolvePolicyCommand): ItemTypeCommandOptionPolicy | null;
+export declare function normalizeItemTypeCommandOptionPolicy(policy:ItemTypeCommandOptionPolicy,resolvePolicyCommand:ResolvePolicyCommand):ItemTypeCommandOptionPolicy | null;
 /** Dedupe by `${command}:${option-lowercased}` and stable-sort by command then option. */
-export declare function normalizeItemTypeCommandOptionPolicies(policies: ItemTypeCommandOptionPolicy[] | undefined, resolvePolicyCommand: ResolvePolicyCommand): ItemTypeCommandOptionPolicy[];
+export declare function normalizeItemTypeCommandOptionPolicies(policies:ItemTypeCommandOptionPolicy[] | undefined,resolvePolicyCommand:ResolvePolicyCommand):ItemTypeCommandOptionPolicy[];
 /** Documents the normalize item type definition options payload exchanged by command, SDK, and package integrations. */
 export interface NormalizeItemTypeDefinitionOptions {
 /** How to resolve a raw policy `command` value (defaults to {@link keepPolicyCommand}). */
-resolvePolicyCommand?: ResolvePolicyCommand;
+resolvePolicyCommand?:ResolvePolicyCommand;
 }
 /** Validate an execution role before a settings or extension definition enters scheduling. Unknown values fail instead of silently enabling dispatch. */
-export declare function parseItemExecutionRole(value: unknown): ItemTypeDefinition["execution_role"];
+export declare function parseItemExecutionRole(value:unknown):ItemTypeDefinition["execution_role"];
 /**
  * Normalize a full {@link ItemTypeDefinition}, returning null when the name is blank.
  *
@@ -48,4 +48,4 @@ export declare function parseItemExecutionRole(value: unknown): ItemTypeDefiniti
  * emitted when present on the input (presence-preserving) so the distinction
  * between "unset" and "set-but-empty" survives the round-trip.
  */
-export declare function normalizeItemTypeDefinition(definition: ItemTypeDefinition, options?: NormalizeItemTypeDefinitionOptions): ItemTypeDefinition | null;
+export declare function normalizeItemTypeDefinition(definition:ItemTypeDefinition,options?:NormalizeItemTypeDefinitionOptions):ItemTypeDefinition | null;

package/dist/core/item/parent-reference-policy.d.ts

@@ -5,14 +5,14 @@
  */
 import type { ParentReferencePolicy } from "../../types/index.js";
 /** Implements normalize parent reference policy for the public runtime surface of this module. */
-export declare function normalizeParentReferencePolicy(value: string | undefined): ParentReferencePolicy;
+export declare function normalizeParentReferencePolicy(value:string | undefined):ParentReferencePolicy;
 /** Implements normalize parent reference value for the public runtime surface of this module. */
-export declare function normalizeParentReferenceValue(rawValue: unknown): string;
+export declare function normalizeParentReferenceValue(rawValue:unknown):string;
 /** Detects parent-style placeholder tokens that should never become stored ids. */
-export declare function isPlaceholderReferenceToken(value: string): boolean;
+export declare function isPlaceholderReferenceToken(value:string):boolean;
 /** Implements validate missing parent reference for the public runtime surface of this module. */
-export declare function validateMissingParentReference(parentId: string, policy: ParentReferencePolicy): {
-warnings: string[];
+export declare function validateMissingParentReference(parentId:string,policy:ParentReferencePolicy):{
+warnings:string[];
 };
 /** Rejects the one-node hierarchy cycle where an item points at itself. */
-export declare function assertParentReferenceIsNotSelf(itemId: string, parentId: string, prefix: string): void;
+export declare function assertParentReferenceIsNotSelf(itemId:string,parentId:string,prefix:string):void;

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

@@ -1,25 +1,25 @@
 /** Classify plaintext as structured key/value input using an explicit accepted-key vocabulary. */
-export declare function looksLikeStructuredKeyValueEntry(raw: string, keys: readonly string[]): boolean;
+export declare function looksLikeStructuredKeyValueEntry(raw:string,keys:readonly string[]):boolean;
 /** Implements parse tags for the public runtime surface of this module. */
-export declare function parseTags(raw: string): string[];
+export declare function parseTags(raw:string):string[];
 /** Merge repeated `--add-tags` / `--remove-tags` values into a single normalized tag list. Each entry can itself be CSV or a JSON array, mirroring the format accepted by `--tags`. Returns a deterministically sorted, deduped list. */
-export declare function collectTagFlagValues(values: readonly string[] | undefined): string[];
+export declare function collectTagFlagValues(values:readonly string[] | undefined):string[];
 /** Split a stored `acceptance_criteria` value into its individual criteria. Criteria are stored as one string joined with `"; "` (repeated `--ac` values accumulate that way), so the semicolon is the criterion boundary and cannot appear inside one criterion; entries are trimmed and blanks dropped. Non-string/absent values yield an empty list. */
-export declare function splitAcceptanceCriteria(value: unknown): string[];
+export declare function splitAcceptanceCriteria(value:unknown):string[];
 /** Apply additive/subtractive acceptance-criteria mutations to a base criteria list. Used by `pm update --add-ac/--remove-ac` so individual semicolon-free criteria can be edited without replacing the whole `acceptance_criteria` value (tag-API parity; disjoint additions merge cleanly across branches). Additions append in argv order and dedupe on exact trimmed text; removals match exact trimmed text and report unmatched selectors so a typo never becomes a silent no-op. */
-export declare function applyAcceptanceCriteriaMutations(baseCriteria: readonly string[], add: readonly string[] | undefined, remove: readonly string[] | undefined): {
-criteria: string[];
-unmatchedRemovals: string[];
+export declare function applyAcceptanceCriteriaMutations(baseCriteria:readonly string[],add:readonly string[] | undefined,remove:readonly string[] | undefined):{
+criteria:string[];
+unmatchedRemovals:string[];
 };
 /** Apply an additive tag mutation to a base tag list. Used by `pm create` and `pm update` so `--add-tags` extends `--tags` (or the existing tags) without replacing them. Output is sorted + deduped lowercase, matching `parseTags`. */
-export declare function mergeAdditiveTags(baseTags: readonly string[], add: readonly string[] | undefined): string[];
+export declare function mergeAdditiveTags(baseTags:readonly string[],add:readonly string[] | undefined):string[];
 /** Apply a subtractive tag mutation to a base tag list. Used by `pm update` so `--remove-tags x,y` prunes those entries without rewriting the full set. Removal is case-insensitive: both the base list and the removal selectors are normalized to canonical lowercase before matching. */
-export declare function applyTagRemovals(baseTags: readonly string[], remove: readonly string[] | undefined): string[];
-declare function coerceJsonTagArray(trimmed: string): string[] | null;
-declare function stripCodeFenceEnvelope(value: string): string;
-declare function parseMarkdownKeyValueLines(raw: string): Record<string, string> | null;
+export declare function applyTagRemovals(baseTags:readonly string[],remove:readonly string[] | undefined):string[];
+declare function coerceJsonTagArray(trimmed:string):string[] | null;
+declare function stripCodeFenceEnvelope(value:string):string;
+declare function parseMarkdownKeyValueLines(raw:string):Record<string,string> | null;
 /** Implements parse csv kv for the public runtime surface of this module. */
-export declare function parseCsvKv(raw: string, optionName: string): Record<string, string>;
+export declare function parseCsvKv(raw:string,optionName:string):Record<string,string>;
 /**
  * Detect a CSV/markdown entry that opens with a generic `key=` token even when
  * that key is unknown (e.g. a typo like `lable=main,path=README.md`). Callers
@@ -30,9 +30,9 @@ export declare function parseCsvKv(raw: string, optionName: string): Record<stri
  * Windows absolute paths (`C:\…`) are excluded so a drive-lettered bare path is
  * never misread as a `C=…` key/value entry.
  */
-export declare function looksLikeGenericKeyValueEntry(raw: string): boolean;
+export declare function looksLikeGenericKeyValueEntry(raw:string):boolean;
 /** Refuse a comma-bearing bare value whose meaning depends on guessing whether the comma separates values or belongs to one value. */
-export declare function assertNoAmbiguousBareCommaEntry(raw: string, optionName: string, noun: string, structured: boolean): void;
+export declare function assertNoAmbiguousBareCommaEntry(raw:string,optionName:string,noun:string,structured:boolean):void;
 /**
  * Reject any key in a parsed CSV/markdown key/value map that is not part of the
  * caller's allowed-key contract, mirroring the strict `test --add` behavior
@@ -53,44 +53,44 @@ export declare function assertNoAmbiguousBareCommaEntry(raw: string, optionName:
  * `--learning`, annotation `--add`) deliberately do NOT call this — there an
  * unrecognized key means "treat the whole entry as plaintext", not an error.
  */
-export declare function assertNoUnknownCsvKeys(kv: Record<string, string>, optionName: string, allowedKeys: readonly string[]): void;
+export declare function assertNoUnknownCsvKeys(kv:Record<string,string>,optionName:string,allowedKeys:readonly string[]):void;
 /** Documents the stdin token resolver payload exchanged by command, SDK, and package integrations. */
 export interface StdinTokenResolver {
 /** Value that configures or reports resolve value for this contract. */
-resolveValue(value: string | undefined, optionName: string, resolveToken?: boolean): Promise<string | undefined>;
+resolveValue(value:string | undefined,optionName:string,resolveToken?:boolean):Promise<string | undefined>;
 /** Value that configures or reports resolve list for this contract. */
-resolveList(values: string[] | undefined, optionName: string, resolveToken?: boolean): Promise<string[] | undefined>;
+resolveList(values:string[] | undefined,optionName:string,resolveToken?:boolean):Promise<string[] | undefined>;
 }
 /** Mark transport-decoded options whose dash values are data, not stdin tokens. */
-export declare function preserveMutationStdinTokenLiterals<T extends object>(options: T): T;
+export declare function preserveMutationStdinTokenLiterals<T extends object>(options:T):T;
 /** Mark selected mutation fields whose dash values are literal transport data. */
-export declare function preserveMutationStdinTokenFields<T extends object>(options: T, fields: readonly PropertyKey[]): T;
+export declare function preserveMutationStdinTokenFields<T extends object>(options:T,fields:readonly PropertyKey[]):T;
 /** Copy the complete mutation stdin-token policy across an option clone. */
-export declare function transferMutationStdinTokenPolicy<T extends object>(source: object, target: T): T;
+export declare function transferMutationStdinTokenPolicy<T extends object>(source:object,target:T):T;
 /** Add a source mutation stdin-token policy without weakening the target. */
-export declare function overlayMutationStdinTokenPolicy<T extends object>(source: object, target: T): T;
+export declare function overlayMutationStdinTokenPolicy<T extends object>(source:object,target:T):T;
 /** Report whether lifecycle input should interpret dash values as stdin tokens. */
-export declare function shouldResolveMutationStdinTokens(options: object): boolean;
+export declare function shouldResolveMutationStdinTokens(options:object):boolean;
 /** Report whether one mutation field should interpret dash as a stdin token. */
-export declare function shouldResolveMutationStdinTokenField(options: object, field: PropertyKey): boolean;
+export declare function shouldResolveMutationStdinTokenField(options:object,field:PropertyKey):boolean;
 /** Refuse competing stdin-token fields before any resolver starts reading. */
-export declare function assertSingleStdinTokenConsumer(candidates: readonly {
-value: string | readonly string[] | undefined;
-optionName: string;
-resolveToken?: boolean;
-}[]): void;
+export declare function assertSingleStdinTokenConsumer(candidates:readonly {
+value:string | readonly string[] | undefined;
+optionName:string;
+resolveToken?:boolean;
+}[]):void;
 /** Resolve a typed mutation option bag only after its complete stdin plan is conflict-free. */
-export declare function resolveMutationStdinTokenFields<T extends object>(options: T, scalarFields: readonly (readonly [keyof T & string, string])[], listFields: readonly (readonly [keyof T & string, string])[]): Promise<T>;
+export declare function resolveMutationStdinTokenFields<T extends object>(options:T,scalarFields:readonly (readonly [keyof T & string,string])[],listFields:readonly (readonly [keyof T & string,string])[]):Promise<T>;
 /** Implements create stdin token resolver for the public runtime surface of this module. */
-export declare function createStdinTokenResolver(): StdinTokenResolver;
+export declare function createStdinTokenResolver():StdinTokenResolver;
 /** Implements parse optional number for the public runtime surface of this module. */
-export declare function parseOptionalNumber(raw: string, optionName: string): number;
+export declare function parseOptionalNumber(raw:string,optionName:string):number;
 /** Parse a non-negative integer option such as an item duration estimate. */
-export declare function parseOptionalNonNegativeInteger(raw: string, optionName: string): number;
+export declare function parseOptionalNonNegativeInteger(raw:string,optionName:string):number;
 /** Public contract for test only, shared by SDK and presentation-layer consumers. */
-export declare const _testOnly: {
-coerceJsonTagArray: typeof coerceJsonTagArray;
-stripCodeFenceEnvelope: typeof stripCodeFenceEnvelope;
-parseMarkdownKeyValueLines: typeof parseMarkdownKeyValueLines;
+export declare const _testOnly:{
+coerceJsonTagArray:typeof coerceJsonTagArray;
+stripCodeFenceEnvelope:typeof stripCodeFenceEnvelope;
+parseMarkdownKeyValueLines:typeof parseMarkdownKeyValueLines;
 };
 export {};

package/dist/core/item/plan-lifecycle.d.ts

@@ -4,10 +4,10 @@
  * Defines the terminal lifecycle semantics shared by Plan command mutations
  * and generic item closure.
  */
-import type { ItemMetadata, PlanMode } from "../../types/index.js";
+import type { ItemMetadata,PlanMode } from "../../types/index.js";
 /** Plan modes that intentionally prevent any further Plan mutation. */
-export declare const TERMINAL_PLAN_MODES: ReadonlySet<PlanMode>;
+export declare const TERMINAL_PLAN_MODES:ReadonlySet<PlanMode>;
 /** Return whether a Plan mode represents a terminal planning state. */
-export declare function isTerminalPlanMode(mode: PlanMode | undefined): boolean;
+export declare function isTerminalPlanMode(mode:PlanMode | undefined):boolean;
 /** Return whether closing this item should complete its Plan lifecycle in the same mutation. */
-export declare function shouldCompletePlanOnClose(item: ItemMetadata): boolean;
+export declare function shouldCompletePlanOnClose(item:ItemMetadata):boolean;

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

@@ -1,9 +1,9 @@
 /** Restricts priority values accepted by command, SDK, and storage contracts. */
 export type Priority = 0 | 1 | 2 | 3 | 4;
 /** Canonical mapping from named priority levels to numeric values. Agents and humans frequently write words ("high") instead of numbers, so both create and update accept either form. This single map is the source of truth so the two commands cannot drift apart. */
-export declare const PRIORITY_NAME_TO_VALUE: Readonly<Record<string, Priority>>;
+export declare const PRIORITY_NAME_TO_VALUE:Readonly<Record<string,Priority>>;
 /** Human-readable description of every accepted priority form. Reused in error messages so the wording stays consistent across commands. */
-export declare const PRIORITY_ACCEPTED_FORMS_HINT: string;
+export declare const PRIORITY_ACCEPTED_FORMS_HINT:string;
 /**
  * Resolve a raw `--priority` option value to a numeric 0..4 priority.
  *
@@ -14,4 +14,4 @@ export declare const PRIORITY_ACCEPTED_FORMS_HINT: string;
  *
  * Throws a USAGE error listing BOTH accepted forms for anything else.
  */
-export declare function resolvePriority(raw: string | number): Priority;
+export declare function resolvePriority(raw:string | number):Priority;

package/dist/core/item/sprint-release-format.d.ts

@@ -5,9 +5,9 @@
  */
 import type { SprintReleaseFormatPolicy } from "../../types/index.js";
 /** Implements normalize sprint release format policy for the public runtime surface of this module. */
-export declare function normalizeSprintReleaseFormatPolicy(value: string | undefined): SprintReleaseFormatPolicy;
+export declare function normalizeSprintReleaseFormatPolicy(value:string | undefined):SprintReleaseFormatPolicy;
 /** Implements validate sprint or release value for the public runtime surface of this module. */
-export declare function validateSprintOrReleaseValue(field: "sprint" | "release", rawValue: string, policy: SprintReleaseFormatPolicy): {
-value: string;
-warnings: string[];
+export declare function validateSprintOrReleaseValue(field:"sprint" | "release",rawValue:string,policy:SprintReleaseFormatPolicy):{
+value:string;
+warnings:string[];
 };

package/dist/core/item/status-filter.d.ts

@@ -1,7 +1,7 @@
 import type { RuntimeStatusRegistry } from "../schema/runtime-schema.js";
 import type { ItemStatus } from "../../types/index.js";
 /** Return true when a status-filter input is the standalone all-status sentinel. */
-export declare function isStatusAllFilterInput(raw: unknown): boolean;
+export declare function isStatusAllFilterInput(raw:unknown):boolean;
 /**
  * Resolve a single status-filter token to a concrete runtime status id.
  *
@@ -10,13 +10,13 @@ export declare function isStatusAllFilterInput(raw: unknown): boolean;
  * Callers decide whether an unrecognized token is an error (strict mode) or is
  * passed through verbatim (lenient mode) — see {@link parseStatusFilterCsv}.
  */
-export declare function resolveStatusFilterToken(token: string, registry: RuntimeStatusRegistry): ItemStatus | undefined;
+export declare function resolveStatusFilterToken(token:string,registry:RuntimeStatusRegistry):ItemStatus | undefined;
 /** Documents the parse status filter options payload exchanged by command, SDK, and package integrations. */
 export interface ParseStatusFilterOptions {
 /** When true, an unrecognized token throws a USAGE error with a did-you-mean hint. When false (default), an unrecognized token is passed through verbatim so custom/unknown statuses still compare against item values by their raw string — preserving the long-standing lenient `pm list` behavior. */
-strict?: boolean;
+strict?:boolean;
 /** Flag label used in error messages (default: "--status"). */
-flagLabel?: string;
+flagLabel?:string;
 }
 /** Parse a comma-separated status filter into a de-duplicated list of concrete status ids. A standalone `all` sentinel intentionally resolves to no filter so duplicate-discovery loops can search every lifecycle bucket with the same `--status` flag shape. Shared by `pm list` (lenient) and `pm search` (strict, with a did-you-mean hint on typos) so both surfaces resolve the open/closed/canceled workflow-group aliases identically. */
-export declare function parseStatusFilterCsv(raw: unknown, registry: RuntimeStatusRegistry, options?: ParseStatusFilterOptions): ItemStatus[] | undefined;
+export declare function parseStatusFilterCsv(raw:unknown,registry:RuntimeStatusRegistry,options?:ParseStatusFilterOptions):ItemStatus[] | undefined;

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

@@ -1,8 +1,8 @@
 import type { ItemStatus } from "../../types/index.js";
 import { type RuntimeStatusRegistry } from "../schema/runtime-schema.js";
 /** Implements normalize status input for the public runtime surface of this module. */
-export declare function normalizeStatusInput(value: unknown, registry?: RuntimeStatusRegistry): ItemStatus | undefined;
+export declare function normalizeStatusInput(value:unknown,registry?:RuntimeStatusRegistry):ItemStatus | undefined;
 /** Normalize a status against the runtime registry, falling back to the original value when normalization does not resolve to a known status. This preserves the long-standing `normalizeStatusInput(status, registry) ?? status` pattern used by query commands so that unknown/custom statuses still compare against registry sets by their raw value. */
-export declare function normalizeStatusForRegistry(status: ItemStatus, registry: RuntimeStatusRegistry): ItemStatus;
+export declare function normalizeStatusForRegistry(status:ItemStatus,registry:RuntimeStatusRegistry):ItemStatus;
 /** Determine whether a status is terminal according to the runtime status registry, applying registry-aware normalization first (with raw fallback). */
-export declare function isTerminalStatus(status: ItemStatus, registry: RuntimeStatusRegistry): boolean;
+export declare function isTerminalStatus(status:ItemStatus,registry:RuntimeStatusRegistry):boolean;

package/dist/core/item/toon-decode.d.ts

@@ -1,19 +1,19 @@
 /** Public contract for toon scalar bracket escape upstream pr, shared by SDK and presentation-layer consumers. */
-export declare const TOON_SCALAR_BRACKET_ESCAPE_UPSTREAM_PR: "https://github.com/toon-format/toon/pull/314";
+export declare const TOON_SCALAR_BRACKET_ESCAPE_UPSTREAM_PR:"https://github.com/toon-format/toon/pull/314";
 /** Historical tracking for the scalar-bracket decoder defect fixed upstream in TOON 2.3.1. */
-export declare const TOON_SCALAR_BRACKET_ESCAPE_TRACKING: {
-readonly dependency: "@toon-format/toon";
-readonly affected_versions: "<=2.3.0";
-readonly resolved_version: "2.3.1";
-readonly upstream_pr: "https://github.com/toon-format/toon/pull/314";
-readonly workaround_status: "removed";
+export declare const TOON_SCALAR_BRACKET_ESCAPE_TRACKING:{
+readonly dependency:"@toon-format/toon";
+readonly affected_versions:"<=2.3.0";
+readonly resolved_version:"2.3.1";
+readonly upstream_pr:"https://github.com/toon-format/toon/pull/314";
+readonly workaround_status:"removed";
 };
 /** Documents the toon decode result payload exchanged by command, SDK, and package integrations. */
 export interface ToonDecodeResult {
 /** The decoded TOON document. */
-value: unknown;
+value:unknown;
 /** Always false since TOON 2.3.1 fixed strict scalar-bracket decoding upstream. */
-usedScalarBracketEscape: boolean;
+usedScalarBracketEscape:boolean;
 }
 /**
  * Decode a TOON item document with the dependency's strict parser.
@@ -22,4 +22,4 @@ usedScalarBracketEscape: boolean;
  * local retry. Keeping one strict decode path avoids masking malformed input and
  * records `usedScalarBracketEscape: false` for result-shape compatibility.
  */
-export declare function decodeToonItemContent(content: string): ToonDecodeResult;
+export declare function decodeToonItemContent(content:string):ToonDecodeResult;