@unbrained/pm-cli 2026.8.23 → 2026.8.24

package/dist/sdk/agent/refusal-closure-census.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @module sdk/agent/refusal-closure-census
+ *
+ * Joins the complete emitted error vocabulary to every executable refusal
+ * corpus. Missing proof remains an explicit row; no catalog code disappears
+ * merely because it has not yet received a probe.
+ */
+import type { PmErrorCodeContract } from "../error-code-catalog.js";
+import type { PmClosedDomainContract } from "./closed-domain-contracts.js";
+import type { PmGrammarRefusalContract } from "./refusal-corpus-contracts.js";
+/** Evidence family that makes an error code executable. */
+export type PmRefusalEvidenceKind = "owned_state" | "closed_domain" | "grammar";
+/** One complete-catalog closure row. */
+export interface PmRefusalClosureCensusRow {
+    /** Declared machine-readable error code. */
+    code: string;
+    /** Canonical compatibility-group code. */
+    canonical_code: string;
+    /** Whether at least one executable probe reaches the compatibility group. */
+    disposition: "executable" | "uncovered";
+    /** Evidence families contributing executable probes. */
+    evidence_kinds: PmRefusalEvidenceKind[];
+    /** Stable executable probe identities. */
+    probe_ids: string[];
+}
+/** Full emitted-vocabulary refusal closure receipt. */
+export interface PmRefusalClosureCensusReport {
+    /** True only when every catalog code belongs to a probed compatibility group. */
+    ok: boolean;
+    /** Number of emitted codes in the catalog. */
+    catalog_error_code_count: number;
+    /** Number of codes backed by executable evidence. */
+    executable_error_code_count: number;
+    /** Number of codes still lacking executable evidence. */
+    uncovered_error_code_count: number;
+    /** Executable codes divided by all catalog codes. */
+    coverage_fraction: number;
+    /** Number of closed-domain probes joined into the census. */
+    closed_domain_probe_count: number;
+    /** Number of grammar-derived probes joined into the census. */
+    grammar_probe_count: number;
+    /** Stable complete list of codes without executable evidence. */
+    uncovered_error_codes: string[];
+    /** Exactly one row for every catalog code. */
+    rows: PmRefusalClosureCensusRow[];
+}
+/** Reviewed floor of 16 catalog rows; includes one alias across 15 canonical groups. */
+export declare const PM_REFUSAL_CLOSURE_EXECUTABLE_CODE_BASELINE = 16;
+/** Fifteen canonical compatibility groups that must retain executable evidence. */
+export declare const PM_REFUSAL_CLOSURE_EXECUTABLE_CANONICAL_CODE_BASELINE: readonly ["bulk_ids_input_empty", "bulk_ids_input_missing_path", "bulk_ids_input_unreadable", "invalid_argument_value", "missing_lifecycle_target", "missing_required_argument", "projection_options_mutually_exclusive", "tracker_not_initialized", "tracker_root_missing", "tracker_root_not_directory", "tracker_root_unreadable", "unknown_context_intent", "unknown_field_projection", "unknown_option", "unknown_subcommand"];
+/** Ratchet receipt that prevents catalog growth from erasing proven closure. */
+export declare function verifyPmRefusalClosureRatchet(report: PmRefusalClosureCensusReport, baseline?: number): {
+    ok: boolean;
+    baseline: number;
+    actual: number;
+};
+/** Ratchet canonical compatibility-group identities independently from counts. */
+export declare function verifyPmRefusalClosureIdentityRatchet(report: PmRefusalClosureCensusReport, requiredCanonicalCodes?: readonly string[]): {
+    ok: boolean;
+    required_canonical_codes: string[];
+    missing_required_canonical_codes: string[];
+};
+/** Build the complete closure join without silently omitting uncovered codes. */
+export declare function buildPmRefusalClosureCensus(catalog: readonly PmErrorCodeContract[], closedDomains: readonly PmClosedDomainContract[], grammar: readonly PmGrammarRefusalContract[]): PmRefusalClosureCensusReport;
+/** Render the complete census for generated documentation and review evidence. */
+export declare function renderPmRefusalClosureCensusMarkdown(report: PmRefusalClosureCensusReport): string;

package/dist/sdk/agent/refusal-closure-census.js

@@ -0,0 +1,144 @@
+/** Reviewed floor of 16 catalog rows; includes one alias across 15 canonical groups. */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="5560aa3a-036e-509c-955c-a09e9bf9df18")}catch(e){}}();
+export const PM_REFUSAL_CLOSURE_EXECUTABLE_CODE_BASELINE = 16;
+/** Fifteen canonical compatibility groups that must retain executable evidence. */
+export const PM_REFUSAL_CLOSURE_EXECUTABLE_CANONICAL_CODE_BASELINE = Object.freeze([
+    "bulk_ids_input_empty",
+    "bulk_ids_input_missing_path",
+    "bulk_ids_input_unreadable",
+    "invalid_argument_value",
+    "missing_lifecycle_target",
+    "missing_required_argument",
+    "projection_options_mutually_exclusive",
+    "tracker_not_initialized",
+    "tracker_root_missing",
+    "tracker_root_not_directory",
+    "tracker_root_unreadable",
+    "unknown_context_intent",
+    "unknown_field_projection",
+    "unknown_option",
+    "unknown_subcommand",
+]);
+/** Ratchet receipt that prevents catalog growth from erasing proven closure. */
+export function verifyPmRefusalClosureRatchet(report, baseline = PM_REFUSAL_CLOSURE_EXECUTABLE_CODE_BASELINE) {
+    return {
+        ok: report.executable_error_code_count >= baseline,
+        baseline,
+        actual: report.executable_error_code_count,
+    };
+}
+/** Ratchet canonical compatibility-group identities independently from counts. */
+export function verifyPmRefusalClosureIdentityRatchet(report, requiredCanonicalCodes = PM_REFUSAL_CLOSURE_EXECUTABLE_CANONICAL_CODE_BASELINE) {
+    const executableCanonicalCodes = new Set(report.rows
+        .filter(({ disposition }) => disposition === "executable")
+        .map(({ canonical_code: canonicalCode }) => canonicalCode));
+    const missingRequiredCanonicalCodes = requiredCanonicalCodes.filter((code) => !executableCanonicalCodes.has(code));
+    return {
+        ok: missingRequiredCanonicalCodes.length === 0,
+        required_canonical_codes: [...requiredCanonicalCodes],
+        missing_required_canonical_codes: missingRequiredCanonicalCodes,
+    };
+}
+function evidenceFor(evidence, canonicalCode) {
+    const existing = evidence.get(canonicalCode);
+    if (existing)
+        return existing;
+    const created = {
+        kinds: new Set(),
+        probeIds: new Set(),
+    };
+    evidence.set(canonicalCode, created);
+    return created;
+}
+/** Build the complete closure join without silently omitting uncovered codes. */
+export function buildPmRefusalClosureCensus(catalog, closedDomains, grammar) {
+    const canonicalByCode = new Map(catalog.map((contract) => [
+        contract.code,
+        contract.canonical_code ?? contract.code,
+    ]));
+    const evidence = new Map();
+    let closedDomainProbeCount = 0;
+    let grammarProbeCount = 0;
+    for (const contract of catalog) {
+        const target = evidenceFor(evidence, contract.canonical_code ?? contract.code);
+        for (const state of contract.owned_states ?? []) {
+            target.kinds.add("owned_state");
+            target.probeIds.add(state.probe_id);
+        }
+    }
+    for (const contract of closedDomains) {
+        const canonical = canonicalByCode.get(contract.error_code);
+        if (canonical === undefined)
+            continue;
+        closedDomainProbeCount += 1;
+        const target = evidenceFor(evidence, canonical);
+        target.kinds.add("closed_domain");
+        target.probeIds.add(contract.probe_id);
+    }
+    for (const contract of grammar) {
+        const canonical = canonicalByCode.get(contract.error_code);
+        if (canonical === undefined)
+            continue;
+        grammarProbeCount += 1;
+        const target = evidenceFor(evidence, canonical);
+        target.kinds.add("grammar");
+        target.probeIds.add(contract.probe_id);
+    }
+    const rows = catalog
+        .map((contract) => {
+        const canonicalCode = contract.canonical_code ?? contract.code;
+        const joined = evidence.get(canonicalCode);
+        const probeIds = [...joined.probeIds].sort();
+        return {
+            code: contract.code,
+            canonical_code: canonicalCode,
+            disposition: probeIds.length > 0 ? "executable" : "uncovered",
+            evidence_kinds: [...joined.kinds].sort(),
+            probe_ids: probeIds,
+        };
+    })
+        .sort((left, right) => (left.code < right.code ? -1 : 1));
+    const uncoveredErrorCodes = rows
+        .filter(({ disposition }) => disposition === "uncovered")
+        .map(({ code }) => code);
+    const executableCount = rows.length - uncoveredErrorCodes.length;
+    return {
+        ok: uncoveredErrorCodes.length === 0,
+        catalog_error_code_count: rows.length,
+        executable_error_code_count: executableCount,
+        uncovered_error_code_count: uncoveredErrorCodes.length,
+        coverage_fraction: rows.length === 0 ? 1 : executableCount / rows.length,
+        closed_domain_probe_count: closedDomainProbeCount,
+        grammar_probe_count: grammarProbeCount,
+        uncovered_error_codes: uncoveredErrorCodes,
+        rows,
+    };
+}
+/** Render the complete census for generated documentation and review evidence. */
+export function renderPmRefusalClosureCensusMarkdown(report) {
+    const rows = report.rows.map((row) => `| \`${row.code}\` | \`${row.canonical_code}\` | ${row.disposition} | ${row.evidence_kinds.join(", ") || "none"} | ${row.probe_ids.length} |`);
+    return [
+        "# Generated refusal closure census",
+        "",
+        "Tracker: `pm-f05lsg`.",
+        "",
+        "Every catalog code is listed. An `uncovered` row is an explicit closure obligation, never an omission or implied approval.",
+        "",
+        `- Catalog error codes: ${report.catalog_error_code_count}`,
+        `- Executable error codes: ${report.executable_error_code_count}`,
+        `- Executable-code ratchet floor: ${PM_REFUSAL_CLOSURE_EXECUTABLE_CODE_BASELINE}`,
+        `- Required executable canonical codes: ${PM_REFUSAL_CLOSURE_EXECUTABLE_CANONICAL_CODE_BASELINE.map((code) => `\`${code}\``).join(", ")}`,
+        `- Uncovered error codes: ${report.uncovered_error_code_count}`,
+        `- Coverage fraction: ${report.coverage_fraction.toFixed(6)}`,
+        `- Closed-domain probes: ${report.closed_domain_probe_count}`,
+        `- Grammar probes: ${report.grammar_probe_count}`,
+        "",
+        "| Error code | Canonical code | Disposition | Evidence kinds | Probe count |",
+        "| --- | --- | --- | --- | --- |",
+        ...rows,
+        "",
+    ].join("\n");
+}
+//# sourceMappingURL=refusal-closure-census.js.map
+//# debugId=5560aa3a-036e-509c-955c-a09e9bf9df18

package/dist/sdk/agent-capability-contracts.d.ts

@@ -1,7 +1,8 @@
+import type { ExtensionCommandCapabilityFamily } from "../core/extensions/command-metadata-contract.js";
 /** Visibility tiers shared by CLI help, completions, docs, extensions, and MCP. */
 export type PmCommandVisibilityTier = "core" | "standard" | "full" | "internal";
 /** Stable capability families shared by every agent-facing command surface. */
-export type PmCommandCapabilityFamily = "workspace" | "intake" | "context" | "lifecycle" | "evidence" | "graph" | "quality" | "automation" | "extensions" | "internal";
+export type PmCommandCapabilityFamily = ExtensionCommandCapabilityFamily;
 /** One command's canonical agent-surface visibility declaration. */
 export interface PmCommandVisibilityContract {
     /** Canonical command path. */
@@ -14,6 +15,13 @@ export interface PmCommandCapabilityContract extends PmCommandVisibilityContract
     /** Exactly one stable capability family used to group the command. */
     family: PmCommandCapabilityFamily;
 }
+/** One generated family route shared by guides, skills, and documentation. */
+export interface PmCommandCapabilityGroup {
+    /** Stable capability family. */
+    family: PmCommandCapabilityFamily;
+    /** Non-internal commands owned by the family. */
+    commands: readonly string[];
+}
 /** Resolve one command's stable capability family. */
 export declare function resolvePmCommandCapabilityFamily(command: string): PmCommandCapabilityFamily;
 /**
@@ -26,18 +34,39 @@ export declare function resolvePmCommandCapabilityFamily(command: string): PmCom
 export declare const PM_COMMAND_CAPABILITY_CONTRACTS: readonly PmCommandCapabilityContract[];
 /** Backward-compatible tier-only projection of the capability contract. */
 export declare const PM_COMMAND_VISIBILITY_CONTRACTS: readonly PmCommandVisibilityContract[];
+/** Bounded compact-help contract: one conventional terminal screen. */
+export declare const PM_CORE_HELP_BUDGET: Readonly<{
+    max_lines: 50;
+    max_utf8_bytes: 6000;
+}>;
+/** Root options retained in the compact progressive-disclosure help screen. */
+export declare const PM_CORE_HELP_OPTION_FLAGS: readonly string[];
+/** Measure rendered core help against its line and byte ceilings. */
+export declare function measurePmCoreHelp(text: string): {
+    lines: number;
+    utf8_bytes: number;
+    within_budget: boolean;
+};
 /** Resolve one command's declared tier; extension commands default to standard. */
 export declare function resolvePmCommandVisibilityTier(command: string, extensionTier?: PmCommandVisibilityTier): PmCommandVisibilityTier;
 /** Return commands visible at a requested tier, preserving contract order. */
 export declare function listPmCommandsForTier(tier: Exclude<PmCommandVisibilityTier, "internal">): string[];
+/** Project an explicit command registry into one visibility tier. */
+export declare function listPmCommandsForTierFromContracts(tier: Exclude<PmCommandVisibilityTier, "internal">, contracts: readonly PmCommandCapabilityContract[]): string[];
 /** Return commands in one capability family, preserving contract order. */
 export declare function listPmCommandsForFamily(family: PmCommandCapabilityFamily): string[];
+/** Project an explicit command registry into one capability family. */
+export declare function listPmCommandsForFamilyFromContracts(family: PmCommandCapabilityFamily, contracts: readonly PmCommandCapabilityContract[]): string[];
+/** Group the command registry for progressive-disclosure routing surfaces. */
+export declare function listPmCommandCapabilityGroups(contracts?: readonly PmCommandCapabilityContract[]): PmCommandCapabilityGroup[];
 /** MCP profile names accepted by the server and embedding hosts. */
 export type PmMcpToolProfile = "core" | "standard" | "full" | "custom";
 /** Mapping from one narrow MCP tool to the command contract that tiers it. */
 export declare const PM_MCP_TOOL_COMMAND_CONTRACTS: Readonly<Record<string, string>>;
 /** Resolve the tools visible in a named MCP profile from command tiers. */
 export declare function listPmMcpToolsForProfile(availableTools: readonly string[], profile: Exclude<PmMcpToolProfile, "custom">): string[];
+/** Project an explicit command registry into one MCP tool profile. */
+export declare function listPmMcpToolsForProfileFromContracts(availableTools: readonly string[], profile: Exclude<PmMcpToolProfile, "custom">, contracts: readonly PmCommandCapabilityContract[]): string[];
 /** Stable MCP resource contract generated from the same agent surface table. */
 export interface PmMcpResourceContract {
     /** Stable resource URI. */
@@ -75,3 +104,7 @@ export interface PmMcpPromptContract {
 export declare const PM_MCP_PROMPT_CONTRACTS: readonly PmMcpPromptContract[];
 /** Render the generated command visibility reference used by docs drift gates. */
 export declare function renderPmCommandVisibilityMarkdown(): string;
+/** Render an explicit registry for mutation-sensitivity and host tooling. */
+export declare function renderPmCommandVisibilityMarkdownFromContracts(contracts: readonly PmCommandCapabilityContract[]): string;
+/** Render family routing for generated docs and skill progressive disclosure. */
+export declare function renderPmCapabilityRoutingMarkdown(contracts?: readonly PmCommandCapabilityContract[]): string;

package/dist/sdk/agent-capability-contracts.js

@@ -5,7 +5,7 @@
  * surfaces from one public SDK contract.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="5e77c121-35a2-57d1-9a3e-f33447535c03")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="51e187c6-d48f-59e8-ad23-c72670ade3cc")}catch(e){}}();
 import { PM_CORE_COMMAND_NAMES } from "./cli-contracts/enum-contracts.js";
 const CORE_COMMANDS = new Set([
     "claim",
@@ -14,6 +14,7 @@ const CORE_COMMANDS = new Set([
     "create",
     "get",
     "help",
+    "init",
     "list",
     "next",
     "plan",
@@ -167,6 +168,36 @@ export const PM_COMMAND_CAPABILITY_CONTRACTS = Object.freeze([
 ]);
 /** Backward-compatible tier-only projection of the capability contract. */
 export const PM_COMMAND_VISIBILITY_CONTRACTS = PM_COMMAND_CAPABILITY_CONTRACTS;
+/** Bounded compact-help contract: one conventional terminal screen. */
+export const PM_CORE_HELP_BUDGET = Object.freeze({
+    max_lines: 50,
+    max_utf8_bytes: 6000,
+});
+/** Root options retained in the compact progressive-disclosure help screen. */
+export const PM_CORE_HELP_OPTION_FLAGS = Object.freeze([
+    "-V, --version",
+    "--json",
+    "--output-include <fields>",
+    "--output-limit <count>",
+    "--output-budget <tokens|unbounded>",
+    "--output-cursor <cursor>",
+    "--pm-path <dir>",
+    "--no-extensions",
+    "--no-pager",
+    "--explain",
+    "-h, --help",
+]);
+/** Measure rendered core help against its line and byte ceilings. */
+export function measurePmCoreHelp(text) {
+    const lines = text === "" ? 0 : text.split(/\r?\n/).length;
+    const utf8Bytes = Buffer.byteLength(text, "utf8");
+    return {
+        lines,
+        utf8_bytes: utf8Bytes,
+        within_budget: lines <= PM_CORE_HELP_BUDGET.max_lines &&
+            utf8Bytes <= PM_CORE_HELP_BUDGET.max_utf8_bytes,
+    };
+}
 const TIER_ORDER = {
     core: 0,
     standard: 1,
@@ -180,12 +211,55 @@ export function resolvePmCommandVisibilityTier(command, extensionTier = "standar
 }
 /** Return commands visible at a requested tier, preserving contract order. */
 export function listPmCommandsForTier(tier) {
+    return listPmCommandsForTierFromContracts(tier, PM_COMMAND_CAPABILITY_CONTRACTS);
+}
+/** Project an explicit command registry into one visibility tier. */
+export function listPmCommandsForTierFromContracts(tier, contracts) {
     const maximum = TIER_ORDER[tier];
-    return PM_COMMAND_VISIBILITY_CONTRACTS.filter((entry) => entry.tier !== "internal" && TIER_ORDER[entry.tier] <= maximum).map((entry) => entry.command);
+    return contracts
+        .filter((entry) => entry.tier !== "internal" && TIER_ORDER[entry.tier] <= maximum)
+        .map((entry) => entry.command);
 }
 /** Return commands in one capability family, preserving contract order. */
 export function listPmCommandsForFamily(family) {
-    return PM_COMMAND_CAPABILITY_CONTRACTS.filter((entry) => entry.family === family).map((entry) => entry.command);
+    return listPmCommandsForFamilyFromContracts(family, PM_COMMAND_CAPABILITY_CONTRACTS);
+}
+/** Project an explicit command registry into one capability family. */
+export function listPmCommandsForFamilyFromContracts(family, contracts) {
+    return contracts
+        .filter((entry) => entry.family === family)
+        .map((entry) => entry.command);
+}
+const CAPABILITY_FAMILY_ORDER = [
+    "workspace",
+    "intake",
+    "context",
+    "lifecycle",
+    "evidence",
+    "graph",
+    "quality",
+    "automation",
+    "extensions",
+    "internal",
+];
+const CAPABILITY_ROUTING_EXCLUDED_ALIASES = new Set([
+    "ctx",
+    "item-reopen",
+    "list-all",
+    "list-blocked",
+    "list-canceled",
+    "list-closed",
+    "list-draft",
+    "list-in-progress",
+    "list-open",
+]);
+/** Group the command registry for progressive-disclosure routing surfaces. */
+export function listPmCommandCapabilityGroups(contracts = PM_COMMAND_CAPABILITY_CONTRACTS) {
+    return CAPABILITY_FAMILY_ORDER.map((family) => ({
+        family,
+        commands: listPmCommandsForFamilyFromContracts(family, contracts).filter((command) => contracts.find((entry) => entry.command === command)?.tier !==
+            "internal" && !CAPABILITY_ROUTING_EXCLUDED_ALIASES.has(command)),
+    })).filter(({ commands }) => commands.length > 0);
 }
 /** Mapping from one narrow MCP tool to the command contract that tiers it. */
 export const PM_MCP_TOOL_COMMAND_CONTRACTS = Object.freeze({
@@ -223,9 +297,13 @@ export const PM_MCP_TOOL_COMMAND_CONTRACTS = Object.freeze({
 });
 /** Resolve the tools visible in a named MCP profile from command tiers. */
 export function listPmMcpToolsForProfile(availableTools, profile) {
+    return listPmMcpToolsForProfileFromContracts(availableTools, profile, PM_COMMAND_CAPABILITY_CONTRACTS);
+}
+/** Project an explicit command registry into one MCP tool profile. */
+export function listPmMcpToolsForProfileFromContracts(availableTools, profile, contracts) {
     if (profile === "full")
         return [...availableTools];
-    const visibleCommands = new Set(listPmCommandsForTier(profile));
+    const visibleCommands = new Set(listPmCommandsForTierFromContracts(profile, contracts));
     return availableTools.filter((tool) => {
         const command = PM_MCP_TOOL_COMMAND_CONTRACTS[tool];
         return command !== undefined && visibleCommands.has(command);
@@ -309,7 +387,11 @@ export const PM_MCP_PROMPT_CONTRACTS = Object.freeze([
 ]);
 /** Render the generated command visibility reference used by docs drift gates. */
 export function renderPmCommandVisibilityMarkdown() {
-    const rows = PM_COMMAND_CAPABILITY_CONTRACTS.map(({ command, tier, family }) => `| \`${command}\` | ${tier} | ${family} |`);
+    return renderPmCommandVisibilityMarkdownFromContracts(PM_COMMAND_CAPABILITY_CONTRACTS);
+}
+/** Render an explicit registry for mutation-sensitivity and host tooling. */
+export function renderPmCommandVisibilityMarkdownFromContracts(contracts) {
+    const rows = contracts.map(({ command, tier, family }) => `| \`${command}\` | ${tier} | ${family} |`);
     return [
         "# Generated agent command surface",
         "",
@@ -321,5 +403,21 @@ export function renderPmCommandVisibilityMarkdown() {
         "",
     ].join("\n");
 }
+/** Render family routing for generated docs and skill progressive disclosure. */
+export function renderPmCapabilityRoutingMarkdown(contracts = PM_COMMAND_CAPABILITY_CONTRACTS) {
+    const rows = listPmCommandCapabilityGroups(contracts).map(({ family, commands }) => `| ${family} | ${commands.map((command) => `\`${command}\``).join(", ")} |`);
+    return [
+        "# Generated agent capability routing",
+        "",
+        "Tracker: `pm-kxci8x`.",
+        "",
+        "This file is generated from `PM_COMMAND_CAPABILITY_CONTRACTS`. Do not edit it manually.",
+        "",
+        "| Capability family | Commands |",
+        "| --- | --- |",
+        ...rows,
+        "",
+    ].join("\n");
+}
 //# sourceMappingURL=agent-capability-contracts.js.map
-//# debugId=5e77c121-35a2-57d1-9a3e-f33447535c03
+//# debugId=51e187c6-d48f-59e8-ad23-c72670ade3cc

package/dist/sdk/annotations.d.ts

@@ -146,6 +146,8 @@ export declare function parseAnnotationTextInput(raw: string, options?: {
 export declare function isErrnoError(error: unknown): error is {
     code?: unknown;
 };
+/** Refuse presentation-level stdin directives when JSON-RPC owns the process stream. */
+export declare function assertAnnotationStdinTransportAvailable(options: AnnotationSourceOptions, optionName: string): void;
 /** Resolves mutually exclusive annotation input flags into one normalized SDK operation. */
 export declare function resolveAnnotationInput(options: AnnotationSourceOptions, noun: string): Promise<AnnotationInput>;
 /** Implements wrap ownership conflict for the public runtime surface of this module. */

package/dist/sdk/annotations.js

@@ -4,13 +4,13 @@
  * Implements the pm annotation command command surface and its agent-facing runtime behavior.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="eac75dc5-80b4-50d2-b615-4f96edca7346")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="39acab93-f9ad-5b95-871e-625d912f1322")}catch(e){}}();
 import { assertInitializedTracker } from "./environment/tracker-preflight.js";
 import { readFile } from "node:fs/promises";
 import { isFileAbsentError } from "../core/fs/fs-utils.js";
 import { getActiveExtensionRegistrations } from "../core/extensions/index.js";
 import { resolveItemTypeRegistry } from "../core/item/type-registry.js";
-import { createStdinTokenResolver, parseCsvKv } from "../core/item/parse.js";
+import { createStdinTokenResolver, parseCsvKv, shouldResolveMutationStdinTokens, transferMutationStdinTokenPolicy, } from "../core/item/parse.js";
 import { EXIT_CODE } from "../core/shared/constants.js";
 import { PmCliError } from "../core/shared/errors.js";
 import { parseLimit } from "../core/shared/numeric-parsers.js";
@@ -26,7 +26,7 @@ export function normalizeAnnotationTransportOptions(options) {
         ...(options.full === true ? { fullHistory: true } : {}),
     };
     delete normalized.full;
-    return normalized;
+    return transferMutationStdinTokenPolicy(options, normalized);
 }
 /** Reject mutation of canonical structured events while allowing ordinary annotations. */
 function assertAnnotationEntryMutable(entry, operation) {
@@ -84,6 +84,15 @@ export function parseAnnotationTextInput(raw, options = {}) {
 export function isErrnoError(error) {
     return typeof error === "object" && error !== null && "code" in error;
 }
+/** Refuse presentation-level stdin directives when JSON-RPC owns the process stream. */
+export function assertAnnotationStdinTransportAvailable(options, optionName) {
+    if (shouldResolveMutationStdinTokens(options))
+        return;
+    throw new PmCliError(`${optionName} cannot read process stdin through the MCP JSON-RPC transport. Pass annotation text in options.add instead.`, EXIT_CODE.USAGE, {
+        code: "mcp_stdin_unavailable",
+        required: "Pass annotation text as JSON data; the MCP protocol already owns process stdin.",
+    });
+}
 async function resolveAnnotationTextSource(options, noun) {
     const sourceCount = Number(options.add !== undefined) +
         Number(options.stdin === true) +
@@ -92,14 +101,16 @@ async function resolveAnnotationTextSource(options, noun) {
         throw new PmCliError(`Specify ${noun} text using only one input source: --add, --stdin, or --file`, EXIT_CODE.USAGE);
     }
     const stdinResolver = createStdinTokenResolver();
+    const resolveStdinTokens = shouldResolveMutationStdinTokens(options);
     if (options.add !== undefined) {
         return {
-            value: (await stdinResolver.resolveValue(options.add, "--add")) ?? "",
+            value: (await stdinResolver.resolveValue(options.add, "--add", resolveStdinTokens)) ?? "",
             rawValue: options.add,
             emptyFlag: "--add",
         };
     }
     if (options.stdin === true) {
+        assertAnnotationStdinTransportAvailable(options, "--stdin");
         return {
             value: (await stdinResolver.resolveValue("-", "--stdin")) ?? "",
             emptyFlag: "--stdin",
@@ -111,15 +122,22 @@ async function resolveAnnotationTextSource(options, noun) {
     if (!filePath) {
         throw new PmCliError("--file path cannot be empty", EXIT_CODE.USAGE);
     }
+    if (filePath === "-") {
+        assertAnnotationStdinTransportAvailable(options, "--file -");
+        return {
+            value: (await stdinResolver.resolveValue("-", "--file")) ?? "",
+            emptyFlag: "--file",
+        };
+    }
     try {
         return { value: await readFile(filePath, "utf8"), emptyFlag: "--file" };
     }
     catch (error) {
         if (isErrnoError(error) && isFileAbsentError(error)) {
-            throw new PmCliError(`--file path not found: ${filePath}`, EXIT_CODE.USAGE);
+            throw new PmCliError(`--file path not found: ${filePath}. Use --file - to read stdin.`, EXIT_CODE.USAGE);
         }
         const detail = error instanceof Error ? error.message : String(error);
-        throw new PmCliError(`Failed to read --file path "${filePath}": ${detail}`, EXIT_CODE.USAGE);
+        throw new PmCliError(`Failed to read --file path "${filePath}": ${detail}. Use --file - to read stdin.`, EXIT_CODE.USAGE);
     }
 }
 /** Resolves mutually exclusive annotation input flags into one normalized SDK operation. */
@@ -398,4 +416,4 @@ function renderAnnotationResult(id, collectionKey, allEntries, limit, includeMet
     };
 }
 //# sourceMappingURL=annotations.js.map
-//# debugId=eac75dc5-80b4-50d2-b615-4f96edca7346
+//# debugId=39acab93-f9ad-5b95-871e-625d912f1322

package/dist/sdk/cli-contracts/tool-parameter-tables.js

@@ -4,7 +4,7 @@
  * Defines SDK command-contract metadata for Tool Parameter Tables.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="fc485dff-5576-536e-86b2-8cc167d4513c")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="2d43e788-cb8d-59b8-a447-4d24033bb55b")}catch(e){}}();
 import { PLAN_HARNESS_VALUES, PLAN_MODE_VALUES, PLAN_STEP_LINK_KIND_VALUES, PLAN_STEP_STATUS_VALUES, } from "../../types/index.js";
 import { PM_READ_OUTPUT_SESSION_MAX_SEEN_ITEM_IDS } from "../read-output-session.js";
 import { ASSURANCE_DEFINITION_SCHEMA } from "./schemas/assurance-definition.js";
@@ -687,6 +687,42 @@ export const PM_TOOL_ACTION_SCOPED_PARAMETER_PROPERTIES = {
             anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
         },
     },
+    "update-many": {
+        ids: {
+            anyOf: [
+                { type: "string" },
+                { type: "number" },
+                {
+                    type: "array",
+                    items: { anyOf: [{ type: "string" }, { type: "number" }] },
+                },
+            ],
+        },
+    },
+    "close-many": {
+        ids: {
+            anyOf: [
+                { type: "string" },
+                { type: "number" },
+                {
+                    type: "array",
+                    items: { anyOf: [{ type: "string" }, { type: "number" }] },
+                },
+            ],
+        },
+    },
+    "history-compact": {
+        ids: {
+            anyOf: [
+                { type: "string" },
+                { type: "number" },
+                {
+                    type: "array",
+                    items: { anyOf: [{ type: "string" }, { type: "number" }] },
+                },
+            ],
+        },
+    },
     events: {
         since: { type: "string", minLength: 1 },
         type: {
@@ -2092,4 +2128,4 @@ export const PM_TOOL_ACTION_SCOPED_PARAMETER_METADATA = {
     },
 };
 //# sourceMappingURL=tool-parameter-tables.js.map
-//# debugId=fc485dff-5576-536e-86b2-8cc167d4513c
+//# debugId=2d43e788-cb8d-59b8-a447-4d24033bb55b

package/dist/sdk/cli-contracts/typed-action-inputs.d.ts

@@ -52,7 +52,10 @@ export type PmCloseActionOptions = DeclaredProperties<CloseCommandOptions> & {
     text?: string;
 };
 /** Typed bulk-mutation selection filters shared by the `update-many` and `close-many` actions, derived from the bulk-mutation filter contract table. */
-export type PmBulkMutationFilterOptions = OptionsFromContracts<typeof TOOL_BULK_MUTATION_FILTER_OPTION_CONTRACT_SOURCE>;
+export type PmBulkMutationFilterOptions = Omit<OptionsFromContracts<typeof TOOL_BULK_MUTATION_FILTER_OPTION_CONTRACT_SOURCE>, "ids"> & {
+    /** Explicit item allowlist supplied as CSV text, a finite numeric scalar, or transport-native string/number IDs. */
+    ids?: string | number | readonly (string | number)[];
+};
 /** Checkpoint/preview controls shared by the bulk mutation actions. Declared as an object type literal (not an interface) so the composed option bags keep their implicit index signature and stay assignable to the wide `Record`-based dispatch layer. */
 export type PmBulkMutationControlOptions = {
     /** Preview the bulk mutation without writing changes. */

package/dist/sdk/cli-contracts/typed-action-inputs.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="67e8cc8b-2908-5165-9f06-6e5d70f858b2")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="52969f17-1b8d-535e-93b6-b99d4e5b9917")}catch(e){}}();
 export {};
 //# sourceMappingURL=typed-action-inputs.js.map
-//# debugId=67e8cc8b-2908-5165-9f06-6e5d70f858b2
+//# debugId=52969f17-1b8d-535e-93b6-b99d4e5b9917