@unbrained/pm-cli 2026.8.22 → 2026.8.24

package/dist/sdk/lifecycle/update.js

@@ -4,9 +4,10 @@
  * Implements the pm update 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]="7c1729f8-4a67-5746-a1bf-351f862ceb66")}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]="6865ca88-7ca1-52fd-86fb-2a3439abeafa")}catch(e){}}();
 import { assertInitializedTracker } from "../environment/tracker-preflight.js";
-import { COMMON_MUTATION_COMMAND_OPTION_KEYS, canonicalizeCommandOptionKey, commandOptionFlagLabel, resolveItemTypeRegistry, resolveCommandOptionPolicyState, resolveTypeDefinition, resolveTypeName, validateTypeOptions, normalizeItemId, toItemRecord, buildInvalidTypeError, assertParentReferenceIsNotSelf, normalizeParentReferenceValue, validateMissingParentReference, validateSprintOrReleaseValue, applyAcceptanceCriteriaMutations, applyTagRemovals, assertNoUnknownCsvKeys, createStdinTokenResolver, looksLikeGenericKeyValueEntry, mergeAdditiveTags, parseCsvKv, parseOptionalNonNegativeInteger, parseOptionalNumber, parseTags, splitAcceptanceCriteria, resolvePriority, normalizeStatusInput, isTerminalStatus, collectRuntimeUpdateFieldValues, resolveItemTypesFilePath, resolveRuntimeFieldRegistry, resolveRuntimeStatusRegistry, describeAllowedTransitions, evaluateTransition, resolveTypeWorkflows, EXIT_CODE, PmCliError, stableValueEquals, resolveIsoOrRelative, getActiveExtensionRegistrations, collectRegisteredItemFieldNames, applyRegisteredItemFieldDefaultsAndValidation, parseRegisteredItemFieldAssignments, buildItemNotFoundError, listAllItemMetadataLight, locateItem, readLocatedItem, resolvePmRoot, readSettings, resolveAuthor, } from "../runtime-primitives.js";
+import { resolveMutationStdinTokenFields } from "../../core/item/parse.js";
+import { COMMON_MUTATION_COMMAND_OPTION_KEYS, canonicalizeCommandOptionKey, commandOptionFlagLabel, resolveItemTypeRegistry, resolveCommandOptionPolicyState, resolveTypeDefinition, resolveTypeName, validateTypeOptions, normalizeItemId, toItemRecord, buildInvalidTypeError, assertParentReferenceIsNotSelf, normalizeParentReferenceValue, validateMissingParentReference, validateSprintOrReleaseValue, applyAcceptanceCriteriaMutations, applyTagRemovals, assertNoUnknownCsvKeys, looksLikeGenericKeyValueEntry, mergeAdditiveTags, parseCsvKv, parseOptionalNonNegativeInteger, parseOptionalNumber, parseTags, shouldResolveMutationStdinTokens, transferMutationStdinTokenPolicy, splitAcceptanceCriteria, resolvePriority, normalizeStatusInput, isTerminalStatus, collectRuntimeUpdateFieldValues, resolveItemTypesFilePath, resolveRuntimeFieldRegistry, resolveRuntimeStatusRegistry, describeAllowedTransitions, evaluateTransition, resolveTypeWorkflows, EXIT_CODE, PmCliError, stableValueEquals, resolveIsoOrRelative, getActiveExtensionRegistrations, collectRegisteredItemFieldNames, applyRegisteredItemFieldDefaultsAndValidation, parseRegisteredItemFieldAssignments, buildItemNotFoundError, listAllItemMetadataLight, locateItem, readLocatedItem, resolvePmRoot, readSettings, resolveAuthor, } from "../runtime-primitives.js";
 import { mutateItemWithHistoryContextResolver } from "../../core/store/item-store.js";
 import { runClose } from "./close.js";
 import { normalizeRiskInput, normalizeSeverityInput, parseConfidenceInput, parseRegressionInput, } from "./metadata-normalizers.js";
@@ -22,6 +23,7 @@ import { resolveWorkspaceRelationshipKindRegistry } from "../graph/assembly.js";
 import { acquireHierarchyMutationLock } from "./hierarchy-mutation-lock.js";
 import { DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RISK_VALUES, } from "../../types/index.js";
 import { parseDocs, parseFiles, parseLogSeed, parseTests, requireStringOption, } from "./create.js";
+import { attachLinkedTestMutationProvenance } from "../test/trust.js";
 import { COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR, COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR, COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON, parseCommandUnsetTargets, resolveRuntimeUnsetFieldDefinition, } from "./shared-unset-fields.js";
 const UPDATE_UNSET_FIELD_DEFINITIONS = [
     ...COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
@@ -107,7 +109,7 @@ function normalizeLegacyNoneUpdateOptions(options) {
         normalized[optionKey] = undefined;
         /* c8 ignore stop */
     }
-    return applyLegacyNoneCollectionNormalizers(normalized, UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS);
+    return transferMutationStdinTokenPolicy(options, applyLegacyNoneCollectionNormalizers(normalized, UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS));
 }
 function parseUpdateUnsetTargets(raw, runtimeFieldRegistry, extensionFieldNames = []) {
     return parseCommandUnsetTargets({
@@ -590,7 +592,7 @@ function docKey(value) {
     return `${value.path}::${value.scope}`;
 }
 function testKey(value) {
-    return `${value.command}::${value.path ?? ""}::${value.scope}::${value.pm_context_mode ?? ""}`;
+    return `${value.command}::${value.path ?? ""}::${value.scope}::${value.pm_context_mode ?? ""}::${value.workspace_context_mode ?? ""}`;
 }
 function matchesDependencySelector(value, selector) {
     if (value.id.trim().toLowerCase() !== selector.id.trim().toLowerCase()) {
@@ -857,23 +859,31 @@ function applyUpdateScalarMutations(definitions, options, context) {
     }
 }
 async function resolveStdinUpdateOptions(options) {
-    const stdinResolver = createStdinTokenResolver();
-    return normalizeLegacyNoneUpdateOptions({
-        ...options,
-        body: await stdinResolver.resolveValue(options.body, "--body"),
-        dep: await stdinResolver.resolveList(options.dep, "--dep"),
-        depRemove: await stdinResolver.resolveList(options.depRemove, "--dep-remove"),
-        comment: await stdinResolver.resolveList(options.comment, "--comment"),
-        note: await stdinResolver.resolveList(options.note, "--note"),
-        learning: await stdinResolver.resolveList(options.learning, "--learning"),
-        file: await stdinResolver.resolveList(options.file, "--file"),
-        test: await stdinResolver.resolveList(options.test, "--test"),
-        doc: await stdinResolver.resolveList(options.doc, "--doc"),
-        reminder: await stdinResolver.resolveList(options.reminder, "--reminder"),
-        event: await stdinResolver.resolveList(options.event, "--event"),
-        typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option"),
-        field: await stdinResolver.resolveList(options.field, "--field"),
-    });
+    const scalarFields = [
+        ["body", "--body"],
+        ["description", "--description"],
+    ];
+    const listFields = [
+        ["dep", "--dep"],
+        ["depRemove", "--dep-remove"],
+        ["comment", "--comment"],
+        ["note", "--note"],
+        ["learning", "--learning"],
+        ["file", "--file"],
+        ["test", "--test"],
+        ["doc", "--doc"],
+        ["reminder", "--reminder"],
+        ["event", "--event"],
+        ["typeOption", "--type-option"],
+        ["field", "--field"],
+    ];
+    return normalizeLegacyNoneUpdateOptions(await resolveMutationStdinTokenFields(options, scalarFields, listFields));
+}
+/** Resolve update stdin tokens once while preserving transport-marked literals. */
+export async function resolveUpdateTransportOptions(options) {
+    return shouldResolveMutationStdinTokens(options)
+        ? await resolveStdinUpdateOptions(options)
+        : normalizeLegacyNoneUpdateOptions(options);
 }
 function buildClearCollectionDefinitions(options) {
     return [
@@ -1219,12 +1229,13 @@ async function routeCloseStatusUpdate(context) {
     const routeWarnings = [];
     let preChangedFields = [];
     if (otherFieldKeys.length > 0) {
-        const preUpdate = await runUpdate(context.id, {
+        const preUpdateOptions = transferMutationStdinTokenPolicy(context.options, {
             ...context.options,
             status: undefined,
             closeReason: undefined,
             message: undefined,
-        }, context.global);
+        });
+        const preUpdate = await runUpdate(context.id, preUpdateOptions, context.global);
         preChangedFields = preUpdate.changed_fields;
         routeWarnings.push(...preUpdate.warnings);
     }
@@ -1803,7 +1814,7 @@ function mutateUpdateDocument(document, context) {
 }
 /** Implements run update for the public runtime surface of this module. */
 async function runUpdateWithContext(id, options, global, execution = {}) {
-    options = await resolveStdinUpdateOptions(options);
+    options = await resolveUpdateTransportOptions(options);
     const pmRoot = resolvePmRoot(process.cwd(), global.path);
     await assertUpdateTrackerInitialized(pmRoot);
     const settings = await readSettings(pmRoot);
@@ -1871,6 +1882,7 @@ async function runUpdateWithContext(id, options, global, execution = {}) {
     const learningUpdates = parseLogSeed("--learning", options.learning, nowIso, author);
     const fileUpdates = parseFiles(options.file);
     const testUpdates = parseTests(options.test);
+    testUpdates.values = await attachLinkedTestMutationProvenance(testUpdates.values, author, nowIso);
     const docUpdates = parseDocs(options.doc);
     const workflowTransitionWarnings = [];
     const parentReference = await resolveParentReferenceForUpdate({
@@ -2109,4 +2121,4 @@ export const _testOnlyUpdateCommand = {
     resolveRuntimeUnsetDefinition: (token, registry) => resolveRuntimeUnsetFieldDefinition(token, "update", registry),
 };
 //# sourceMappingURL=update.js.map
-//# debugId=7c1729f8-4a67-5746-a1bf-351f862ceb66
+//# debugId=6865ca88-7ca1-52fd-86fb-2a3439abeafa

package/dist/sdk/merge/three-way.js

@@ -9,7 +9,7 @@
  * definition for multi-branch agent workflows.
  */
 
-!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]="3c9d6924-ae7c-57c3-a346-1e2189c532fa")}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]="393f6460-bf8b-5479-8e3e-cac6f2680823")}catch(e){}}();
 import { historyEntriesToRaw, reanchorHistoryEntries, } from "../../core/history/replay.js";
 import { canonicalDocument, parseItemDocument, serializeItemDocument, } from "../../core/item/item-format.js";
 import { EXIT_CODE } from "../../core/shared/constants.js";
@@ -318,6 +318,58 @@ function unionCollection(base, ours, theirs) {
     }
     return merged;
 }
+function linkedTestDefinitionIdentity(value) {
+    /* c8 ignore start -- canonical item parsing normalizes linked-test entries to object records */
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return stableStringify(value);
+    }
+    /* c8 ignore stop */
+    const { provenance: _provenance, ...definition } = value;
+    return stableStringify(definition);
+}
+function markMergedLinkedTest(value) {
+    /* c8 ignore start -- canonical item parsing normalizes linked-test entries to object records */
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return value;
+    }
+    /* c8 ignore stop */
+    const test = value;
+    if (!test.provenance) {
+        return {
+            ...test,
+            // Legacy entries contributed by another branch must not regain implicit
+            // local trust. This incomplete merge marker is preserved by normalization
+            // and refused until an operator acknowledges it in the receiving clone.
+            provenance: { source_kind: "merge_union" },
+        };
+    }
+    return {
+        ...test,
+        provenance: {
+            ...test.provenance,
+            source_kind: "merge_union",
+        },
+    };
+}
+function unionLinkedTests(base, ours, theirs) {
+    const toEntries = (value) => Array.isArray(value) ? value : [];
+    const baseIds = new Set(toEntries(base).map(linkedTestDefinitionIdentity));
+    const oursEntries = toEntries(ours);
+    const oursIds = new Set(oursEntries.map(linkedTestDefinitionIdentity));
+    const theirsEntries = toEntries(theirs);
+    const theirsIds = new Set(theirsEntries.map(linkedTestDefinitionIdentity));
+    const merged = oursEntries.filter((entry) => {
+        const identity = linkedTestDefinitionIdentity(entry);
+        return !baseIds.has(identity) || theirsIds.has(identity);
+    });
+    for (const entry of theirsEntries) {
+        const identity = linkedTestDefinitionIdentity(entry);
+        if (!oursIds.has(identity) && !baseIds.has(identity)) {
+            merged.push(markMergedLinkedTest(entry));
+        }
+    }
+    return merged;
+}
 function latestTimestamp(ours, theirs) {
     return compareTimestampStrings(String(ours), String(theirs)) >= 0
         ? ours
@@ -362,6 +414,40 @@ function parseItemMergeSide(raw, label, options) {
         throw new PmCliError(`Item merge input (${label}) is not a readable item document: ${String(error)}`, EXIT_CODE.GENERIC_FAILURE);
     }
 }
+/** Merge one collection field and report whether the field was handled. */
+function mergeItemUnionField(params) {
+    if (!params.unionFieldSet.has(params.field))
+        return false;
+    const union = params.field === "tests"
+        ? unionLinkedTests(params.baseValue, params.oursValue, params.theirsValue)
+        : unionCollection(params.baseValue, params.oursValue, params.theirsValue);
+    params.accumulator.merged[params.field] = union;
+    if (!jsonEquals(union, params.oursValue)) {
+        params.accumulator.unionFields.push(params.field);
+    }
+    return true;
+}
+/** Merge one scalar field while preserving conflict evidence. */
+function mergeItemScalarField(params) {
+    const outcome = mergeItemScalarThreeWay(params.baseValue, params.oursValue, params.theirsValue, params.preferred, params.conflictResolution);
+    if (outcome.value !== undefined) {
+        params.accumulator.merged[params.field] = outcome.value;
+    }
+    if (outcome.conflict) {
+        params.accumulator.conflictFields.push(params.field);
+        params.accumulator.conflictDecisions.push({
+            field: params.field,
+            base: params.baseValue,
+            ours: params.oursValue,
+            theirs: params.theirsValue,
+            retained: outcome.value,
+            discarded: outcome.from_theirs ? params.oursValue : params.theirsValue,
+        });
+    }
+    else if (outcome.from_theirs) {
+        params.accumulator.fieldsFromTheirs.push(params.field);
+    }
+}
 function mergeItemMetadataRecords(baseRecord, oursRecord, theirsRecord, preferred, conflictResolution) {
     const unionFieldSet = new Set(ITEM_UNION_COLLECTION_FIELDS);
     const latestFieldSet = new Set(ITEM_LATEST_TIMESTAMP_FIELDS);
@@ -379,39 +465,32 @@ function mergeItemMetadataRecords(baseRecord, oursRecord, theirsRecord, preferre
         const baseValue = baseRecord[field];
         const oursValue = oursRecord[field];
         const theirsValue = theirsRecord[field];
-        if (unionFieldSet.has(field)) {
-            const union = unionCollection(baseValue, oursValue, theirsValue);
+        if (mergeItemUnionField({
+            field,
+            baseValue,
+            oursValue,
+            theirsValue,
+            unionFieldSet,
+            accumulator,
+        })) {
             // `fieldNames` is derived from both records' own keys, so a collection
             // reached here is declared by at least one side. Preserve even an empty
             // result (`tags` is required) so serialization never drops it.
-            accumulator.merged[field] = union;
-            if (!jsonEquals(union, oursValue)) {
-                accumulator.unionFields.push(field);
-            }
             continue;
         }
         if (latestFieldSet.has(field)) {
             accumulator.merged[field] = latestTimestamp(oursValue, theirsValue);
             continue;
         }
-        const outcome = mergeItemScalarThreeWay(baseValue, oursValue, theirsValue, preferred, conflictResolution);
-        if (outcome.value !== undefined) {
-            accumulator.merged[field] = outcome.value;
-        }
-        if (outcome.conflict) {
-            accumulator.conflictFields.push(field);
-            accumulator.conflictDecisions.push({
-                field,
-                base: baseValue,
-                ours: oursValue,
-                theirs: theirsValue,
-                retained: outcome.value,
-                discarded: outcome.from_theirs ? oursValue : theirsValue,
-            });
-        }
-        else if (outcome.from_theirs) {
-            accumulator.fieldsFromTheirs.push(field);
-        }
+        mergeItemScalarField({
+            field,
+            baseValue,
+            oursValue,
+            theirsValue,
+            preferred,
+            conflictResolution,
+            accumulator,
+        });
     }
     return accumulator;
 }
@@ -625,4 +704,4 @@ export function mergeJsonDocuments(baseRaw, oursRaw, theirsRaw, options = {}) {
     };
 }
 //# sourceMappingURL=three-way.js.map
-//# debugId=3c9d6924-ae7c-57c3-a346-1e2189c532fa
+//# debugId=393f6460-bf8b-5479-8e3e-cac6f2680823

package/dist/sdk/read-output-budget.d.ts

@@ -5,6 +5,27 @@
  * read-output contract without expanding its public declaration module.
  */
 import type { PmReadOutputReceipt } from "./read-output-contracts.js";
+/** Input to the deterministic finite-retry recommendation contract. */
+export interface PmReadOutputRecoveryBudgetInput {
+    /** Ceiling that already bound and truncated the response. */
+    effective_budget_tokens: number;
+    /** Measured cost of the useful result before row compaction. */
+    measured_result_tokens: number;
+}
+/** Executable next-budget recommendation shared by CLI, SDK, and MCP. */
+export interface PmReadOutputRecoveryBudget {
+    /** Rounded finite retry ceiling, or the only truthful safe fallback. */
+    output_budget: number | "unbounded";
+    /** Ratio to the binding request, absent when finite arithmetic is unsafe. */
+    recovery_budget_multiplier: number | null;
+    /** Stable algorithm revision for consumers and fixtures. */
+    rule_version: "v1";
+}
+/**
+ * Recommend a retry that is strictly larger than both the binding request and
+ * the pre-compaction result, with a 25% envelope margin rounded to 100 tokens.
+ */
+export declare function resolveReadOutputRecoveryBudget(input: PmReadOutputRecoveryBudgetInput): PmReadOutputRecoveryBudget;
 /** Estimate the conservative token cost of a JSON-shaped result. */
 export declare function estimateReadOutputTokens(result: unknown): number;
 /** Update a receipt to the fixed-point estimate of the result containing it. */

package/dist/sdk/read-output-budget.js

@@ -1,8 +1,45 @@
 
-!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]="737ac274-c165-5d1a-8b8e-cb5d57a81c46")}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]="02a0bd0c-6ab0-5193-807b-00394a4712b7")}catch(e){}}();
 import { countReadOutputRows, readOutputBudgetCollections, } from "./read-output-rows.js";
 const MAX_ESTIMATE_ITERATIONS = 8;
 const MAX_COMPACTION_ITERATIONS = 64;
+const RECOVERY_MARGIN_NUMERATOR = 5;
+const RECOVERY_MARGIN_DENOMINATOR = 4;
+const RECOVERY_ROUNDING_TOKENS = 100;
+/**
+ * Recommend a retry that is strictly larger than both the binding request and
+ * the pre-compaction result, with a 25% envelope margin rounded to 100 tokens.
+ */
+export function resolveReadOutputRecoveryBudget(input) {
+    const binding = Math.trunc(input.effective_budget_tokens);
+    const measured = Math.trunc(input.measured_result_tokens);
+    if (!Number.isSafeInteger(binding) ||
+        binding <= 0 ||
+        !Number.isSafeInteger(measured) ||
+        measured <= 0) {
+        return {
+            output_budget: "unbounded",
+            recovery_budget_multiplier: null,
+            rule_version: "v1",
+        };
+    }
+    const baseline = Math.max(binding + 1, measured);
+    const withMargin = Math.ceil((baseline * RECOVERY_MARGIN_NUMERATOR) / RECOVERY_MARGIN_DENOMINATOR);
+    const rounded = Math.ceil(withMargin / RECOVERY_ROUNDING_TOKENS) *
+        RECOVERY_ROUNDING_TOKENS;
+    if (!Number.isSafeInteger(rounded)) {
+        return {
+            output_budget: "unbounded",
+            recovery_budget_multiplier: null,
+            rule_version: "v1",
+        };
+    }
+    return {
+        output_budget: rounded,
+        recovery_budget_multiplier: rounded / binding,
+        rule_version: "v1",
+    };
+}
 /** Estimate the conservative token cost of a JSON-shaped result. */
 export function estimateReadOutputTokens(result) {
     return Math.ceil(Buffer.byteLength(JSON.stringify(result), "utf8") / 4);
@@ -96,4 +133,4 @@ export function compactReadOutputToBudget(result, receipt, budget, minimumRowsBy
     return compacted;
 }
 //# sourceMappingURL=read-output-budget.js.map
-//# debugId=737ac274-c165-5d1a-8b8e-cb5d57a81c46
+//# debugId=02a0bd0c-6ab0-5193-807b-00394a4712b7

package/dist/sdk/read-output-contracts.d.ts

@@ -1,3 +1,5 @@
+export { resolveReadOutputRecoveryBudget } from "./read-output-budget.js";
+export type { PmReadOutputRecoveryBudget, PmReadOutputRecoveryBudgetInput, } from "./read-output-budget.js";
 export { decodeReadOutputContinuationCursor, encodeReadOutputContinuationCursor, } from "./read-output/continuation.js";
 import { type PmReadOutputSessionReceipt, type PmReadOutputSessionState } from "./read-output-session.js";
 /** Stable output dimensions shared by every read surface. */
@@ -142,7 +144,7 @@ export interface PmReadOutputTruncationDisclosure {
     /** Whether at least one declared row collection can be resumed within the budget. */
     continuation_available: boolean;
     /** Maximum next-page useful-result budget relative to the current budget. */
-    recovery_budget_multiplier: 1;
+    recovery_budget_multiplier: number | null;
     /** Bounded continuation instructions for every compacted declared row path. */
     continuations: PmReadOutputContinuation[];
     /** Executable recovery instruction for retrieving the complete result. */
@@ -160,10 +162,10 @@ export interface PmReadOutputTruncationDisclosure {
     } | {
         cli: string;
         sdk: {
-            outputBudget: number;
+            outputBudget: number | "unbounded";
         };
         mcp: {
-            outputBudget: number;
+            outputBudget: number | "unbounded";
         };
     };
 }

package/dist/sdk/read-output-contracts.js

@@ -5,10 +5,11 @@
  * surface without coupling package authors to command-specific option names.
  */
 
-!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]="a1272c1f-c03e-580c-8c44-6b3ddeedd240")}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]="76c9c2d0-951d-579e-916e-e8d54d4a8be9")}catch(e){}}();
 import { EXIT_CODE } from "../core/shared/constants.js";
 import { PmCliError } from "../core/shared/errors.js";
-import { compactReadOutputToBudget, estimateReadOutputTokens, updateReadOutputReceiptEstimate, } from "./read-output-budget.js";
+import { compactReadOutputToBudget, estimateReadOutputTokens, resolveReadOutputRecoveryBudget, updateReadOutputReceiptEstimate, } from "./read-output-budget.js";
+export { resolveReadOutputRecoveryBudget } from "./read-output-budget.js";
 import { resolvePmCommandOutputBudget } from "./cli-contracts/agent-output-contracts.js";
 import { boundReadOutputRows, countReadOutputRows, mapReadOutputRows, readOutputBudgetCollections, readOutputContinuationRowCollections, readOutputRowPaths, } from "./read-output-rows.js";
 import { applyReadOutputContinuation, decodeReadOutputContinuationCursor, encodeReadOutputContinuationCursor, prioritizeAssuranceAssertions, readOutputCollectionFingerprint, } from "./read-output/continuation.js";
@@ -979,7 +980,7 @@ function canReturnReadOutputUnchanged(resolved, session, result) {
  * without this an explicitly requested unbounded read is silently downgraded and
  * the only working recovery is never named.
  */
-function attachReadOutputTruncationDisclosure(projected, resolved, receipt, bindingBudget, continuationCursorRebased, collectionsBeforeBudget) {
+function attachReadOutputTruncationDisclosure(projected, resolved, receipt, bindingBudget, continuationCursorRebased, measuredResultTokens, collectionsBeforeBudget) {
     if (!receipt.rows_compacted)
         return;
     const overridden = resolved.amount?.value === "unbounded" ? ["amount"] : [];
@@ -1013,6 +1014,10 @@ function attachReadOutputTruncationDisclosure(projected, resolved, receipt, bind
         ];
     });
     const primary = continuations[0];
+    const recoveryBudget = resolveReadOutputRecoveryBudget({
+        effective_budget_tokens: bindingBudget.tokens,
+        measured_result_tokens: measuredResultTokens,
+    });
     if (primary && typeof projected.next_cursor !== "string") {
         projected.next_cursor = primary.cursor;
     }
@@ -1029,11 +1034,13 @@ function attachReadOutputTruncationDisclosure(projected, resolved, receipt, bind
         compacted_row_paths: receipt.compacted_row_paths,
         continuation_cursor_rebased: continuationCursorRebased,
         continuation_available: continuations.length > 0,
-        recovery_budget_multiplier: 1,
+        recovery_budget_multiplier: primary
+            ? 1
+            : recoveryBudget.recovery_budget_multiplier,
         continuations,
         restore_with: primary
             ? "Use recovery binding."
-            : "Increase --output-budget because no declared row collection can be continued.",
+            : `Retry with --output-budget ${recoveryBudget.output_budget} because no declared row collection can be continued.`,
         recovery: primary
             ? {
                 cursor: primary.cursor,
@@ -1042,9 +1049,9 @@ function attachReadOutputTruncationDisclosure(projected, resolved, receipt, bind
                 mcp: "outputCursor",
             }
             : {
-                cli: "--output-budget 1200",
-                sdk: { outputBudget: 1200 },
-                mcp: { outputBudget: 1200 },
+                cli: `--output-budget ${recoveryBudget.output_budget}`,
+                sdk: { outputBudget: recoveryBudget.output_budget },
+                mcp: { outputBudget: recoveryBudget.output_budget },
             },
     };
 }
@@ -1115,7 +1122,7 @@ function captureReadOutputContinuationState(projected, cursor, options) {
             : options.after,
     };
 }
-function compactReadOutputProjection(projected, resolved, receipt, bindingBudget, session, continuationState) {
+function compactReadOutputProjection(projected, resolved, receipt, bindingBudget, session, continuationState, measuredResultTokens) {
     const assuranceMinimumRows = resolved.command === "assurance" && Array.isArray(projected.assertions)
         ? projected.assertions.filter((row) => isRecord(row) && row.verdict !== "pass").length
         : 0;
@@ -1123,7 +1130,7 @@ function compactReadOutputProjection(projected, resolved, receipt, bindingBudget
         ? new Map([["assertions", assuranceMinimumRows]])
         : new Map());
     const continuationCursorRebased = rebaseBudgetCompactedCursor(compacted, continuationState.originalItemCount, continuationState.cursorSource, continuationState.cursorContinuesExistingPage);
-    attachReadOutputTruncationDisclosure(compacted, resolved, receipt, bindingBudget, continuationCursorRebased, continuationState.collectionsBeforeBudget);
+    attachReadOutputTruncationDisclosure(compacted, resolved, receipt, bindingBudget, continuationCursorRebased, measuredResultTokens, continuationState.collectionsBeforeBudget);
     if (session !== undefined) {
         compacted = attachReadOutputSessionContracts(compacted, session, receipt);
     }
@@ -1176,7 +1183,8 @@ export function applyReadOutputDimensions(command, options, result) {
     updateReadOutputReceiptEstimate(projected, receipt);
     if (bindingBudget !== undefined &&
         receipt.estimated_tokens > bindingBudget.tokens) {
-        projected = compactReadOutputProjection(projected, resolved, receipt, bindingBudget, session, continuationState);
+        const measuredResultTokens = receipt.estimated_tokens;
+        projected = compactReadOutputProjection(projected, resolved, receipt, bindingBudget, session, continuationState, measuredResultTokens);
     }
     if (bindingBudget !== undefined &&
         receipt.estimated_tokens > bindingBudget.tokens) {
@@ -1199,4 +1207,4 @@ export function resolveReadOutputEncoding(command, options) {
         : undefined;
 }
 //# sourceMappingURL=read-output-contracts.js.map
-//# debugId=a1272c1f-c03e-580c-8c44-6b3ddeedd240
+//# debugId=76c9c2d0-951d-579e-916e-e8d54d4a8be9

package/dist/sdk/reproducibility/process.d.ts

@@ -0,0 +1,19 @@
+import { type ReproducibleExecutionSettings, type ReproducibleExecutionRunner } from "../../core/reproducibility/context.js";
+/** Stable environment-variable names understood by every pm process transport. */
+export declare const PM_REPRODUCIBLE_PROCESS_ENV: Readonly<{
+    readonly clock: "PM_CLOCK";
+    readonly tickMs: "PM_CLOCK_TICK_MS";
+    readonly seed: "PM_SEED";
+}>;
+/** Environment-shaped input accepted by the reproducible process adapter. */
+export type ReproducibleProcessEnvironment = Readonly<Record<string, string | undefined>>;
+/** Public deterministic settings installed by recipes and process transports. */
+export type { ReproducibleExecutionSettings };
+/** Runner used by long-lived transports whose serial operations share one sequence. */
+export type ReproducibleProcessRunner = ReproducibleExecutionRunner;
+/** Resolve validated deterministic settings, or undefined when no opt-in is present. */
+export declare function resolveReproducibleProcessEnvironment(environment: ReproducibleProcessEnvironment): ReproducibleExecutionSettings | undefined;
+/** Create one process-lifetime runner for long-lived serial transports such as MCP. */
+export declare function createReproducibleProcessRunner(environment: ReproducibleProcessEnvironment): ReproducibleProcessRunner;
+/** Run one process transport operation under its declared deterministic context. */
+export declare function runWithReproducibleProcessEnvironment<T>(environment: ReproducibleProcessEnvironment, operation: () => Promise<T>): Promise<T>;

package/dist/sdk/reproducibility/process.js

@@ -0,0 +1,88 @@
+/**
+ * @module sdk/reproducible-process
+ *
+ * Owns the process-environment contract that lets CLI and MCP transports enter
+ * the same deterministic execution context as SDK workspace recipes.
+ */
+
+!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]="ae031bac-f5a1-5762-9c58-0410b8f1f86d")}catch(e){}}();
+import { EXIT_CODE } from "../../core/shared/constants.js";
+import { PmCliError } from "../../core/shared/errors.js";
+import { isRfc3339DateTime } from "../../core/shared/time.js";
+import { createReproducibleExecutionRunner, validateReproducibleExecutionSettings, } from "../../core/reproducibility/context.js";
+/** Stable environment-variable names understood by every pm process transport. */
+export const PM_REPRODUCIBLE_PROCESS_ENV = Object.freeze({
+    clock: "PM_CLOCK",
+    tickMs: "PM_CLOCK_TICK_MS",
+    seed: "PM_SEED",
+});
+function invalidProcessEnvironment(message, reason, field, providedFields) {
+    return new PmCliError(message, EXIT_CODE.USAGE, {
+        code: "invalid_reproducible_process_environment",
+        reason,
+        field,
+        required: `${PM_REPRODUCIBLE_PROCESS_ENV.clock} and ${PM_REPRODUCIBLE_PROCESS_ENV.seed}; ${PM_REPRODUCIBLE_PROCESS_ENV.tickMs} is optional`,
+        nextSteps: [
+            `Set ${PM_REPRODUCIBLE_PROCESS_ENV.clock} to an ISO-8601 instant with Z or a numeric UTC offset and ${PM_REPRODUCIBLE_PROCESS_ENV.seed} to a non-empty reproducibility seed.`,
+            `Optionally set ${PM_REPRODUCIBLE_PROCESS_ENV.tickMs} to a non-negative integer; it defaults to 1.`,
+            `Unset all three variables to retain normal wall-clock and cryptographic-random behavior.`,
+        ],
+        recovery: {
+            recovery_mode: "compact",
+            provided_fields: providedFields,
+            missing_required_fields: reason === "incomplete"
+                ? [
+                    PM_REPRODUCIBLE_PROCESS_ENV.clock,
+                    PM_REPRODUCIBLE_PROCESS_ENV.seed,
+                ].filter((name) => !providedFields.includes(name))
+                : undefined,
+        },
+    });
+}
+/** Resolve validated deterministic settings, or undefined when no opt-in is present. */
+export function resolveReproducibleProcessEnvironment(environment) {
+    const clock = environment[PM_REPRODUCIBLE_PROCESS_ENV.clock];
+    const tick = environment[PM_REPRODUCIBLE_PROCESS_ENV.tickMs];
+    const seed = environment[PM_REPRODUCIBLE_PROCESS_ENV.seed];
+    const providedFields = [
+        [PM_REPRODUCIBLE_PROCESS_ENV.clock, clock],
+        [PM_REPRODUCIBLE_PROCESS_ENV.tickMs, tick],
+        [PM_REPRODUCIBLE_PROCESS_ENV.seed, seed],
+    ]
+        .filter((entry) => entry[1] !== undefined)
+        .map(([name]) => name);
+    if (providedFields.length === 0) {
+        return undefined;
+    }
+    if (clock === undefined || seed === undefined) {
+        throw invalidProcessEnvironment("Reproducible process execution requires PM_CLOCK and PM_SEED together.", "incomplete", clock === undefined
+            ? PM_REPRODUCIBLE_PROCESS_ENV.clock
+            : PM_REPRODUCIBLE_PROCESS_ENV.seed, providedFields);
+    }
+    if (seed.trim().length === 0) {
+        throw invalidProcessEnvironment(`${PM_REPRODUCIBLE_PROCESS_ENV.seed} must not be empty.`, "invalid_value", PM_REPRODUCIBLE_PROCESS_ENV.seed, providedFields);
+    }
+    if (!isRfc3339DateTime(clock)) {
+        throw invalidProcessEnvironment(`${PM_REPRODUCIBLE_PROCESS_ENV.clock} must be a valid ISO-8601 instant with Z or a numeric UTC offset.`, "invalid_value", PM_REPRODUCIBLE_PROCESS_ENV.clock, providedFields);
+    }
+    const tickMs = tick === undefined ? 1 : Number(tick);
+    if (tick?.trim().length === 0 ||
+        !Number.isSafeInteger(tickMs) ||
+        tickMs < 0) {
+        throw invalidProcessEnvironment(`${PM_REPRODUCIBLE_PROCESS_ENV.tickMs} must be a non-negative integer.`, "invalid_value", PM_REPRODUCIBLE_PROCESS_ENV.tickMs, providedFields);
+    }
+    return validateReproducibleExecutionSettings({ clock, seed, tickMs });
+}
+/** Create one process-lifetime runner for long-lived serial transports such as MCP. */
+export function createReproducibleProcessRunner(environment) {
+    const settings = resolveReproducibleProcessEnvironment(environment);
+    return settings === undefined
+        ? (operation) => operation()
+        : createReproducibleExecutionRunner(settings);
+}
+/** Run one process transport operation under its declared deterministic context. */
+export async function runWithReproducibleProcessEnvironment(environment, operation) {
+    return createReproducibleProcessRunner(environment)(operation);
+}
+//# sourceMappingURL=process.js.map
+//# debugId=ae031bac-f5a1-5762-9c58-0410b8f1f86d

package/dist/sdk/runtime-extended-actions.js

@@ -1,7 +1,8 @@
 
-!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]="0492d773-2af2-5072-8164-9f8aab536191")}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]="8a3a82a1-9e3d-555f-9111-3c3e19887f75")}catch(e){}}();
 import { EXIT_CODE } from "../core/shared/constants.js";
 import { PmCliError } from "../core/shared/errors.js";
+import { transferMutationStdinTokenPolicy, } from "./runtime-primitives.js";
 import { createUnknownSubcommandError } from "./agent/subcommand-recovery.js";
 import { resolvePmRoot } from "../core/store/paths.js";
 import { runEval } from "./eval.js";
@@ -14,7 +15,8 @@ import { parseRuntimeInteger, readRuntimeString, readRuntimeStringArray, } from
 import { runEvent, runMeet, runRemind, } from "./scheduling-shortcuts.js";
 import { createWorkspaceSnapshot, deleteWorkspaceSnapshot, inspectWorkspaceSnapshot, listWorkspaceSnapshots, planWorkspaceSnapshotRestore, restoreWorkspaceSnapshotWithRecovery, } from "./workspace-snapshot.js";
 function mergedInput(context) {
-    return { ...context.args, ...context.options };
+    const input = { ...context.args, ...context.options };
+    return transferMutationStdinTokenPolicy(context.options, input);
 }
 function requiredString(input, key) {
     const value = readRuntimeString(input, key);
@@ -169,4 +171,4 @@ export function runRuntimeSchedulingAction(context) {
     return runRemind(title, input, context.global);
 }
 //# sourceMappingURL=runtime-extended-actions.js.map
-//# debugId=0492d773-2af2-5072-8164-9f8aab536191
+//# debugId=8a3a82a1-9e3d-555f-9111-3c3e19887f75