@unbrained/pm-cli 2026.10.13 → 2026.10.15

package/dist/core/test/run-selectors.d.ts

@@ -11,30 +11,30 @@ export type LinkedTestSelectorKind = "match" | "only-index" | "only-last";
 /** Documents the linked test run selector payload exchanged by command, SDK, and package integrations. */
 export interface LinkedTestRunSelector {
 /** Value that configures or reports match for this contract. */
-match?: string;
+match?:string;
 /** Value that configures or reports only index for this contract. */
-onlyIndex?: number;
+onlyIndex?:number;
 /** Value that configures or reports only last for this contract. */
-onlyLast?: boolean;
+onlyLast?:boolean;
 }
 /** Documents the linked test run selection payload exchanged by command, SDK, and package integrations. */
 export interface LinkedTestRunSelection {
 /** Value that configures or reports selector for this contract. */
-selector: LinkedTestSelectorKind | null;
+selector:LinkedTestSelectorKind | null;
 /** Value that configures or reports requested for this contract. */
-requested: string | null;
+requested:string | null;
 /** Value that configures or reports selected for this contract. */
-selected: LinkedTest[];
+selected:LinkedTest[];
 /** 1-based positions of selected entries in the original `--list` order. */
-selected_indexes: number[];
+selected_indexes:number[];
 /** Number of selected entries represented by this result. */
-selected_count: number;
+selected_count:number;
 /** Number of skipped entries represented by this result. */
-skipped_count: number;
+skipped_count:number;
 }
 /** Implements parse only index value for the public runtime surface of this module. */
-export declare function parseOnlyIndexValue(raw: string | number, optionName?: string): number;
+export declare function parseOnlyIndexValue(raw:string | number,optionName?:string):number;
 /** Implements describe linked test entries for the public runtime surface of this module. */
-export declare function describeLinkedTestEntries(tests: LinkedTest[]): string;
+export declare function describeLinkedTestEntries(tests:LinkedTest[]):string;
 /** Implements resolve linked test run selection for the public runtime surface of this module. */
-export declare function resolveLinkedTestRunSelection(tests: LinkedTest[], selector: LinkedTestRunSelector): LinkedTestRunSelection;
+export declare function resolveLinkedTestRunSelection(tests:LinkedTest[],selector:LinkedTestRunSelector):LinkedTestRunSelection;

package/dist/core/validate/estimate-defaults.d.ts

@@ -12,10 +12,10 @@
  * deterministic, non-throwing style of stale-file-classification.ts).
  */
 /** Built-in per-type default estimates in MINUTES used by `pm validate --auto-fix` (GH-212) to backfill missing `estimated_minutes`. Keys are canonical built-in type names. Lookups are case-insensitive (see resolveEstimateDefaultMinutes). */
-export declare const DEFAULT_ESTIMATE_MINUTES_BY_TYPE: Readonly<Record<string, number>>;
+export declare const DEFAULT_ESTIMATE_MINUTES_BY_TYPE:Readonly<Record<string,number>>;
 /** Fallback when neither overrides nor the built-in map have the type. */
 export declare const FALLBACK_ESTIMATE_MINUTES = 120;
 /** Resolve the default estimated-minutes for an item type. Precedence: overrides (case-insensitive key match) > DEFAULT_ESTIMATE_MINUTES_BY_TYPE (case-insensitive) > FALLBACK_ESTIMATE_MINUTES. - `type` undefined/empty -> FALLBACK. - Only finite values > 0 are honored from overrides/defaults; a non-positive or non-finite override value is ignored and resolution continues to the next tier. - Returned value is a positive integer (floor of the resolved value). */
-export declare function resolveEstimateDefaultMinutes(type: string | undefined, overrides?: Readonly<Record<string, number>>): number;
+export declare function resolveEstimateDefaultMinutes(type:string | undefined,overrides?:Readonly<Record<string,number>>):number;
 /** Validate + normalize a raw `validation.estimate_defaults_by_type` settings object into a clean Record<string, number> of positive integers, dropping invalid entries. Used so the pure resolver always receives a sane override map. Returns {} for undefined/null/non-object input. Trims keys; ignores empty keys and non-positive / non-finite / non-number values. Floors values to integers. */
-export declare function normalizeEstimateDefaultOverrides(raw: unknown): Record<string, number>;
+export declare function normalizeEstimateDefaultOverrides(raw:unknown):Record<string,number>;

package/dist/core/validate/fix-planning.d.ts

@@ -22,91 +22,91 @@ export type ValidateFixKind = "set_resolution" | "set_close_reason" | "set_estim
 /** Restricts validate fix scope values accepted by command, SDK, and storage contracts. */
 export type ValidateFixScope = "metadata" | "resolution" | "estimates" | "timestamps" | "lifecycle";
 /** Scopes auto-applied without an explicit `--fix-scope` (safe field backfills). */
-export declare const DEFAULT_GRANTED_FIX_SCOPES: readonly ValidateFixScope[];
+export declare const DEFAULT_GRANTED_FIX_SCOPES:readonly ValidateFixScope[];
 /** Scopes accepted by `--fix-scope`. Estimates are heuristic, timestamps require verified historical replay, and lifecycle changes are structural; all three require explicit opt-in. */
-export declare const SUPPORTED_FIX_SCOPES: readonly ValidateFixScope[];
+export declare const SUPPORTED_FIX_SCOPES:readonly ValidateFixScope[];
 /** Documents the validate fix record payload exchanged by command, SDK, and package integrations. */
 export interface ValidateFixRecord {
 /** Item the fix targets. */
-item_id: string;
+item_id:string;
 /** Validate check the finding came from. */
-check: ValidateFixCheck;
+check:ValidateFixCheck;
 /** Item-metadata field (or link list) the fix changes. */
-field: string;
+field:string;
 /** Declarative fix kind the applier dispatches on. */
-kind: ValidateFixKind;
+kind:ValidateFixKind;
 /** Equivalent standalone `pm` command for the fix. */
-command: string;
+command:string;
 /** New value for set-field fixes. */
-value?: string;
+value?:string;
 /** Stale link path for prune fixes. */
-path?: string;
+path?:string;
 /** Target parent id for reparent fixes. */
-parent_id?: string;
+parent_id?:string;
 /** Fix scope the `--fix-scope` allowlist must grant for the fix to be applied. Every `--auto-fix` record carries one (the granted default is metadata+resolution; lifecycle must be named explicitly). Absent only on `--prune-missing` records, which are governed by their own flag. */
-gate?: ValidateFixScope;
+gate?:ValidateFixScope;
 }
 /** Documents the resolution backfill row payload exchanged by command, SDK, and package integrations. */
 export interface ResolutionBackfillRow {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Resolution-check missing field keys for this closed item. */
-missing_fields: readonly string[];
+missing_fields:readonly string[];
 /** The item's close_reason, when present (preferred derivation source). */
-close_reason?: string;
+close_reason?:string;
 }
 /** Plan resolution backfills for closed items flagged by the resolution check. Only the `resolution` field is mechanical enough to auto-fix: it derives from the item's own `close_reason` when present and falls back to the `"completed"` default. `expected_result` / `actual_result` stay hint-only — no deterministic source text exists for them. */
-export declare function planResolutionBackfillFixes(rows: readonly ResolutionBackfillRow[]): ValidateFixRecord[];
+export declare function planResolutionBackfillFixes(rows:readonly ResolutionBackfillRow[]):ValidateFixRecord[];
 /** Documents the close reason backfill row payload exchanged by command, SDK, and package integrations. */
 export interface CloseReasonBackfillRow {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** The item's resolution, when present (the only derivation source). */
-resolution?: string;
+resolution?:string;
 }
 /** Plan close_reason backfills for closed items flagged by the metadata check. Only derivable when the item already carries a resolution; items missing both stay hint-only (any synthesized reason would be fabricated, not derived). */
-export declare function planCloseReasonBackfillFixes(rows: readonly CloseReasonBackfillRow[]): ValidateFixRecord[];
+export declare function planCloseReasonBackfillFixes(rows:readonly CloseReasonBackfillRow[]):ValidateFixRecord[];
 /** Documents the estimate backfill row payload exchanged by command, SDK, and package integrations. */
 export interface EstimateBackfillRow {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Item type, used to resolve the per-type default estimate. */
-type?: string;
+type?:string;
 }
 /** Plan estimate backfills for items flagged by the metadata check as missing `estimated_minutes` (GH-212). The value is a config-driven per-type default (overrides > built-in map > fallback), never a derived fact — so these fixes carry `gate: "estimates"`, an opt-in scope that is NOT granted by default. `overrides` is the already-normalized `validation.estimate_defaults_by_type` map; pass `undefined`/`{}` to use the built-in defaults. */
-export declare function planEstimateBackfillFixes(rows: readonly EstimateBackfillRow[], overrides?: Readonly<Record<string, number>>): ValidateFixRecord[];
+export declare function planEstimateBackfillFixes(rows:readonly EstimateBackfillRow[],overrides?:Readonly<Record<string,number>>):ValidateFixRecord[];
 /** Documents the terminal parent fix row payload exchanged by command, SDK, and package integrations. */
 export interface TerminalParentFixRow {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Value that configures or reports parent id for this contract. */
-parent_id: string;
+parent_id:string;
 /** The terminal parent's own parent, when one exists. */
-grandparent_id?: string;
+grandparent_id?:string;
 /** True when the grandparent exists and is NOT terminal (safe reparent target). */
-grandparent_active?: boolean;
+grandparent_active?:boolean;
 }
 /** Plan lifecycle fixes for active items whose parent is terminal (pm-8jss / GH-168). When the terminal parent has an active grandparent, the child is reparented one level up (it stays inside the same hierarchy); otherwise the parent link is cleared so the item surfaces as unparented active work. Either way the item itself is never closed or mutated beyond `parent` — and every fix carries `gate: "lifecycle"` so it is only applied under an explicit `--fix-scope lifecycle`. */
-export declare function planTerminalParentFixes(rows: readonly TerminalParentFixRow[]): ValidateFixRecord[];
+export declare function planTerminalParentFixes(rows:readonly TerminalParentFixRow[]):ValidateFixRecord[];
 /** Documents the stale link prune row payload exchanged by command, SDK, and package integrations. */
 export interface StaleLinkPruneRow {
 /** Value that configures or reports item id for this contract. */
-item_id: string;
+item_id:string;
 /** Filesystem path used for path resolution. */
-path: string;
+path:string;
 /** Value that configures or reports link kind for this contract. */
-link_kind: "files" | "docs";
+link_kind:"files" | "docs";
 /** Value that configures or reports classification for this contract. */
-classification: "moved" | "deleted" | "malformed";
+classification:"moved" | "deleted" | "malformed";
 }
 /** Plan link prunes for `--prune-missing` (pm-0v2m / GH-184). Only links whose stale path classified as `deleted` are pruned; `moved` links keep their relink candidates in the files-check details instead of being dropped, so recoverable link information is never destroyed. Link removal only — real files are never touched. */
-export declare function planStaleLinkPruneFixes(rows: readonly StaleLinkPruneRow[]): ValidateFixRecord[];
+export declare function planStaleLinkPruneFixes(rows:readonly StaleLinkPruneRow[]):ValidateFixRecord[];
 /** Resolve the granted `--fix-scope` set (repeatable and/or comma-separated). With no explicit scopes the safe field-backfill scopes (metadata, resolution) are granted; lifecycle must always be named explicitly. Unknown values fail fast with the supported list. */
-export declare function resolveGrantedFixScopes(rawScopes: readonly string[] | undefined): Set<ValidateFixScope>;
+export declare function resolveGrantedFixScopes(rawScopes:readonly string[] | undefined):Set<ValidateFixScope>;
 /** Split a fix plan into the records that may be applied under the granted scopes and the gated records that were withheld. `--fix-scope` is an exact allowlist: every `--auto-fix` record requires its gate scope in `granted`. Ungated records (`--prune-missing` link prunes, governed by their own flag) are always applicable. */
-export declare function partitionFixesByGrant(fixes: readonly ValidateFixRecord[], granted: ReadonlySet<ValidateFixScope>): {
-applicable: ValidateFixRecord[];
-gated: ValidateFixRecord[];
+export declare function partitionFixesByGrant(fixes:readonly ValidateFixRecord[],granted:ReadonlySet<ValidateFixScope>):{
+applicable:ValidateFixRecord[];
+gated:ValidateFixRecord[];
 };
 /** Compact serialization of a fix for planned/applied output rows. */
-export declare function toFixOutputRow(fix: ValidateFixRecord): Record<string, unknown>;
+export declare function toFixOutputRow(fix:ValidateFixRecord):Record<string,unknown>;

package/dist/core/validate/linked-artifact-reference.d.ts

@@ -17,4 +17,4 @@
  * string and branch on the boolean result.
  */
 /** Return `true` when a linked-artifact path is a remote reference (a URL with a `scheme://` authority) rather than a local filesystem path. Whitespace is trimmed before matching so a stored `" https://…"` is still recognized. */
-export declare function isRemoteLinkedArtifactReference(path: string): boolean;
+export declare function isRemoteLinkedArtifactReference(path:string):boolean;

package/dist/core/validate/missing-by-type.d.ts

@@ -10,9 +10,9 @@
 /** One missing required metadata field observed on an item of a specific type. */
 export interface MissingFieldOccurrence {
 /** Item type name as stored in item metadata (e.g. "Task"). */
-item_type: string;
+item_type:string;
 /** Required metadata field that is missing on the item. */
-field: string;
+field:string;
 }
 /** Aggregate missing-field occurrences into `{ type: { field: count } }` with both levels sorted lexicographically for stable, diff-friendly output. Zero counts never appear (only observed occurrences are aggregated). */
-export declare function buildMissingByTypeCounts(occurrences: Iterable<MissingFieldOccurrence>): Record<string, Record<string, number>>;
+export declare function buildMissingByTypeCounts(occurrences:Iterable<MissingFieldOccurrence>):Record<string,Record<string,number>>;

package/dist/core/validate/missing-link-owners.d.ts

@@ -17,44 +17,44 @@ export type StaleLinkClassification = "moved" | "deleted" | "malformed";
 /** Documents the stale link owner input payload exchanged by command, SDK, and package integrations. */
 export interface StaleLinkOwnerInput {
 /** Value that configures or reports item id for this contract. */
-item_id: string;
+item_id:string;
 /** Normalized workspace-relative path that no longer resolves. */
-path: string;
+path:string;
 /** Which link list of the owning item the path lives in. */
-link_kind: "files" | "docs";
+link_kind:"files" | "docs";
 /** Value that configures or reports classification for this contract. */
-classification: StaleLinkClassification;
+classification:StaleLinkClassification;
 }
 /** Documents the missing linked path owner payload exchanged by command, SDK, and package integrations. */
 export interface MissingLinkedPathOwner {
 /** Stable identifier used to reference this record across commands and storage. */
-id: string;
+id:string;
 /** Owning item type, `"Unknown"` if metadata is absent. */
-type: string;
+type:string;
 /** Owning item title, `""` if absent. */
-title: string;
+title:string;
 /** Owning item status, `""` if absent. */
-status: string;
+status:string;
 /** The link list the path lives in (= the input `link_kind`). */
-field: "files" | "docs";
+field:"files" | "docs";
 }
 /** Documents the missing linked path row payload exchanged by command, SDK, and package integrations. */
 export interface MissingLinkedPathRow {
 /** Filesystem path used for path resolution. */
-path: string;
+path:string;
 /** Value that configures or reports classification for this contract. */
-classification: StaleLinkClassification;
+classification:StaleLinkClassification;
 /** Value that configures or reports items for this contract. */
-items: MissingLinkedPathOwner[];
+items:MissingLinkedPathOwner[];
 }
 /** Documents the owner item metadata payload exchanged by command, SDK, and package integrations. */
 export interface OwnerItemMetadata {
 /** Schema type that determines the shape and validation rules for this value. */
-type?: string;
+type?:string;
 /** Value that configures or reports title for this contract. */
-title?: string;
+title?:string;
 /** Lifecycle state reported for status. */
-status?: string;
+status?:string;
 }
 /**
  * Group stale-link owner inputs by linked path and attach owning-item metadata.
@@ -65,7 +65,7 @@ status?: string;
  * - `classification` per path follows {@link preferClassification} (moved wins).
  * - Missing metadata falls back: type `"Unknown"`, title `""`, status `""`.
  */
-export declare function buildMissingLinkedPathRows(rows: readonly StaleLinkOwnerInput[], lookup: (itemId: string) => OwnerItemMetadata | undefined): MissingLinkedPathRow[];
+export declare function buildMissingLinkedPathRows(rows:readonly StaleLinkOwnerInput[],lookup:(itemId:string) => OwnerItemMetadata | undefined):MissingLinkedPathRow[];
 /**
  * Token-efficient one-line-per-owner serialization for the files-check details
  * (compact text counterpart to the full {@link MissingLinkedPathRow} objects).
@@ -75,4 +75,4 @@ export declare function buildMissingLinkedPathRows(rows: readonly StaleLinkOwner
  * render (`status=` and `title=""`). Order follows
  * {@link buildMissingLinkedPathRows} output order.
  */
-export declare function summarizeMissingLinkedPathRows(rows: readonly MissingLinkedPathRow[]): string[];
+export declare function summarizeMissingLinkedPathRows(rows:readonly MissingLinkedPathRow[]):string[];

package/dist/core/validate/stale-file-classification.d.ts

@@ -18,17 +18,17 @@ export type StaleLinkedPathClassification = "moved" | "deleted" | "malformed";
 /** Documents the classified stale linked path payload exchanged by command, SDK, and package integrations. */
 export interface ClassifiedStaleLinkedPath {
 /** Normalized workspace-relative stale linked path. */
-path: string;
+path:string;
 /** Value that configures or reports classification for this contract. */
-classification: StaleLinkedPathClassification;
+classification:StaleLinkedPathClassification;
 /** Candidate new locations (same basename, different path), sorted and capped at `candidateLimit`. Empty for `deleted` and `malformed`. */
-candidates: string[];
+candidates:string[];
 /** True when more candidates existed than `candidateLimit` allowed. */
-candidates_truncated: boolean;
+candidates_truncated:boolean;
 }
 /** Fallback stale path candidate limit used when callers do not provide an override. */
 export declare const DEFAULT_STALE_PATH_CANDIDATE_LIMIT = 3;
 /** Classify each stale (missing) linked path as `moved`, `deleted`, or `malformed` by matching its basename against the candidate file list. Output preserves the input order of `stalePaths` (callers pass an already-sorted unique list). A candidate equal to the stale path itself never matches (the path is known missing; an identical candidate would be self-referential noise). */
-export declare function classifyStaleLinkedPaths(stalePaths: readonly string[], candidateFiles: readonly string[], candidateLimit?: number): ClassifiedStaleLinkedPath[];
+export declare function classifyStaleLinkedPaths(stalePaths:readonly string[],candidateFiles:readonly string[],candidateLimit?:number):ClassifiedStaleLinkedPath[];
 /** Render compact `<path>:moved:<top-candidate>` / `<path>:deleted` rows for the files check details (token-efficient counterpart to the full classification objects). */
-export declare function summarizeStaleLinkedPathClassifications(classified: readonly ClassifiedStaleLinkedPath[]): string[];
+export declare function summarizeStaleLinkedPathClassifications(classified:readonly ClassifiedStaleLinkedPath[]):string[];

package/dist/mcp/http-server.d.ts

@@ -5,56 +5,56 @@
  * Serves the pm MCP dispatcher through the sessionless 2026-07-28 Streamable
  * HTTP POST binding with request-scoped JSON/SSE responses.
  */
-import { type IncomingMessage, type Server, type ServerResponse } from "node:http";
-import { type PmMcpHttpAuthorizationPolicy, type PmMcpProtectedResourceMetadata } from "../sdk/mcp/authorization.js";
+import { type IncomingMessage,type Server,type ServerResponse } from "node:http";
+import { type PmMcpHttpAuthorizationPolicy,type PmMcpProtectedResourceMetadata } from "../sdk/mcp/authorization.js";
 import { type JsonRpcRequest } from "./server.js";
 /** Runtime options for one real Streamable HTTP server. */
 export interface PmMcpHttpServerOptions {
 /** Local bind host. Defaults to the DNS-rebinding-safe loopback address. */
-host?: string;
+host?:string;
 /** TCP port. Zero requests an ephemeral port. */
-port?: number;
+port?:number;
 /** Single modern MCP POST endpoint. */
-endpointPath?: string;
+endpointPath?:string;
 /** Exact browser origins permitted when an Origin header is present. */
-allowedOrigins?: readonly string[];
+allowedOrigins?:readonly string[];
 /** Optional RFC 9728/OAuth resource-server policy. */
-authorization?: PmMcpHttpAuthorizationPolicy;
+authorization?:PmMcpHttpAuthorizationPolicy;
 /** Metadata served at RFC 9728 well-known paths. */
-protectedResourceMetadata?: PmMcpProtectedResourceMetadata;
+protectedResourceMetadata?:PmMcpProtectedResourceMetadata;
 /** Maximum accepted JSON request bytes. */
-maximumBodyBytes?: number;
+maximumBodyBytes?:number;
 /** SSE comment interval; zero disables keep-alives. */
-keepAliveMs?: number;
+keepAliveMs?:number;
 /** Optional embedding dispatcher; defaults to the canonical pm MCP handler. */
-requestHandler?: (request: JsonRpcRequest) => unknown | Promise<unknown>;
+requestHandler?:(request:JsonRpcRequest) => unknown | Promise<unknown>;
 }
 /** Write one SSE event and wait for transport backpressure to clear. */
-export declare function writePmMcpSseEvent(response: ServerResponse, payload: unknown): Promise<void>;
-declare function writeMcpHttpDispatchError(response: ServerResponse, rpcRequest: JsonRpcRequest | undefined, error: unknown): void;
-declare function destroyFailedMcpHttpResponse(response: ServerResponse, error: unknown): void;
+export declare function writePmMcpSseEvent(response:ServerResponse,payload:unknown):Promise<void>;
+declare function writeMcpHttpDispatchError(response:ServerResponse,rpcRequest:JsonRpcRequest | undefined,error:unknown):void;
+declare function destroyFailedMcpHttpResponse(response:ServerResponse,error:unknown):void;
 /** Create a configured HTTP server without binding it. */
-export declare function createPmMcpHttpServer(options?: PmMcpHttpServerOptions): Server<typeof IncomingMessage, typeof ServerResponse>;
+export declare function createPmMcpHttpServer(options?:PmMcpHttpServerOptions):Server<typeof IncomingMessage,typeof ServerResponse>;
 /** Gracefully close subscriptions before stopping a Streamable HTTP server. */
-export declare function closePmMcpHttpServer(server: Server): Promise<void>;
+export declare function closePmMcpHttpServer(server:Server):Promise<void>;
 /** Bind the configured Streamable HTTP server and return its actual address. */
-export declare function startPmMcpHttpServer(options?: PmMcpHttpServerOptions): Promise<ReturnType<typeof createPmMcpHttpServer>>;
+export declare function startPmMcpHttpServer(options?:PmMcpHttpServerOptions):Promise<ReturnType<typeof createPmMcpHttpServer>>;
 /** Resolve loopback-safe bind defaults without opening a socket. */
-export declare function resolvePmMcpHttpListenAddress(options?: Pick<PmMcpHttpServerOptions, "host" | "port">): {
-host: string;
-port: number;
+export declare function resolvePmMcpHttpListenAddress(options?:Pick<PmMcpHttpServerOptions,"host" | "port">):{
+host:string;
+port:number;
 };
 /** Resolve and harden executable HTTP options from an environment map. */
-export declare function resolvePmMcpHttpServerOptionsFromEnvironment(processEnvironment?: NodeJS.ProcessEnv): PmMcpHttpServerOptions;
+export declare function resolvePmMcpHttpServerOptionsFromEnvironment(processEnvironment?:NodeJS.ProcessEnv):PmMcpHttpServerOptions;
 /** Internal HTTP transport seams used only by direct integration tests. */
-export declare const _testOnly: {
+export declare const _testOnly:{
 /** Return the first active request-scoped transport key for one server. */
-activeSubscriptionKey: (server: Server) => symbol | undefined;
+activeSubscriptionKey:(server:Server) => symbol | undefined;
 /** Open a stream against one server runtime without a network socket. */
-openHttpSubscription: (server: Server, request: JsonRpcRequest, response: ServerResponse) => Promise<void>;
+openHttpSubscription:(server:Server,request:JsonRpcRequest,response:ServerResponse) => Promise<void>;
 /** Exercise committed-response handling without a network race. */
-writeMcpHttpDispatchError: typeof writeMcpHttpDispatchError;
+writeMcpHttpDispatchError:typeof writeMcpHttpDispatchError;
 /** Exercise the terminal request rejection handler without a live socket. */
-destroyFailedMcpHttpResponse: typeof destroyFailedMcpHttpResponse;
+destroyFailedMcpHttpResponse:typeof destroyFailedMcpHttpResponse;
 };
 export {};

package/dist/mcp/legacy-adapter.d.ts

@@ -5,36 +5,36 @@
  * canonical stateless dispatcher. No modern transport imports policy from it.
  */
 import { type AgentClientInfo } from "../sdk/runtime-primitives.js";
-import { PM_MCP_LEGACY_PROTOCOL_VERSIONS, type PmMcpImplementation, type PmMcpServerCapabilities } from "../sdk/mcp/protocol.js";
+import { PM_MCP_LEGACY_PROTOCOL_VERSIONS,type PmMcpImplementation,type PmMcpServerCapabilities } from "../sdk/mcp/protocol.js";
 /** Minimal request shape consumed by the compatibility adapter. */
 export interface LegacyMcpRequest {
 /** Legacy method name. */
-method?: string;
+method?:string;
 /** Legacy method parameters. */
-params?: Record<string, unknown>;
+params?:Record<string,unknown>;
 }
 /** Host callbacks keep this adapter separate from canonical SDK policy. */
 export interface LegacyMcpAdapterOptions {
 /** Immutable server identity. */
-serverInfo: PmMcpImplementation;
+serverInfo:PmMcpImplementation;
 /** Compatibility-era capabilities. */
-capabilities: PmMcpServerCapabilities;
+capabilities:PmMcpServerCapabilities;
 /** Model-facing usage instructions. */
-instructions: string;
+instructions:string;
 /** Parse bounded historical client identity. */
-parseClientInfo: (value: unknown) => AgentClientInfo | undefined;
+parseClientInfo:(value:unknown) => AgentClientInfo | undefined;
 /** Resolve legacy tool definitions. */
-listTools: (params: Record<string, unknown> | undefined) => Promise<Record<string, unknown>>;
+listTools:(params:Record<string,unknown> | undefined) => Promise<Record<string,unknown>>;
 /** Execute one legacy tool call. */
-callTool: (params: Record<string, unknown> | undefined, clientInfo: AgentClientInfo | undefined) => Promise<Record<string, unknown>>;
+callTool:(params:Record<string,unknown> | undefined,clientInfo:AgentClientInfo | undefined) => Promise<Record<string,unknown>>;
 /** List legacy resources. */
-listResources: () => Record<string, unknown>;
+listResources:() => Record<string,unknown>;
 /** Read one legacy resource. */
-readResource: (params: Record<string, unknown> | undefined) => Promise<Record<string, unknown>>;
+readResource:(params:Record<string,unknown> | undefined) => Promise<Record<string,unknown>>;
 /** List legacy prompts. */
-listPrompts: () => Record<string, unknown>;
+listPrompts:() => Record<string,unknown>;
 /** Render one legacy prompt. */
-getPrompt: (params: Record<string, unknown> | undefined) => Record<string, unknown>;
+getPrompt:(params:Record<string,unknown> | undefined) => Record<string,unknown>;
 }
 /**
  * Resolve the legacy revision a handshake negotiates, or refuse with the full
@@ -44,16 +44,16 @@ getPrompt: (params: Record<string, unknown> | undefined) => Record<string, unkno
  * accepted legacy revision alongside the canonical modern one: the error text
  * is the only diagnostic such a client can surface.
  */
-export declare function resolveLegacyProtocolVersion(requestedVersion: unknown): (typeof PM_MCP_LEGACY_PROTOCOL_VERSIONS)[number];
+export declare function resolveLegacyProtocolVersion(requestedVersion:unknown):(typeof PM_MCP_LEGACY_PROTOCOL_VERSIONS)[number];
 /** Explicit compatibility adapter with no cross-process or modern-session role. */
 export declare class LegacyMcpAdapter {
 #private;
 /** Create one process-local legacy stdio adapter. */
-constructor(options: LegacyMcpAdapterOptions);
+constructor(options:LegacyMcpAdapterOptions);
 /** Read the bounded identity most recently supplied to legacy initialize. */
-getClientInfo(): AgentClientInfo | undefined;
+getClientInfo():AgentClientInfo | undefined;
 /** Validate and answer the historical initialize handshake. */
-initialize(params: Record<string, unknown> | undefined): Record<string, unknown>;
+initialize(params:Record<string,unknown> | undefined):Record<string,unknown>;
 /** Dispatch one unversioned request through the finite legacy method set. */
-dispatch(request: LegacyMcpRequest): Promise<Record<string, unknown>>;
+dispatch(request:LegacyMcpRequest):Promise<Record<string,unknown>>;
 }

package/dist/mcp/runtime-capabilities.d.ts

@@ -5,53 +5,53 @@
  * public SDK contracts.
  */
 import { type PmMcpToolProfile } from "../sdk/agent-capability-contracts.js";
-import { type WorkspaceContracts, type WorkspaceExtensionCommandContract } from "../sdk/runtime.js";
+import { type WorkspaceContracts,type WorkspaceExtensionCommandContract } from "../sdk/runtime.js";
 import { type ToolDefinition } from "./tool-definitions.js";
 /** Environment configuration accepted by the MCP profile resolver. */
 export interface McpProfileEnvironment {
 /** Named built-in or custom MCP surface profile. */
-PM_MCP_PROFILE?: string;
+PM_MCP_PROFILE?:string;
 /** Comma-separated exact tool allowlist used by the custom profile. */
-PM_MCP_TOOLS?: string;
+PM_MCP_TOOLS?:string;
 }
 /** Fully resolved MCP tool surface for one request workspace. */
 export interface ResolvedMcpToolSurface {
 /** Resolved profile after environment validation. */
-profile: PmMcpToolProfile;
+profile:PmMcpToolProfile;
 /** Runtime-filtered and workspace-enriched MCP definitions. */
-tools: ToolDefinition[];
+tools:ToolDefinition[];
 /** Extension action names reachable through the selected surface. */
-extensionActions: string[];
+extensionActions:string[];
 }
 /** Profile decision for one tool call without projecting every tool schema. */
 export interface ResolvedMcpToolAccess {
 /** Resolved profile after environment validation. */
-profile: PmMcpToolProfile;
+profile:PmMcpToolProfile;
 /** Whether the requested tool is callable in that profile and workspace. */
-available: boolean;
+available:boolean;
 }
-declare function workspaceFields(workspace: Pick<WorkspaceContracts, "fields">): NonNullable<WorkspaceContracts["fields"]>;
-declare function workspaceExtensionCommands(workspace: Pick<WorkspaceContracts, "extensionCommands">): NonNullable<WorkspaceContracts["extensionCommands"]>;
+declare function workspaceFields(workspace:Pick<WorkspaceContracts,"fields">):NonNullable<WorkspaceContracts["fields"]>;
+declare function workspaceExtensionCommands(workspace:Pick<WorkspaceContracts,"extensionCommands">):NonNullable<WorkspaceContracts["extensionCommands"]>;
 /** Resolve and validate the configured MCP profile. */
-export declare function resolveMcpToolProfile(environment?: McpProfileEnvironment): PmMcpToolProfile;
+export declare function resolveMcpToolProfile(environment?:McpProfileEnvironment):PmMcpToolProfile;
 /** Select extension actions visible to one validated MCP profile. */
-export declare function selectMcpExtensionActions(commands: readonly WorkspaceExtensionCommandContract[], profile: PmMcpToolProfile, selectedNames: ReadonlySet<string>): string[];
+export declare function selectMcpExtensionActions(commands:readonly WorkspaceExtensionCommandContract[],profile:PmMcpToolProfile,selectedNames:ReadonlySet<string>):string[];
 /**
  * Resolve a profile-filtered tool list and enrich schemas with live workspace
  * types, statuses, custom fields, and extension actions.
  */
-export declare function resolveMcpToolSurface(availableTools: readonly ToolDefinition[], args?: Record<string, unknown>, environment?: McpProfileEnvironment): Promise<ResolvedMcpToolSurface>;
+export declare function resolveMcpToolSurface(availableTools:readonly ToolDefinition[],args?:Record<string,unknown>,environment?:McpProfileEnvironment):Promise<ResolvedMcpToolSurface>;
 /**
  * Resolve one tool's callability without cloning and enriching the complete
  * schema surface. Only compact/standard `pm_run` calls need workspace
  * contracts because an activated extension action can promote that dispatcher.
  */
-export declare function resolveMcpToolAccess(availableTools: readonly ToolDefinition[], toolName: string, args?: Record<string, unknown>, environment?: McpProfileEnvironment): Promise<ResolvedMcpToolAccess>;
+export declare function resolveMcpToolAccess(availableTools:readonly ToolDefinition[],toolName:string,args?:Record<string,unknown>,environment?:McpProfileEnvironment):Promise<ResolvedMcpToolAccess>;
 /** Move declared custom-field inputs into the runtime action option bag. */
-export declare function normalizeWorkspaceToolArguments(toolName: string, args: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function normalizeWorkspaceToolArguments(toolName:string,args:Record<string,unknown>):Promise<Record<string,unknown>>;
 /** Internal compatibility helpers exposed only for exhaustive fallback tests. */
-export declare const _testOnlyMcpRuntimeCapabilities: {
-workspaceExtensionCommands: typeof workspaceExtensionCommands;
-workspaceFields: typeof workspaceFields;
+export declare const _testOnlyMcpRuntimeCapabilities:{
+workspaceExtensionCommands:typeof workspaceExtensionCommands;
+workspaceFields:typeof workspaceFields;
 };
 export {};