@unbrained/pm-cli 2026.8.22 → 2026.8.24

package/dist/core/item/parse.js

@@ -4,7 +4,7 @@
  * Defines item parsing, formatting, and lifecycle helpers for Parse.
  */
 
-!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]="d5003dd5-f208-5734-9711-dff935d8c851")}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]="2252cfb9-37ea-57f1-b7ea-2b0c0f87ecb2")}catch(e){}}();
 import { PmCliError } from "../shared/errors.js";
 import { EXIT_CODE } from "../shared/constants.js";
 const STDIN_TOKEN = "-";
@@ -416,6 +416,95 @@ async function readStdinText(optionName) {
         });
     });
 }
+const ALL_MUTATION_STDIN_FIELDS = Symbol("all-mutation-stdin-fields");
+const literalStdinTokenFields = new WeakMap();
+/** Mark transport-decoded options whose dash values are data, not stdin tokens. */
+export function preserveMutationStdinTokenLiterals(options) {
+    literalStdinTokenFields.set(options, ALL_MUTATION_STDIN_FIELDS);
+    return options;
+}
+/** Mark selected mutation fields whose dash values are literal transport data. */
+export function preserveMutationStdinTokenFields(options, fields) {
+    const current = literalStdinTokenFields.get(options);
+    if (current === ALL_MUTATION_STDIN_FIELDS)
+        return options;
+    literalStdinTokenFields.set(options, new Set([...(current ?? []), ...fields]));
+    return options;
+}
+/** Copy the complete mutation stdin-token policy across an option clone. */
+export function transferMutationStdinTokenPolicy(source, target) {
+    const policy = literalStdinTokenFields.get(source);
+    if (policy === undefined)
+        return target;
+    literalStdinTokenFields.set(target, policy === ALL_MUTATION_STDIN_FIELDS ? policy : new Set(policy));
+    return target;
+}
+/** Add a source mutation stdin-token policy without weakening the target. */
+export function overlayMutationStdinTokenPolicy(source, target) {
+    const sourcePolicy = literalStdinTokenFields.get(source);
+    const targetPolicy = literalStdinTokenFields.get(target);
+    if (sourcePolicy === undefined ||
+        targetPolicy === ALL_MUTATION_STDIN_FIELDS) {
+        return target;
+    }
+    if (sourcePolicy === ALL_MUTATION_STDIN_FIELDS) {
+        literalStdinTokenFields.set(target, sourcePolicy);
+        return target;
+    }
+    literalStdinTokenFields.set(target, new Set([...(targetPolicy ?? []), ...sourcePolicy]));
+    return target;
+}
+/** Report whether lifecycle input should interpret dash values as stdin tokens. */
+export function shouldResolveMutationStdinTokens(options) {
+    return literalStdinTokenFields.get(options) !== ALL_MUTATION_STDIN_FIELDS;
+}
+/** Report whether one mutation field should interpret dash as a stdin token. */
+export function shouldResolveMutationStdinTokenField(options, field) {
+    const literalFields = literalStdinTokenFields.get(options);
+    return (literalFields !== ALL_MUTATION_STDIN_FIELDS && !literalFields?.has(field));
+}
+/** Refuse competing stdin-token fields before any resolver starts reading. */
+export function assertSingleStdinTokenConsumer(candidates) {
+    let stdinConsumerOption;
+    for (const candidate of candidates) {
+        if (candidate.resolveToken === false || candidate.value === undefined) {
+            continue;
+        }
+        const values = Array.isArray(candidate.value)
+            ? candidate.value
+            : [candidate.value];
+        const tokenCount = values.filter((value) => value.trim() === STDIN_TOKEN).length;
+        if (tokenCount > 1) {
+            throw new PmCliError(`${candidate.optionName} accepts "${STDIN_TOKEN}" stdin token at most once per command invocation`, EXIT_CODE.USAGE);
+        }
+        if (tokenCount === 0)
+            continue;
+        if (stdinConsumerOption !== undefined &&
+            stdinConsumerOption !== candidate.optionName) {
+            throw new PmCliError(`Only one option may use "${STDIN_TOKEN}" stdin token per command invocation. Already used by ${stdinConsumerOption}.`, EXIT_CODE.USAGE);
+        }
+        stdinConsumerOption = candidate.optionName;
+    }
+}
+/** Resolve a typed mutation option bag only after its complete stdin plan is conflict-free. */
+export async function resolveMutationStdinTokenFields(options, scalarFields, listFields) {
+    const source = options;
+    const definitions = [...scalarFields, ...listFields];
+    assertSingleStdinTokenConsumer(definitions.map(([field, optionName]) => ({
+        value: source[field],
+        optionName,
+        resolveToken: shouldResolveMutationStdinTokenField(options, field),
+    })));
+    const stdinResolver = createStdinTokenResolver();
+    const resolved = { ...source };
+    for (const [field, optionName] of scalarFields) {
+        resolved[field] = await stdinResolver.resolveValue(source[field], optionName, shouldResolveMutationStdinTokenField(options, field));
+    }
+    for (const [field, optionName] of listFields) {
+        resolved[field] = await stdinResolver.resolveList(source[field], optionName, shouldResolveMutationStdinTokenField(options, field));
+    }
+    return preserveMutationStdinTokenLiterals(resolved);
+}
 /** Implements create stdin token resolver for the public runtime surface of this module. */
 export function createStdinTokenResolver() {
     let stdinValuePromise;
@@ -430,7 +519,9 @@ export function createStdinTokenResolver() {
         }
         return await stdinValuePromise;
     };
-    const resolveValue = async (value, optionName) => {
+    const resolveValue = async (value, optionName, resolveToken = true) => {
+        if (!resolveToken)
+            return value;
         if (value === undefined) {
             return undefined;
         }
@@ -439,7 +530,9 @@ export function createStdinTokenResolver() {
         }
         return await consumeStdin(optionName);
     };
-    const resolveList = async (values, optionName) => {
+    const resolveList = async (values, optionName, resolveToken = true) => {
+        if (!resolveToken)
+            return values;
         if (!values) {
             return undefined;
         }
@@ -486,4 +579,4 @@ export const _testOnly = {
     parseMarkdownKeyValueLines,
 };
 //# sourceMappingURL=parse.js.map
-//# debugId=d5003dd5-f208-5734-9711-dff935d8c851
+//# debugId=2252cfb9-37ea-57f1-b7ea-2b0c0f87ecb2

package/dist/core/reproducibility/context.d.ts

@@ -7,8 +7,12 @@ export interface ReproducibleExecutionSettings {
     /** Milliseconds advanced after each clock read. */
     tickMs: number;
 }
+/** Runs async operations against one shared deterministic sequence. */
+export type ReproducibleExecutionRunner = <T>(operation: () => Promise<T>) => Promise<T>;
 /** Validate and normalize deterministic execution settings before work starts. */
 export declare function validateReproducibleExecutionSettings(settings: ReproducibleExecutionSettings): ReproducibleExecutionSettings;
+/** Create a runner whose serial operations share deterministic clock and entropy state. */
+export declare function createReproducibleExecutionRunner(settings: ReproducibleExecutionSettings): ReproducibleExecutionRunner;
 /** Run an isolated async operation with deterministic clock and entropy state. */
 export declare function runWithReproducibleExecution<T>(settings: ReproducibleExecutionSettings, operation: () => Promise<T>): Promise<T>;
 /** Return the next deterministic clock value, or undefined outside a recipe. */

package/dist/core/reproducibility/context.js

@@ -2,10 +2,11 @@
  * @module core/reproducibility/context
  *
  * Provides opt-in deterministic time and identifier entropy for reproducible
- * workspace executions. The default CLI path never installs this context.
+ * workspace executions. SDK recipes and supported process adapters install
+ * this context explicitly; default execution remains nondeterministic.
  */
 
-!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]="cc84ae55-6dc4-57d4-b7de-c43ae1fb4603")}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]="aacc48ae-e9b2-5c8e-945f-89d05aff48e8")}catch(e){}}();
 import crypto from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 const executionStorage = new AsyncLocalStorage();
@@ -19,7 +20,7 @@ export function validateReproducibleExecutionSettings(settings) {
     if (!Number.isSafeInteger(settings.tickMs) || settings.tickMs < 0) {
         throw new Error("Reproducible workspace tickMs must be a non-negative integer");
     }
-    if (settings.seed.length === 0) {
+    if (settings.seed.trim().length === 0) {
         throw new Error("Reproducible workspace seed must not be empty");
     }
     return {
@@ -27,14 +28,19 @@ export function validateReproducibleExecutionSettings(settings) {
         clock: new Date(clockMs).toISOString(),
     };
 }
-/** Run an isolated async operation with deterministic clock and entropy state. */
-export async function runWithReproducibleExecution(settings, operation) {
+/** Create a runner whose serial operations share deterministic clock and entropy state. */
+export function createReproducibleExecutionRunner(settings) {
     const normalized = validateReproducibleExecutionSettings(settings);
-    return executionStorage.run({
+    const state = {
         ...normalized,
         clockReads: 0,
         tokenReads: 0,
-    }, operation);
+    };
+    return (operation) => executionStorage.run(state, operation);
+}
+/** Run an isolated async operation with deterministic clock and entropy state. */
+export async function runWithReproducibleExecution(settings, operation) {
+    return createReproducibleExecutionRunner(settings)(operation);
 }
 /** Return the next deterministic clock value, or undefined outside a recipe. */
 export function nextReproducibleTimestamp() {
@@ -74,4 +80,4 @@ export function nextReproducibleToken(length) {
     return token;
 }
 //# sourceMappingURL=context.js.map
-//# debugId=cc84ae55-6dc4-57d4-b7de-c43ae1fb4603
+//# debugId=aacc48ae-e9b2-5c8e-945f-89d05aff48e8

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

@@ -6,7 +6,7 @@ export type AgentModelSource = "override" | "environment" | "mcp_client" | "argv
 /** Stable built-in provenance dimensions understood by the default runtime. */
 export declare const AGENT_PROVENANCE_DIMENSIONS: readonly ["model", "effort", "role", "topic", "version"];
 /** Built-in, bounded local resolver names accepted by harness descriptors. */
-export type AgentProvenanceResolver = "ai_agent_version" | "claude_session_file";
+export type AgentProvenanceResolver = "ai_agent_version" | "claude_session_file" | "codex_session_file";
 /** One bounded provenance value and the signal class that supplied it. */
 export interface AgentProvenanceObservation {
     /** Bounded descriptive value retained in local history. */
@@ -74,6 +74,49 @@ export interface HarnessSignalDescriptor {
     /** Literal, case-insensitive MCP client-name markers. */
     client_names?: readonly string[];
 }
+/** Versioned package-replaceable provenance contract for one agent harness. */
+export interface AgentProvenanceAdapter {
+    /** Public adapter contract revision. */
+    contract_version: 1;
+    /** Adapter implementation revision supplied by pm or a package. */
+    adapter_version: string;
+    /** Explicit replacement precedence; built-ins use zero. */
+    priority: number;
+    /** Stable lowercase harness namespace. */
+    harness: string;
+    /** Executable detection and provenance descriptor. */
+    descriptor: HarnessSignalDescriptor;
+    /** Provenance dimensions intentionally covered by the adapter. */
+    supported_dimensions: readonly string[];
+    /** Privacy classes the adapter may inspect. */
+    native_sources: readonly ("environment" | "argv" | "mcp_client" | "session_file")[];
+    /** Hard bounds shared by runtime probes and package review. */
+    probe_policy: {
+        max_bytes: number;
+        max_lines: number;
+        network_access: false;
+        subprocess_access: false;
+    };
+    /** Stable normalization vocabulary declarations. */
+    normalization: {
+        model_family: "v1";
+        effort: "v1";
+        preserve_raw: true;
+    };
+    /** Confidence of a value read directly from the declared sources. */
+    confidence: "high" | "medium" | "low";
+    /** Bounded reasons for intentionally uncovered dimensions. */
+    waivers?: Readonly<Record<string, string>>;
+}
+/** One raw and normalized adapter value with its stable vocabulary revision. */
+export interface NormalizedAgentProvenanceAdapterValue {
+    /** Bounded value retained exactly as observed. */
+    raw: string;
+    /** Stable cross-harness family or vocabulary value. */
+    normalized: string;
+    /** Normalization vocabulary revision. */
+    vocabulary: "v1";
+}
 /** Public, privacy-safe agent observation shared by CLI, SDK, and MCP hosts. */
 export interface DetectedAgentIdentity {
     /** Normalized harness namespace when automatic detection succeeded. */
@@ -128,6 +171,8 @@ export interface HarnessDetectionSignals {
 }
 /** Built-in agent descriptors evaluated before package and workspace additions. */
 export declare const BUILTIN_HARNESS_SIGNAL_DESCRIPTORS: readonly HarnessSignalDescriptor[];
+/** Built-in versioned adapters for supported interactive agent harnesses. */
+export declare const BUILTIN_AGENT_PROVENANCE_ADAPTERS: readonly AgentProvenanceAdapter[];
 /**
  * Register package-provided harness signals until the returned disposer runs.
  *
@@ -136,6 +181,15 @@ export declare const BUILTIN_HARNESS_SIGNAL_DESCRIPTORS: readonly HarnessSignalD
  * repeated extension activation remains idempotent.
  */
 export declare function registerHarnessSignalDescriptors(descriptors: readonly HarnessSignalDescriptor[]): () => void;
+/** Return the effective built-in or explicitly higher-priority package adapters. */
+export declare function listAgentProvenanceAdapters(): readonly AgentProvenanceAdapter[];
+/**
+ * Register package adapters until disposal. Replacing a built-in requires an
+ * explicitly greater priority; equal-priority ambiguity fails closed.
+ */
+export declare function registerAgentProvenanceAdapters(adapters: readonly AgentProvenanceAdapter[]): () => void;
+/** Normalize model-family or effort vocabulary while retaining the raw value. */
+export declare function normalizeAgentProvenanceAdapterValue(dimension: "model" | "effort", value: string): NormalizedAgentProvenanceAdapterValue;
 /** Run one invocation with host-provided detection signals available downstream. */
 export declare function runWithHarnessDetectionSignals<T>(signals: HarnessDetectionSignals, callback: () => T): T;
 /** Run one invocation with workspace-provided descriptors available downstream. */