@unbrained/pm-cli 2026.8.9 → 2026.8.11

package/dist/core/shared/author.js

@@ -4,13 +4,14 @@
  * 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]="a89b5501-1909-5ea8-b34b-8ca9b4bc5dd5")}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]="e0ab2d6f-0925-540d-8d24-a7f0687b4bf0")}catch(e){}}();
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { resolveAgentSessionContextFromSignals, } from "./agent-session-context.js";
+import { readAgentSemanticAttributionSync, } from "../session/session-state.js";
 /** Stable built-in provenance dimensions understood by the default runtime. */
 export const AGENT_PROVENANCE_DIMENSIONS = [
     "model",
@@ -191,15 +192,6 @@ 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)
@@ -241,7 +233,10 @@ const AGENT_ROLE_VALUES = new Set([
 function normalizeProvenanceValue(dimension, value) {
     if (dimension !== "role" || value === undefined)
         return value;
-    const normalized = value.trim().toLowerCase().replaceAll(/[_\s]+/gu, "-");
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replaceAll(/[_\s]+/gu, "-");
     return AGENT_ROLE_VALUES.has(normalized) ? normalized : undefined;
 }
 function boundedProvenanceValue(provenance, dimension) {
@@ -310,13 +305,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;
@@ -334,7 +339,31 @@ function descriptorMatchesSignals(descriptor, env, labels, clientName) {
     const clientMatch = descriptor.client_names.some((name) => clientName === name || literalSignalMatches(clientName, name));
     return environmentMatch || argvMatch || clientMatch;
 }
-function resolveAgentProvenanceObservation(dimension, signals, env, descriptor, sessionContext) {
+function inferredProvenanceObservation(dimension, semanticAttribution) {
+    if (!semanticAttribution)
+        return undefined;
+    let value;
+    if (dimension === "topic")
+        value = semanticAttribution.topic;
+    if (dimension === "role")
+        value = semanticAttribution.role;
+    if (!value)
+        return undefined;
+    return {
+        value,
+        source: "inferred",
+        confidence: semanticAttribution.confidence,
+        rule_version: semanticAttribution.rule_version,
+        evidence: semanticAttribution.evidence,
+    };
+}
+function firstProvenanceObservation(candidates) {
+    const observed = candidates.find(([value]) => value !== undefined);
+    return observed?.[0]
+        ? { value: observed[0], source: observed[1] }
+        : undefined;
+}
+function resolveAgentProvenanceObservation(dimension, signals, env, descriptor, sessionContext, semanticAttribution) {
     const overrideKey = `PM_AGENT_${dimension.toUpperCase().replaceAll("-", "_")}`;
     const hostResolvedDimensions = new Set([
         ...AGENT_PROVENANCE_DIMENSIONS,
@@ -342,9 +371,11 @@ function resolveAgentProvenanceObservation(dimension, signals, env, descriptor,
     ]);
     let overrideValue;
     let argvValue;
+    let argvFlagValue;
     if (hostResolvedDimensions.has(dimension)) {
         overrideValue = normalizeProvenanceValue(dimension, nonBlank(env[overrideKey])?.slice(0, 256));
-        argvValue = provenanceFromArgv(signals.argv ?? [], dimension);
+        argvFlagValue = normalizeProvenanceValue(dimension, provenanceFlagValue(signals.argv ?? [], dimension));
+        argvValue = normalizeProvenanceValue(dimension, provenanceFromArgv(signals.argv ?? [], dimension));
     }
     const environmentKeysByDimension = {
         ...descriptor?.provenance_environment_keys,
@@ -354,31 +385,33 @@ function resolveAgentProvenanceObservation(dimension, signals, env, descriptor,
         ...signals.client_info?.provenance,
         model: signals.client_info?.model,
     };
-    const values = [
-        overrideValue,
-        boundedProvenanceValue(sessionContext?.provenance, dimension),
-        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 = [
-        "override",
-        "session",
-        "environment",
-        "mcp_client",
-        "host",
-        "argv",
-        "probe",
-    ];
-    const candidates = sources.map((source, index) => ({
-        value: values[index],
-        source,
-    }));
-    return candidates.find((candidate) => candidate.value !== undefined);
+    const sessionValue = boundedProvenanceValue(sessionContext?.provenance, dimension);
+    const environmentValue = normalizeProvenanceValue(dimension, firstEnvironmentValue(env, environmentKeysByDimension[dimension]));
+    const clientValue = normalizeProvenanceValue(dimension, boundedProvenanceValue(clientProvenance, dimension));
+    const hostValue = normalizeProvenanceValue(dimension, boundedProvenanceValue(signals.provenance, dimension));
+    const probeValue = resolveProvenanceProbe(dimension, signals, env, descriptor);
+    const observed = firstProvenanceObservation([
+        [overrideValue, "override"],
+        [sessionValue, "session"],
+        [argvFlagValue, "argv"],
+        [environmentValue, "environment"],
+        [clientValue, "mcp_client"],
+        [hostValue, "host"],
+        [probeValue, "probe"],
+    ]);
+    return (observed ??
+        inferredProvenanceObservation(dimension, semanticAttribution) ??
+        (argvValue ? { value: argvValue, source: "argv" } : undefined));
 }
-function resolveAgentProvenance(signals, env, descriptor, sessionContext) {
+function resolveAgentInstance(harness, session) {
+    if (!harness || !session)
+        return undefined;
+    return createHash("sha256")
+        .update(`pm-agent-instance:v1\0${harness}\0${session}`)
+        .digest("hex")
+        .slice(0, 24);
+}
+function resolveAgentProvenance(signals, env, descriptor, sessionContext, semanticAttribution) {
     const descriptorDimensions = Object.keys(descriptor?.provenance_environment_keys ?? {});
     const dimensions = new Set([
         ...AGENT_PROVENANCE_DIMENSIONS,
@@ -390,7 +423,7 @@ function resolveAgentProvenance(signals, env, descriptor, sessionContext) {
     ]);
     const observations = {};
     for (const dimension of dimensions) {
-        const observed = resolveAgentProvenanceObservation(dimension, signals, env, descriptor, sessionContext);
+        const observed = resolveAgentProvenanceObservation(dimension, signals, env, descriptor, sessionContext, semanticAttribution);
         if (observed) {
             observations[dimension] = observed;
         }
@@ -482,18 +515,18 @@ export function detectAgentIdentity(signals) {
     const clientName = effectiveSignals.client_info?.name.trim().toLowerCase() ?? "";
     const descriptor = descriptors.find((candidate) => descriptorMatchesSignals(candidate, env, labels, clientName));
     const sessionContext = resolveAgentSessionContextFromSignals(effectiveSignals, env);
-    const provenance = resolveAgentProvenance(effectiveSignals, env, descriptor, sessionContext);
-    const modelCandidate = provenance.model;
     const session = [
         firstEnvironmentValue(env, descriptor?.session_environment_keys),
         nonBlank(effectiveSignals.client_info?.session)?.slice(0, 256),
     ].find((candidate) => candidate !== undefined);
-    const instance = descriptor?.harness && session
-        ? createHash("sha256")
-            .update(`pm-agent-instance:v1\0${descriptor.harness}\0${session}`)
-            .digest("hex")
-            .slice(0, 24)
-        : undefined;
+    const instance = resolveAgentInstance(descriptor?.harness, session);
+    const semanticAttribution = readAgentSemanticAttributionSync({
+        cwd: effectiveSignals.cwd ?? process.cwd(),
+        env,
+        key: instance,
+    });
+    const provenance = resolveAgentProvenance(effectiveSignals, env, descriptor, sessionContext, semanticAttribution);
+    const modelCandidate = provenance.model;
     const entries = [
         ["harness", descriptor?.harness],
         ["model", modelCandidate?.value],
@@ -522,9 +555,7 @@ function resolveProvenanceOutcome(dimension, identity, descriptor, env, probesEn
         };
     }
     if (resolver) {
-        const resolverHasInput = resolver === "ai_agent_version"
-            ? nonBlank(env.AI_AGENT) !== undefined
-            : nonBlank(env.CLAUDE_CODE_SESSION_ID) !== undefined;
+        const resolverHasInput = provenanceResolverHasInput(resolver, descriptor, env);
         const status = resolverHasInput && probesEnabled ? "failed" : "unavailable";
         const reason = !resolverHasInput
             ? "harness_unavailable"
@@ -534,7 +565,9 @@ function resolveProvenanceOutcome(dimension, identity, descriptor, env, probesEn
         return { status, reason, resolver, rule_version: "v1" };
     }
     return {
-        status: "unavailable",
+        status: descriptor?.provenance_unavailable_dimensions.includes(dimension)
+            ? "unavailable"
+            : "not_configured",
         reason: descriptor?.provenance_unavailable_dimensions.includes(dimension)
             ? "harness_unavailable"
             : "resolver_not_configured",
@@ -680,4 +713,4 @@ export function resolveAuthor(candidate, fallback) {
     return identity.author;
 }
 //# sourceMappingURL=author.js.map
-//# debugId=a89b5501-1909-5ea8-b34b-8ca9b4bc5dd5
+//# debugId=e0ab2d6f-0925-540d-8d24-a7f0687b4bf0

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

@@ -19,6 +19,14 @@ export interface PmCliErrorRecoveryPayload {
     missing_required_fields?: string[];
     /** Value that configures or reports suggested flags for this contract. */
     suggested_flags?: string[];
+    /** Complete allowed value set for a refused positional or enum token. */
+    allowed_values?: string[];
+    /** Ranked command paths that accept an option rejected on the attempted path. */
+    candidate_commands?: string[];
+    /** Complete number of accepting command paths before the recovery ceiling. */
+    candidate_commands_total?: number;
+    /** Whether additional accepting command paths were omitted from this payload. */
+    candidate_commands_truncated?: boolean;
     /** Value that configures or reports suggested retry for this contract. */
     suggested_retry?: string;
     /** Elapsed time in milliseconds for retry after. */
@@ -60,6 +68,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]="df6f6758-f972-5bf4-aaa8-b16dd9a247f3")}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=df6f6758-f972-5bf4-aaa8-b16dd9a247f3

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/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;