@unbrained/pm-cli 2026.8.8 → 2026.8.10

package/dist/core/shared/author.js

@@ -4,7 +4,7 @@
  * Provides shared primitives and utilities for Author.
  */
 
-!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]="0139d8ef-d286-571f-89f8-7de2f8422f22")}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]="6c075a14-1a65-59c7-a9c6-af348e30f821")}catch(e){}}();
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
@@ -31,13 +31,12 @@ export const BUILTIN_HARNESS_SIGNAL_DESCRIPTORS = [
         session_environment_keys: ["CLAUDE_CODE_SESSION_ID"],
         provenance_environment_keys: {
             effort: ["CLAUDE_EFFORT"],
-            role: ["CLAUDE_CODE_CHILD_SESSION"],
         },
         provenance_resolvers: {
             model: "claude_session_file",
             version: "claude_session_file",
         },
-        provenance_unavailable_dimensions: ["topic"],
+        provenance_unavailable_dimensions: ["role", "topic"],
         argv_markers: ["claude", "claude-code"],
         client_names: ["claude", "claude-code", "claude code"],
     },
@@ -192,6 +191,28 @@ function firstEnvironmentValue(env, keys) {
     return undefined;
 }
 function provenanceFromArgv(argv, dimension) {
+    const flaggedValue = provenanceFlagValue(argv, dimension);
+    if (flaggedValue !== undefined)
+        return flaggedValue;
+    if (dimension === "topic") {
+        return argv
+            .slice(0, 16)
+            .map((token) => token.trim())
+            .find((token) => /^pm-[a-z0-9][a-z0-9-]{2,63}$/u.test(token));
+    }
+    if (dimension === "role") {
+        const command = argv
+            .slice(0, 8)
+            .map((token) => token.trim().toLowerCase())
+            .find((token) => ["claim", "create", "update", "close", "release", "review"].includes(token));
+        if (command === "review")
+            return "reviewer";
+        if (command)
+            return "implementer";
+    }
+    return undefined;
+}
+function provenanceFlagValue(argv, dimension) {
     const acceptedFlags = dimension === "model"
         ? ["--model", "--agent-model"]
         : [`--agent-${dimension}`];
@@ -208,6 +229,24 @@ function provenanceFromArgv(argv, dimension) {
     }
     return undefined;
 }
+const AGENT_ROLE_VALUES = new Set([
+    "implementation",
+    "implementer",
+    "investigator",
+    "orchestrator",
+    "planner",
+    "release-operator",
+    "reviewer",
+]);
+function normalizeProvenanceValue(dimension, value) {
+    if (dimension !== "role" || value === undefined)
+        return value;
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replaceAll(/[_\s]+/gu, "-");
+    return AGENT_ROLE_VALUES.has(normalized) ? normalized : undefined;
+}
 function boundedProvenanceValue(provenance, dimension) {
     return nonBlank(provenance?.[dimension])?.slice(0, 256);
 }
@@ -274,13 +313,23 @@ function resolveProvenanceProbe(dimension, signals, env, descriptor) {
     }
     if (resolver === "ai_agent_version") {
         const value = nonBlank(env.AI_AGENT);
-        if (!value)
+        if (!value ||
+            !descriptor ||
+            !literalSignalMatches(value, descriptor.harness)) {
             return undefined;
+        }
         const match = /(?:^|[@/\s])v?(\d+\.\d+(?:\.\d+)?(?:[-+][A-Za-z0-9.-]+)?)$/u.exec(value);
         return match?.[1]?.slice(0, 256);
     }
     return undefined;
 }
+function provenanceResolverHasInput(resolver, descriptor, env) {
+    if (resolver === "ai_agent_version") {
+        const value = nonBlank(env.AI_AGENT);
+        return (value !== undefined && literalSignalMatches(value, descriptor.harness));
+    }
+    return nonBlank(env.CLAUDE_CODE_SESSION_ID) !== undefined;
+}
 function effectiveHarnessDetectionSignals(signals) {
     if (signals)
         return signals;
@@ -307,7 +356,7 @@ function resolveAgentProvenanceObservation(dimension, signals, env, descriptor,
     let overrideValue;
     let argvValue;
     if (hostResolvedDimensions.has(dimension)) {
-        overrideValue = nonBlank(env[overrideKey])?.slice(0, 256);
+        overrideValue = normalizeProvenanceValue(dimension, nonBlank(env[overrideKey])?.slice(0, 256));
         argvValue = provenanceFromArgv(signals.argv ?? [], dimension);
     }
     const environmentKeysByDimension = {
@@ -321,10 +370,10 @@ function resolveAgentProvenanceObservation(dimension, signals, env, descriptor,
     const values = [
         overrideValue,
         boundedProvenanceValue(sessionContext?.provenance, dimension),
-        firstEnvironmentValue(env, environmentKeysByDimension[dimension]),
-        boundedProvenanceValue(clientProvenance, dimension),
-        boundedProvenanceValue(signals.provenance, dimension),
-        argvValue,
+        normalizeProvenanceValue(dimension, firstEnvironmentValue(env, environmentKeysByDimension[dimension])),
+        normalizeProvenanceValue(dimension, boundedProvenanceValue(clientProvenance, dimension)),
+        normalizeProvenanceValue(dimension, boundedProvenanceValue(signals.provenance, dimension)),
+        normalizeProvenanceValue(dimension, argvValue),
         resolveProvenanceProbe(dimension, signals, env, descriptor),
     ];
     const sources = [
@@ -469,6 +518,75 @@ export function detectAgentIdentity(signals) {
     ];
     return Object.fromEntries(entries.filter((entry) => entry[1] !== undefined));
 }
+function resolveProvenanceOutcome(dimension, identity, descriptor, env, probesEnabled, invalidValue) {
+    const resolver = descriptor?.provenance_resolvers[dimension];
+    if (identity.provenance?.[dimension]) {
+        return {
+            status: "resolved",
+            ...(resolver ? { resolver } : {}),
+            rule_version: "v1",
+        };
+    }
+    if (invalidValue) {
+        return {
+            status: "unavailable",
+            reason: "invalid_value",
+            rule_version: "v1",
+        };
+    }
+    if (resolver) {
+        const resolverHasInput = provenanceResolverHasInput(resolver, descriptor, env);
+        const status = resolverHasInput && probesEnabled ? "failed" : "unavailable";
+        const reason = !resolverHasInput
+            ? "harness_unavailable"
+            : probesEnabled
+                ? "resolver_failed"
+                : "probes_disabled";
+        return { status, reason, resolver, rule_version: "v1" };
+    }
+    return {
+        status: descriptor?.provenance_unavailable_dimensions.includes(dimension)
+            ? "unavailable"
+            : "not_configured",
+        reason: descriptor?.provenance_unavailable_dimensions.includes(dimension)
+            ? "harness_unavailable"
+            : "resolver_not_configured",
+        rule_version: "v1",
+    };
+}
+/**
+ * Diagnose provenance without exposing environment values, paths, or probe data.
+ *
+ * This additive SDK contract keeps legacy `detectAgentIdentity` projections
+ * stable while giving health checks and history writers explicit absence states.
+ */
+export function diagnoseAgentIdentity(signals) {
+    const effectiveSignals = effectiveHarnessDetectionSignals(signals);
+    const identity = detectAgentIdentity(effectiveSignals);
+    const descriptor = currentHarnessSignalDescriptors(effectiveSignals.descriptors).find((candidate) => candidate.harness === identity.harness);
+    const env = effectiveSignals.env ?? {};
+    const probesEnabled = effectiveSignals.probes_enabled !== false &&
+        workspaceHarnessSignalsStorage.getStore()?.probesEnabled !== false &&
+        !["0", "false", "off"].includes(nonBlank(env.PM_AGENT_PROBES)?.toLowerCase() ?? "");
+    const sessionContext = resolveAgentSessionContextFromSignals(effectiveSignals, env);
+    const invalidRoleValue = [
+        env.PM_AGENT_ROLE,
+        sessionContext.provenance?.role,
+        firstEnvironmentValue(env, descriptor?.provenance_environment_keys.role),
+        effectiveSignals.client_info?.provenance?.role,
+        effectiveSignals.provenance?.role,
+        provenanceFlagValue(effectiveSignals.argv ?? [], "role"),
+    ].some((candidate) => {
+        const value = nonBlank(candidate)?.slice(0, 256);
+        return (value !== undefined &&
+            normalizeProvenanceValue("role", value) === undefined);
+    });
+    const outcomes = Object.fromEntries(AGENT_PROVENANCE_DIMENSIONS.map((dimension) => [
+        dimension,
+        resolveProvenanceOutcome(dimension, identity, descriptor, env, probesEnabled, dimension === "role" && invalidRoleValue),
+    ]));
+    return { ...identity, provenance_outcomes: outcomes };
+}
 /** Reads the invocation-wide author override through the canonical environment seam. */
 export function readAuthorEnvironment() {
     return process.env.PM_AUTHOR;
@@ -575,4 +693,4 @@ export function resolveAuthor(candidate, fallback) {
     return identity.author;
 }
 //# sourceMappingURL=author.js.map
-//# debugId=0139d8ef-d286-571f-89f8-7de2f8422f22
+//# debugId=6c075a14-1a65-59c7-a9c6-af348e30f821

package/dist/core/shared/errors.d.ts

@@ -60,6 +60,10 @@ export interface PmCliErrorContext {
     examples?: string[];
     /** Value that configures or reports next steps for this contract. */
     nextSteps?: string[];
+    /** Exact selectors that could not be matched by a lossless removal. */
+    unmatched?: string[];
+    /** Local dependency targets that could not be resolved before mutation. */
+    unresolved_targets?: string[];
     /** Available history bounds for a failed point-in-time read or restore target. */
     valid_range?: {
         /** Earliest available one-based version, or null for an empty stream. */

package/dist/core/shared/errors.js

@@ -1,6 +1,6 @@
 /** Implements the exported pm cli error runtime abstraction for core/shared/errors.ts. */
 
-!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]="c2c9251e-86bf-5a92-acdb-581e59d269d8")}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]="31191ce6-fb17-5b76-aa3d-3c3773cd85e0")}catch(e){}}();
 export class PmCliError extends Error {
     /** Value that configures or reports exit code for this contract. */
     exitCode;
@@ -18,4 +18,4 @@ export class PmCliError extends Error {
     }
 }
 //# sourceMappingURL=errors.js.map
-//# debugId=c2c9251e-86bf-5a92-acdb-581e59d269d8
+//# debugId=31191ce6-fb17-5b76-aa3d-3c3773cd85e0

package/dist/core/shared/text-normalization.d.ts

@@ -8,4 +8,4 @@ export declare function normalizeLowercaseWhitespace(value: string): string;
 /** Implements tokenize alpha numeric for the public runtime surface of this module. */
 export declare function tokenizeAlphaNumeric(value: string): string[];
 /** Implements jaccard similarity for the public runtime surface of this module. */
-export declare function jaccardSimilarity(leftTokens: string[], rightTokens: string[]): number;
+export declare function jaccardSimilarity(leftTokens: readonly string[], rightTokens: readonly string[]): number;

package/dist/core/shared/text-normalization.js

@@ -5,7 +5,7 @@
  */
 /** Normalizes text to lowercase whitespace-collapsed form for stable matching and comparison. */
 
-!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]="7288620a-5aa7-50f9-a271-45b2722a4887")}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]="3ad30a32-0f83-5473-b0a3-349e271d8378")}catch(e){}}();
 export function normalizeLowercaseWhitespace(value) {
     return value.trim().toLowerCase().replace(/\s+/g, " ");
 }
@@ -36,4 +36,4 @@ export function jaccardSimilarity(leftTokens, rightTokens) {
     return intersection / union;
 }
 //# sourceMappingURL=text-normalization.js.map
-//# debugId=7288620a-5aa7-50f9-a271-45b2722a4887
+//# debugId=3ad30a32-0f83-5473-b0a3-349e271d8378

package/dist/sdk/actionability.d.ts

@@ -7,4 +7,4 @@
  * blocker or ready-work classifications without storage or rendering side
  * effects.
  */
-export { collectBlockedByIds, collectDependencyBlockedIds, computeActionabilityReport, resolveItemBlockers, type ActionabilityReport, type ActionableEntry, type ResolvedBlocker, } from "../core/item/actionability.js";
+export { ACTIONABILITY_ORDERING_KINDS, collectBlockedByIds, collectBlockedByIdsFromCorpus, collectDependencyBlockedIds, computeActionabilityReport, indexBlockedByIds, resolveItemBlockers, type ActionabilityReport, type ActionableEntry, type ResolvedBlocker, } from "../core/item/actionability.js";

package/dist/sdk/actionability.js

@@ -8,7 +8,7 @@
  * effects.
  */
 
-!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]="9184e723-8269-5e45-8c6a-52fd02da60e6")}catch(e){}}();
-export { collectBlockedByIds, collectDependencyBlockedIds, computeActionabilityReport, resolveItemBlockers, } from "../core/item/actionability.js";
+!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]="cc271a73-9767-54bb-a142-d4d4569e3c6a")}catch(e){}}();
+export { ACTIONABILITY_ORDERING_KINDS, collectBlockedByIds, collectBlockedByIdsFromCorpus, collectDependencyBlockedIds, computeActionabilityReport, indexBlockedByIds, resolveItemBlockers, } from "../core/item/actionability.js";
 //# sourceMappingURL=actionability.js.map
-//# debugId=9184e723-8269-5e45-8c6a-52fd02da60e6
+//# debugId=cc271a73-9767-54bb-a142-d4d4569e3c6a

package/dist/sdk/agent/command-recovery.d.ts

@@ -0,0 +1,4 @@
+/** Resolve the truthful placeholder for a missing flag from its contract. */
+export declare function resolveMissingOptionPlaceholder(commandName: string, missingLabel: string): string | null | undefined;
+/** Preserve an attempted argv vector and insert each missing option before `--`. */
+export declare function renderMissingOptionRetry(invocationArgv: string[], commandName: string, missingLabels: string[]): string | undefined;

package/dist/sdk/agent/command-recovery.js

@@ -0,0 +1,52 @@
+/**
+ * @module sdk/command-recovery
+ *
+ * Builds executable recovery commands from tokenized argv and declared CLI
+ * flag domains. Display labels are normalized back to real flag tokens and
+ * supplied arguments are preserved byte-for-token.
+ */
+
+!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]="ab87f46c-c9b4-51d1-a712-fbce7c79fca9")}catch(e){}}();
+import { renderPmCommand } from "../command-line.js";
+import { resolveSubcommandFlagContractsForCommand } from "../cli-contracts.js";
+function normalizeMissingFlag(label) {
+    const match = label.trim().match(/--[a-z0-9][a-z0-9_-]*/i);
+    return match?.[0]?.replaceAll("_", "-").toLowerCase();
+}
+/** Resolve the truthful placeholder for a missing flag from its contract. */
+export function resolveMissingOptionPlaceholder(commandName, missingLabel) {
+    const flag = normalizeMissingFlag(missingLabel);
+    if (!flag)
+        return undefined;
+    const contract = resolveSubcommandFlagContractsForCommand(commandName).find((entry) => entry.flag === flag || entry.aliases?.includes(flag));
+    if (!contract)
+        return "<value>";
+    if (contract.value_type === "boolean") {
+        return null;
+    }
+    return `<${contract.value_name ?? "value"}>`;
+}
+/** Preserve an attempted argv vector and insert each missing option before `--`. */
+export function renderMissingOptionRetry(invocationArgv, commandName, missingLabels) {
+    const retry = [...invocationArgv];
+    const terminatorIndex = retry.indexOf("--");
+    let insertionIndex = terminatorIndex < 0 ? retry.length : terminatorIndex;
+    for (const label of missingLabels) {
+        const flag = normalizeMissingFlag(label);
+        if (!flag ||
+            retry
+                .slice(0, insertionIndex)
+                .some((token) => token === flag || token.startsWith(`${flag}=`))) {
+            continue;
+        }
+        const placeholder = resolveMissingOptionPlaceholder(commandName, flag);
+        const recoveredOption = placeholder ? [flag, placeholder] : [flag];
+        retry.splice(insertionIndex, 0, ...recoveredOption);
+        insertionIndex += recoveredOption.length;
+    }
+    return retry.length === invocationArgv.length
+        ? undefined
+        : renderPmCommand(retry);
+}
+//# sourceMappingURL=command-recovery.js.map
+//# debugId=ab87f46c-c9b4-51d1-a712-fbce7c79fca9

package/dist/sdk/agent/command-suggestions.d.ts

@@ -0,0 +1,4 @@
+/** Score one command path for a guessed command token; lower is better. */
+export declare function scoreCommandPathMatch(commandPath: string, queryToken: string): number;
+/** Rank available command paths for one guessed token. */
+export declare function rankCommandPaths(commandPaths: string[], queryToken: string): string[];

package/dist/sdk/agent/command-suggestions.js

@@ -0,0 +1,67 @@
+/**
+ * @module sdk/command-suggestions
+ *
+ * Provides deterministic, agent-oriented command suggestion ranking. Semantic
+ * verb aliases rank first, bounded edit distance second, and substring matches
+ * last so `log` never prefers `catalog` over item history commands.
+ */
+
+!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]="71e5a870-f62f-5252-b4e9-e1a42e36009f")}catch(e){}}();
+import { levenshteinDistanceWithinLimit } from "../../core/shared/levenshtein.js";
+const COMMAND_SYNONYMS = {
+    add: ["create", "append"],
+    fetch: ["get"],
+    inspect: ["get", "health"],
+    log: ["history", "comments", "notes"],
+    ls: ["list"],
+    pause: ["release"],
+    read: ["get"],
+    remove: ["delete"],
+    rm: ["delete"],
+    show: ["get"],
+};
+/** Score one command path for a guessed command token; lower is better. */
+export function scoreCommandPathMatch(commandPath, queryToken) {
+    const normalizedPath = commandPath.trim().toLowerCase();
+    const normalizedToken = queryToken.trim().toLowerCase();
+    if (normalizedToken.length === 0)
+        return Number.POSITIVE_INFINITY;
+    const segments = normalizedPath.split(" ");
+    const semanticIndex = COMMAND_SYNONYMS[normalizedToken]?.indexOf(normalizedPath);
+    if (semanticIndex !== undefined && semanticIndex >= 0)
+        return semanticIndex;
+    if (normalizedPath === normalizedToken)
+        return 10;
+    if (segments.includes(normalizedToken))
+        return 11;
+    if (segments.some((segment) => segment.startsWith(normalizedToken)))
+        return 12;
+    const maxDistance = normalizedToken.length >= 5 ? 2 : 1;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const segment of segments) {
+        const distance = levenshteinDistanceWithinLimit(segment, normalizedToken, maxDistance);
+        if (distance !== null)
+            bestDistance = Math.min(bestDistance, distance);
+    }
+    if (Number.isFinite(bestDistance))
+        return 20 + bestDistance;
+    if (normalizedPath.includes(normalizedToken))
+        return 30;
+    return Number.POSITIVE_INFINITY;
+}
+/** Rank available command paths for one guessed token. */
+export function rankCommandPaths(commandPaths, queryToken) {
+    return commandPaths
+        .map((path) => ({ path, score: scoreCommandPathMatch(path, queryToken) }))
+        .filter((entry) => Number.isFinite(entry.score))
+        .sort((left, right) => {
+        if (left.score !== right.score)
+            return left.score - right.score;
+        if (left.path === right.path)
+            return 0;
+        return left.path < right.path ? -1 : 1;
+    })
+        .map((entry) => entry.path);
+}
+//# sourceMappingURL=command-suggestions.js.map
+//# debugId=71e5a870-f62f-5252-b4e9-e1a42e36009f

package/dist/sdk/agent/create-option-policy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module sdk/create-option-policy
+ *
+ * Defines explicit-empty assertions for repeatable create options. A strict
+ * schema can require that an agent considers a collection without forcing it
+ * to invent an entry: the corresponding `--clear-*` flag is an auditable,
+ * truthful answer that the collection is intentionally empty.
+ */
+/** Return the explicit-empty flag for a repeatable create option. */
+export declare function resolveCreateExplicitEmptyFlag(optionKey: string): string | undefined;
+/** Return whether a create option can be satisfied by an explicit empty set. */
+export declare function supportsCreateExplicitEmpty(optionKey: string): boolean;

package/dist/sdk/agent/create-option-policy.js

@@ -0,0 +1,32 @@
+/**
+ * @module sdk/create-option-policy
+ *
+ * Defines explicit-empty assertions for repeatable create options. A strict
+ * schema can require that an agent considers a collection without forcing it
+ * to invent an entry: the corresponding `--clear-*` flag is an auditable,
+ * truthful answer that the collection is intentionally empty.
+ */
+
+!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]="002f45a2-edc3-5aa0-9af8-d9b1dfecc097")}catch(e){}}();
+const CREATE_REPEATABLE_CLEAR_FLAGS = {
+    comment: "--clear-comments",
+    dep: "--clear-deps",
+    doc: "--clear-docs",
+    event: "--clear-events",
+    file: "--clear-files",
+    learning: "--clear-learnings",
+    note: "--clear-notes",
+    reminder: "--clear-reminders",
+    test: "--clear-tests",
+    typeOption: "--clear-type-options",
+};
+/** Return the explicit-empty flag for a repeatable create option. */
+export function resolveCreateExplicitEmptyFlag(optionKey) {
+    return CREATE_REPEATABLE_CLEAR_FLAGS[optionKey];
+}
+/** Return whether a create option can be satisfied by an explicit empty set. */
+export function supportsCreateExplicitEmpty(optionKey) {
+    return resolveCreateExplicitEmptyFlag(optionKey) !== undefined;
+}
+//# sourceMappingURL=create-option-policy.js.map
+//# debugId=002f45a2-edc3-5aa0-9af8-d9b1dfecc097

package/dist/sdk/agent/item-addressing.d.ts

@@ -0,0 +1,19 @@
+/** Result of normalizing one item-addressed invocation. */
+export interface ItemAddressInvocationResult {
+    /** Canonical argv with an `--id` value moved into positional-id location. */
+    argv: string[];
+    /** Whether argv changed. */
+    changed: boolean;
+    /** Whether both positional and named item ids were supplied. */
+    conflict: boolean;
+    /** Resolved named item id when one was present. */
+    itemId?: string;
+}
+/** Return whether a command participates in the shared item-id alias contract. */
+export declare function supportsItemIdAlias(commandName: string | undefined): boolean;
+/**
+ * Normalize `pm <command> --id <value>` to the command's positional id form.
+ * The transformation is lossless for every other argument and reports a
+ * conflict instead of guessing when both forms are present.
+ */
+export declare function normalizeItemAddressInvocation(argv: string[]): ItemAddressInvocationResult;