@unbrained/pm-cli 2026.8.15 → 2026.8.17

package/dist/sdk/context-intent-contracts.js

@@ -5,7 +5,7 @@
  * workspace configuration, and packages.
  */
 
-!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]="fa03d543-ff0d-5556-8558-9bed82838a58")}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]="d09393aa-0253-5ad6-a2fe-245f31b9eb87")}catch(e){}}();
 import { AsyncLocalStorage } from "node:async_hooks";
 import { attachOutputOmissionReceipt } from "./output-projection.js";
 import { encodeQueryCursor } from "./pagination.js";
@@ -25,7 +25,7 @@ export const PM_CONTEXT_INTENT_CONTRACTS = Object.freeze([
             "blockers",
             "activity",
         ],
-        token_budget: 2400,
+        token_budget: 3000,
         source: "core",
     },
     {
@@ -211,10 +211,14 @@ const CONTEXT_INTENT_DEFAULT_APPLIERS = {
                     : ["hierarchy", "blockers", "activity"];
         }
         const tokenBudget = resolveIntentTokenBudget(projected.tokenBudget, contract.token_budget);
-        const calculatedLimit = Math.max(1, Math.floor((tokenBudget - 800) / 500));
-        const derivedLimit = String(explicitTokenBudget ? calculatedLimit : Math.min(20, calculatedLimit));
-        if (projected.limit === undefined)
+        const budgetDerivedLimit = resolveIntentRowBudget("context", contract.intent, tokenBudget, explicitTokenBudget);
+        const requestedLimit = parsePositiveIntentTokenBudget(projected.limit);
+        const derivedLimit = String(requestedLimit === undefined
+            ? budgetDerivedLimit
+            : Math.min(requestedLimit, budgetDerivedLimit));
+        if (projected.limit === undefined || requestedLimit !== undefined) {
             projected.limit = derivedLimit;
+        }
         if (projected.activityLimit === undefined) {
             projected.activityLimit = derivedLimit;
         }
@@ -232,10 +236,13 @@ const CONTEXT_INTENT_DEFAULT_APPLIERS = {
             projected.fields =
                 "id,title,status,type,priority,parent,assignee,risk,blocked_by";
         }
-        if (projected.limit === undefined) {
-            const tokenBudget = resolveIntentTokenBudget(projected.tokenBudget, contract.token_budget);
-            const calculatedLimit = Math.max(2, Math.floor((tokenBudget - 520) / 16));
-            projected.limit = String(explicitTokenBudget ? calculatedLimit : Math.min(100, calculatedLimit));
+        const tokenBudget = resolveIntentTokenBudget(projected.tokenBudget, contract.token_budget);
+        const budgetDerivedLimit = resolveIntentRowBudget("list", contract.intent, tokenBudget, explicitTokenBudget);
+        const requestedLimit = parsePositiveIntentTokenBudget(projected.limit);
+        if (projected.limit === undefined || requestedLimit !== undefined) {
+            projected.limit = String(requestedLimit === undefined
+                ? budgetDerivedLimit
+                : Math.min(requestedLimit, budgetDerivedLimit));
         }
     },
     next: (projected) => {
@@ -248,10 +255,13 @@ const CONTEXT_INTENT_DEFAULT_APPLIERS = {
             projected.fields === undefined) {
             projected.compact = true;
         }
-        if (projected.limit === undefined) {
-            const tokenBudget = resolveIntentTokenBudget(projected.tokenBudget, contract.token_budget);
-            const calculatedLimit = Math.max(2, Math.floor((tokenBudget - 480) / 16));
-            projected.limit = String(explicitTokenBudget ? calculatedLimit : Math.min(100, calculatedLimit));
+        const tokenBudget = resolveIntentTokenBudget(projected.tokenBudget, contract.token_budget);
+        const budgetDerivedLimit = resolveIntentRowBudget("search", contract.intent, tokenBudget, explicitTokenBudget);
+        const requestedLimit = parsePositiveIntentTokenBudget(projected.limit);
+        if (projected.limit === undefined || requestedLimit !== undefined) {
+            projected.limit = String(requestedLimit === undefined
+                ? budgetDerivedLimit
+                : Math.min(requestedLimit, budgetDerivedLimit));
         }
     },
 };
@@ -341,6 +351,23 @@ function resolveIntentTokenBudget(value, declaredBudget) {
     }
     return parsed;
 }
+function resolveIntentRowBudget(command, intent, tokenBudget, explicitTokenBudget) {
+    if (command === "get" || command === "next")
+        return undefined;
+    const contextOrient = command === "context" && intent === "orient";
+    const overhead = command === "context"
+        ? contextOrient
+            ? 1200
+            : 800
+        : command === "list"
+            ? 520
+            : 480;
+    const rowCost = command === "context" ? (contextOrient ? 600 : 500) : 16;
+    const calculatedLimit = Math.max(command === "context" ? 1 : 2, Math.floor((tokenBudget - overhead) / rowCost));
+    return explicitTokenBudget
+        ? calculatedLimit
+        : Math.min(command === "context" ? 20 : 100, calculatedLimit);
+}
 /** Update a receipt until its estimate matches the serialized projection that contains it. */
 function updateContextIntentEstimate(projected, receipt) {
     let measuredTokens = receipt.estimated_tokens;
@@ -495,12 +522,15 @@ export function attachContextIntentReceipt(command, options, result) {
         return result;
     const builtInCommand = normalizedCommand;
     const contract = resolveContextIntentContract(builtInCommand, options.for);
+    const effectiveTokenBudget = resolveIntentTokenBudget(options.tokenBudget ?? options.token_budget, contract.token_budget);
     const receipt = {
         command: builtInCommand,
         intent: contract.intent,
         source: contract.source,
         included_field_groups: [...contract.included_field_groups],
-        token_budget: resolveIntentTokenBudget(options.tokenBudget ?? options.token_budget, contract.token_budget),
+        token_budget: effectiveTokenBudget,
+        declared_token_budget: contract.token_budget,
+        token_budget_override: effectiveTokenBudget - contract.token_budget,
         estimated_tokens: 0,
         within_budget: true,
         degradation: CONTEXT_INTENT_DEGRADATIONS[builtInCommand],
@@ -508,21 +538,17 @@ export function attachContextIntentReceipt(command, options, result) {
         result_omitted: false,
     };
     const resultWithDiagnostics = { ...result };
-    if (builtInCommand === "list" || builtInCommand === "search") {
-        const overhead = builtInCommand === "list" ? 520 : 480;
-        const calculatedLimit = Math.max(2, Math.floor((receipt.token_budget - overhead) / 16));
-        const explicitTokenBudget = parsePositiveIntentTokenBudget(options.tokenBudget ?? options.token_budget) !== undefined;
-        const budgetDerivedLimit = explicitTokenBudget
-            ? calculatedLimit
-            : Math.min(100, calculatedLimit);
-        const hasExplicitLimit = options.limit !== undefined;
+    const budgetDerivedLimit = resolveIntentRowBudget(builtInCommand, contract.intent, receipt.token_budget, parsePositiveIntentTokenBudget(options.tokenBudget ?? options.token_budget) !== undefined);
+    if (budgetDerivedLimit !== undefined) {
+        const effectiveLimit = parsePositiveIntentTokenBudget(options.limit);
+        const explicitLimitBinds = effectiveLimit !== undefined && effectiveLimit < budgetDerivedLimit;
         receipt.budget_derived_limit = budgetDerivedLimit;
-        receipt.binding_constraint = hasExplicitLimit
+        receipt.binding_constraint = explicitLimitBinds
             ? "explicit_limit"
             : "token_budget";
-        receipt.limit_reason = hasExplicitLimit
-            ? "The caller supplied an explicit row limit; the budget-derived limit remains diagnostic."
-            : "The selected intent token budget determines the row ceiling.";
+        receipt.limit_reason = explicitLimitBinds
+            ? "The caller supplied a smaller row limit than the budget-derived ceiling."
+            : "The selected intent token budget constrains the effective row ceiling.";
         resultWithDiagnostics.budget_derived_limit = budgetDerivedLimit;
     }
     let projected = {
@@ -543,20 +569,22 @@ export function attachContextIntentReceipt(command, options, result) {
         receipt.degradation = "budget_row_compaction";
         updateContextIntentEstimate(projected, receipt);
     }
+    receipt.declaration_feasible =
+        receipt.estimated_tokens <= receipt.declared_token_budget;
     if (receipt.estimated_tokens > receipt.token_budget) {
         receipt.degradation = "budget_receipt_only";
-        receipt.declaration_feasible = false;
         receipt.result_omitted = true;
         receipt.within_budget = false;
         projected = {
             budget_exceeded: {
                 omitted_result: true,
-                reason: "declared_budget_infeasible",
-                restore_with: "Increase --token-budget or narrow the request; the unprojected command may be larger.",
+                reason: receipt.token_budget_override === 0
+                    ? "declared_budget_infeasible"
+                    : "effective_budget_infeasible",
+                restore_with: buildContextIntentRecoveryCommand(command, builtInCommand, contract.intent, receipt, resultWithDiagnostics),
             },
             context_intent: receipt,
         };
-        updateContextIntentEstimate(projected, receipt);
     }
     return projected;
 }
@@ -594,6 +622,23 @@ function collapseContinuationMetadata(options, result) {
 function isOutputRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+/** Build a shell-safe bounded retry while retaining required read positionals. */
+function buildContextIntentRecoveryCommand(command, builtInCommand, intent, receipt, result) {
+    const recoveryTarget = builtInCommand === "get" &&
+        isOutputRecord(result.item) &&
+        typeof result.item.id === "string"
+        ? result.item.id
+        : builtInCommand === "search" && typeof result.query === "string"
+            ? result.query
+            : undefined;
+    const recoveryPositional = recoveryTarget === undefined
+        ? ""
+        : ` '${recoveryTarget.replaceAll("'", `'"'"'`)}'`;
+    const boundedRowLimit = builtInCommand === "get"
+        ? ""
+        : ` --limit ${receipt.budget_derived_limit ?? 1}`;
+    return `pm ${command}${recoveryPositional} --for ${intent} --token-budget ${Math.ceil(receipt.estimated_tokens / 100) * 100}${boundedRowLimit}`;
+}
 /** Read one numeric fixed-point estimate from an optional receipt. */
 function receiptEstimate(value, field) {
     if (!isOutputRecord(value))
@@ -641,4 +686,4 @@ export function attachReadOutputContracts(command, options, result) {
     return stabilizeSuppressedRowContractReceipts(Object.fromEntries(Object.entries(projected).filter(([key]) => key !== "row_contract")), options);
 }
 //# sourceMappingURL=context-intent-contracts.js.map
-//# debugId=fa03d543-ff0d-5556-8558-9bed82838a58
+//# debugId=d09393aa-0253-5ad6-a2fe-245f31b9eb87

package/dist/sdk/dependency-flag-validation.d.ts

@@ -1,4 +1,4 @@
-import type { Dependency, ItemFormat } from "../types/index.js";
+import type { Dependency, ItemFormat, RuntimeSchemaSettings } from "../types/index.js";
 import { type RelationshipKindRegistry } from "./relationships.js";
 /** Reject malformed shorthand before item-id prefix normalization can create a dangling graph node. */
 export declare function assertValidBareDependencyFlagValue(value: string, structured: boolean): void;
@@ -8,7 +8,8 @@ export declare function assertValidBareDependencyFlagValue(value: string, struct
  */
 export declare function assertDependencyEdgesAllowed(holderId: string, dependencies: readonly Dependency[] | undefined, registry?: RelationshipKindRegistry): void;
 /**
- * Resolve every newly supplied local dependency before a mutation commits.
+ * Resolve every newly supplied local dependency and enforce declared endpoint
+ * chronology before a mutation commits.
  * Explicit external provenance bypasses workspace lookup, while the opt-in
  * unresolved mode returns durable warning tokens instead of pretending that
  * the graph edge resolved successfully.
@@ -20,4 +21,10 @@ export declare function assertDependencyTargetsResolvable(params: {
     itemFormat: ItemFormat;
     typeToFolder: Record<string, string>;
     allowUnresolved?: boolean;
+    holders?: readonly {
+        id: string;
+        createdAt?: string;
+    }[];
+    schema?: RuntimeSchemaSettings;
+    registry?: RelationshipKindRegistry;
 }): Promise<string[]>;

package/dist/sdk/dependency-flag-validation.js

@@ -1,10 +1,10 @@
 /** @module cli/commands/dependency-flag-validation */
 
-!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]="e7cd6092-ed18-52ea-94a0-03bed42eb858")}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]="f9c9b926-c912-548e-a9c7-64c2c69767cd")}catch(e){}}();
 import { EXIT_CODE } from "../core/shared/constants.js";
 import { PmCliError } from "../core/shared/errors.js";
 import { toErrorMessage } from "../core/shared/primitives.js";
-import { locateItem } from "../core/store/item-store.js";
+import { locateItem, readLocatedItem, } from "../core/store/item-store.js";
 import { isExternalDependencySourceKind } from "./dependency-provenance.js";
 import { resolveWorkspaceRelationshipKindRegistry } from "./graph/assembly.js";
 import { assertRelationshipEdgeAllowed, } from "./relationships.js";
@@ -31,55 +31,121 @@ export function assertDependencyEdgesAllowed(holderId, dependencies, registry =
         }
     }
 }
+async function readDependencyEndpointCreatedAt(located, schema) {
+    return (await readLocatedItem(located, { schema })).document.metadata
+        .created_at;
+}
+async function resolveDependencyHolderCreatedAt(holder, context) {
+    if (holder.createdAt !== undefined)
+        return holder.createdAt;
+    const located = await locateItem(context.pmRoot, holder.id, context.idPrefix, context.itemFormat, context.typeToFolder);
+    return located === null
+        ? undefined
+        : readDependencyEndpointCreatedAt(located, context.schema);
+}
+function dependencyTemporalOrderError(params) {
+    const definition = params.registry.require(params.dependency.kind);
+    return new PmCliError(`${definition.kind} requires source ${params.holder.id} to be created after target ${params.dependency.id}`, EXIT_CODE.USAGE, {
+        code: "dependency_temporal_order_invalid",
+        reason: "source_not_after_target",
+        required: `${params.holder.id}.created_at must be later than ${params.dependency.id}.created_at for ${definition.kind}.`,
+        why: "Chronological recurrence direction must be validated before the relationship is persisted.",
+        source_id: params.holder.id,
+        source_created_at: params.sourceCreatedAt,
+        target_id: params.dependency.id,
+        target_created_at: params.targetCreatedAt,
+        temporal_order: definition.temporalOrder,
+    });
+}
+async function assertTemporalDependencyChronology(params) {
+    const temporalDependencies = params.dependencies.filter((dependency) => params.registry.resolve(dependency.kind)?.temporalOrder ===
+        "source_after_target" &&
+        !params.missingTargets.includes(dependency.id));
+    if (temporalDependencies.length === 0 || params.holders.length === 0)
+        return;
+    const locatedTargets = new Map(params.resolutions.flatMap(({ target, located }) => located === null ? [] : [[target, located]]));
+    const targetCreatedAt = new Map(await Promise.all([...new Set(temporalDependencies.map(({ id }) => id))].map(async (target) => [
+        target,
+        await readDependencyEndpointCreatedAt(locatedTargets.get(target), params.context.schema),
+    ])));
+    for (const holder of params.holders) {
+        const sourceCreatedAt = await resolveDependencyHolderCreatedAt(holder, params.context);
+        if (sourceCreatedAt === undefined)
+            continue;
+        for (const dependency of temporalDependencies) {
+            const targetTimestamp = targetCreatedAt.get(dependency.id);
+            const sourceTime = Date.parse(sourceCreatedAt);
+            const targetTime = Date.parse(targetTimestamp);
+            if (Number.isFinite(sourceTime) &&
+                Number.isFinite(targetTime) &&
+                sourceTime > targetTime) {
+                continue;
+            }
+            throw dependencyTemporalOrderError({
+                holder,
+                dependency,
+                sourceCreatedAt,
+                targetCreatedAt: targetTimestamp,
+                registry: params.registry,
+            });
+        }
+    }
+}
 /**
- * Resolve every newly supplied local dependency before a mutation commits.
+ * Resolve every newly supplied local dependency and enforce declared endpoint
+ * chronology before a mutation commits.
  * Explicit external provenance bypasses workspace lookup, while the opt-in
  * unresolved mode returns durable warning tokens instead of pretending that
  * the graph edge resolved successfully.
  */
 export async function assertDependencyTargetsResolvable(params) {
+    const registry = params.registry ?? resolveWorkspaceRelationshipKindRegistry();
+    const localDependencies = (params.dependencies ?? []).filter((dependency) => !isExternalDependencySourceKind(dependency.source_kind));
     const localTargets = [
-        ...new Set((params.dependencies ?? [])
-            .filter((dependency) => !isExternalDependencySourceKind(dependency.source_kind))
-            .map((dependency) => dependency.id)),
+        ...new Set(localDependencies.map((dependency) => dependency.id)),
     ];
     const resolutions = await Promise.all(localTargets.map(async (target) => ({
         target,
         located: await locateItem(params.pmRoot, target, params.idPrefix, params.itemFormat, params.typeToFolder),
     })));
-    const targets = resolutions
+    const missingTargets = resolutions
         .filter(({ located }) => located === null)
         .map(({ target }) => target)
         .sort((left, right) => (left < right ? -1 : 1));
-    if (targets.length === 0) {
-        return [];
-    }
-    if (params.allowUnresolved === true) {
-        return targets.map((target) => `dependency_target_unresolved:${target}`);
+    if (missingTargets.length > 0 && params.allowUnresolved !== true) {
+        throw new PmCliError(`Dependency target${missingTargets.length === 1 ? "" : "s"} not found: ${missingTargets.join(", ")}`, EXIT_CODE.NOT_FOUND, {
+            code: "dependency_target_not_found",
+            reason: "unresolved_local_dependency",
+            required: "Every local dependency target must exist before the edge is committed.",
+            why: "Fail-fast target resolution prevents dangling graph nodes and preserves reliable traversal semantics.",
+            unresolved_targets: missingTargets,
+            examples: [
+                "--dep id=<existing-item-id>,kind=related",
+                "--dep id=<external-id>,kind=related,source_kind=external",
+                "--allow-unresolved-deps --dep id=<future-item-id>,kind=related",
+            ],
+            nextSteps: [
+                `Create or correct ${missingTargets.length === 1 ? "the target" : "the targets"}, then retry the mutation.`,
+                "Use source_kind=external for a cross-workspace reference.",
+                "Use --allow-unresolved-deps only when the dangling local edge is intentional.",
+            ],
+            recovery: {
+                recovery_mode: "compact",
+                missing: missingTargets,
+                suggested_flags: ["--allow-unresolved-deps"],
+                suggested_retry: `pm search "${missingTargets[0]}" --limit 10`,
+            },
+        });
     }
-    throw new PmCliError(`Dependency target${targets.length === 1 ? "" : "s"} not found: ${targets.join(", ")}`, EXIT_CODE.NOT_FOUND, {
-        code: "dependency_target_not_found",
-        reason: "unresolved_local_dependency",
-        required: "Every local dependency target must exist before the edge is committed.",
-        why: "Fail-fast target resolution prevents dangling graph nodes and preserves reliable traversal semantics.",
-        unresolved_targets: targets,
-        examples: [
-            "--dep id=<existing-item-id>,kind=related",
-            "--dep id=<external-id>,kind=related,source_kind=external",
-            "--allow-unresolved-deps --dep id=<future-item-id>,kind=related",
-        ],
-        nextSteps: [
-            `Create or correct ${targets.length === 1 ? "the target" : "the targets"}, then retry the mutation.`,
-            "Use source_kind=external for a cross-workspace reference.",
-            "Use --allow-unresolved-deps only when the dangling local edge is intentional.",
-        ],
-        recovery: {
-            recovery_mode: "compact",
-            missing: targets,
-            suggested_flags: ["--allow-unresolved-deps"],
-            suggested_retry: `pm search "${targets[0]}" --limit 10`,
-        },
+    await assertTemporalDependencyChronology({
+        dependencies: localDependencies,
+        missingTargets,
+        resolutions,
+        holders: params.holders ?? [],
+        registry,
+        context: params,
     });
+    return missingTargets.map((target) => `dependency_target_unresolved:${target}`);
 }
 //# sourceMappingURL=dependency-flag-validation.js.map
-//# debugId=e7cd6092-ed18-52ea-94a0-03bed42eb858
+//# debugId=f9c9b926-c912-548e-a9c7-64c2c69767cd

package/dist/sdk/environment/host-environment-errors.js

@@ -5,7 +5,8 @@
  * leaking local paths or swallowing genuine implementation defects.
  */
 
-!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]="41fec0f3-5cc8-5007-a896-f8d8b83ae4f5")}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]="679bb2a0-aada-586e-a831-591266be2ee0")}catch(e){}}();
+import { constants as osConstants } from "node:os";
 import { EXIT_CODE } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
 const HOST_ENVIRONMENT_FAULTS = new Map([
@@ -75,6 +76,16 @@ const HOST_ENVIRONMENT_FAULTS = new Map([
     ],
 ]);
 const OPERATION_PATTERN = /^[a-z][a-z0-9_]{0,63}$/u;
+const HOST_ENVIRONMENT_ERRNO_NAMES = new Map([
+    [osConstants.errno.EACCES, "EACCES"],
+    [osConstants.errno.EDQUOT, "EDQUOT"],
+    [osConstants.errno.EMFILE, "EMFILE"],
+    [osConstants.errno.ENFILE, "ENFILE"],
+    [osConstants.errno.ENOMEM, "ENOMEM"],
+    [osConstants.errno.ENOSPC, "ENOSPC"],
+    [osConstants.errno.EPERM, "EPERM"],
+    [osConstants.errno.EROFS, "EROFS"],
+]);
 const HOST_ENVIRONMENT_FAULT_CODES = {
     capacity: { code: "host_environment_capacity_fault" },
     permission: { code: "host_environment_permission_fault" },
@@ -82,12 +93,19 @@ const HOST_ENVIRONMENT_FAULT_CODES = {
 };
 /** Return a declared host errno only when it represents recoverable environment state. */
 export function classifyHostEnvironmentFault(error) {
-    if (typeof error !== "object" || error === null || !("code" in error))
+    if (typeof error !== "object" || error === null) {
         return null;
-    const code = error.code;
-    return typeof code === "string" && HOST_ENVIRONMENT_FAULTS.has(code)
-        ? code
-        : null;
+    }
+    const errorRecord = error;
+    if (typeof errorRecord.code === "string" &&
+        HOST_ENVIRONMENT_FAULTS.has(errorRecord.code)) {
+        return errorRecord.code;
+    }
+    if (typeof errorRecord.errno !== "number" ||
+        !Number.isInteger(errorRecord.errno)) {
+        return null;
+    }
+    return HOST_ENVIRONMENT_ERRNO_NAMES.get(Math.abs(errorRecord.errno)) ?? null;
 }
 /** Translate one known host fault into a stable path-redacted SDK refusal. */
 export function translateHostEnvironmentFault(error, operation, options = {}) {
@@ -121,4 +139,4 @@ export async function withHostEnvironmentBoundary(operation, run, options = {})
     }
 }
 //# sourceMappingURL=host-environment-errors.js.map
-//# debugId=41fec0f3-5cc8-5007-a896-f8d8b83ae4f5
+//# debugId=679bb2a0-aada-586e-a831-591266be2ee0

package/dist/sdk/generated/generated-error-code-catalog-part-1.js

@@ -1,6 +1,6 @@
 /** Generated partition 1 of the exhaustive error-code catalog. */
 
-!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]="3891c17c-c79d-54d4-8b62-da8fe9c1eaf4")}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]="d188630b-bf34-53f4-a93e-78698013994e")}catch(e){}}();
 export const PM_ERROR_CODE_CATALOG_PART_1 = [
     {
         code: "acceptance_criteria_mutation_conflict",
@@ -470,6 +470,18 @@ export const PM_ERROR_CODE_CATALOG_PART_1 = [
         canonical_code: "dependency_target_not_found",
         aliases: [],
     },
+    {
+        code: "dependency_temporal_order_invalid",
+        meaning: "Dependency temporal order invalid condition.",
+        stability: "provisional",
+        exit_code: 2,
+        class: "usage",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["sdk/dependency-flag-validation.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "dependency_temporal_order_invalid",
+        aliases: [],
+    },
     {
         code: "duplicate_command",
         meaning: "Duplicate command condition.",
@@ -806,6 +818,42 @@ export const PM_ERROR_CODE_CATALOG_PART_1 = [
         canonical_code: "github_source_entry_unbuilt",
         aliases: [],
     },
+    {
+        code: "history_author_acknowledge_plan_conflict",
+        meaning: "History author acknowledge plan conflict condition.",
+        stability: "provisional",
+        exit_code: 4,
+        class: "conflict",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["sdk/author-attribution.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "history_author_acknowledge_plan_conflict",
+        aliases: [],
+    },
+    {
+        code: "history_author_acknowledge_plan_fingerprint_required",
+        meaning: "History author acknowledge plan fingerprint required condition.",
+        stability: "provisional",
+        exit_code: 2,
+        class: "usage",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["sdk/author-attribution.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "history_author_acknowledge_plan_fingerprint_required",
+        aliases: [],
+    },
+    {
+        code: "history_author_acknowledge_preview_limit_invalid",
+        meaning: "History author acknowledge preview limit invalid condition.",
+        stability: "provisional",
+        exit_code: 2,
+        class: "usage",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["sdk/author-attribution.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "history_author_acknowledge_preview_limit_invalid",
+        aliases: [],
+    },
     {
         code: "history_author_acknowledge_required_values_missing",
         meaning: "History author acknowledge required values missing condition.",
@@ -1592,6 +1640,18 @@ export const PM_ERROR_CODE_CATALOG_PART_1 = [
         canonical_code: "manifest_capabilities_absent",
         aliases: [],
     },
+    {
+        code: "manifest_unknown_key",
+        meaning: "Manifest unknown key condition.",
+        stability: "provisional",
+        exit_code: 2,
+        class: "usage",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["sdk/compose.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "manifest_unknown_key",
+        aliases: [],
+    },
     {
         code: "merge_conflict_markers_detected",
         meaning: "Merge conflict markers detected condition.",
@@ -1604,18 +1664,6 @@ export const PM_ERROR_CODE_CATALOG_PART_1 = [
         canonical_code: "merge_conflict_markers_detected",
         aliases: ["history_merge_conflict_markers_detected"],
     },
-    {
-        code: "merge_decisions_unreviewed",
-        meaning: "Merge decisions unreviewed condition.",
-        stability: "provisional",
-        exit_code: 1,
-        class: "generic_failure",
-        recovery: "Inspect the structured error guidance and retry the suggested command.",
-        sources: ["core/diagnostics/remediation.ts"],
-        emitting_commands: ["*"],
-        canonical_code: "merge_decisions_unreviewed",
-        aliases: [],
-    },
 ];
 //# sourceMappingURL=generated-error-code-catalog-part-1.js.map
-//# debugId=3891c17c-c79d-54d4-8b62-da8fe9c1eaf4
+//# debugId=d188630b-bf34-53f4-a93e-78698013994e

package/dist/sdk/generated/generated-error-code-catalog-part-2.js

@@ -1,7 +1,19 @@
 /** Generated partition 2 of the exhaustive error-code catalog. */
 
-!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]="5d64a86d-6ba6-5bbe-a83a-9703690a851e")}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]="43b9f478-8b90-5644-aa06-b6787514ffa1")}catch(e){}}();
 export const PM_ERROR_CODE_CATALOG_PART_2 = [
+    {
+        code: "merge_decisions_unreviewed",
+        meaning: "Merge decisions unreviewed condition.",
+        stability: "provisional",
+        exit_code: 1,
+        class: "generic_failure",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["core/diagnostics/remediation.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "merge_decisions_unreviewed",
+        aliases: [],
+    },
     {
         code: "merge_git_config_unwritable",
         meaning: "Merge git config unwritable condition.",
@@ -207,6 +219,18 @@ export const PM_ERROR_CODE_CATALOG_PART_2 = [
         canonical_code: "no_update_fields",
         aliases: [],
     },
+    {
+        code: "no_version_bounds_declared",
+        meaning: "No version bounds declared condition.",
+        stability: "provisional",
+        exit_code: 1,
+        class: "generic_failure",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["sdk/compose.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "no_version_bounds_declared",
+        aliases: [],
+    },
     {
         code: "npm_package_not_found",
         meaning: "Npm package not found condition.",
@@ -774,6 +798,18 @@ export const PM_ERROR_CODE_CATALOG_PART_2 = [
         canonical_code: "tracker_root_not_directory",
         aliases: [],
     },
+    {
+        code: "tracker_root_unreadable",
+        meaning: "Tracker root unreadable condition.",
+        stability: "provisional",
+        exit_code: 1,
+        class: "generic_failure",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["core/store/item-store.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "tracker_root_unreadable",
+        aliases: [],
+    },
     {
         code: "type_duplicate",
         meaning: "Type duplicate condition.",
@@ -1507,6 +1543,18 @@ export const PM_ERROR_CODE_CATALOG_PART_2 = [
         canonical_code: "workflow_type_unknown",
         aliases: [],
     },
+    {
+        code: "workspace_history_chain_invalid",
+        meaning: "Workspace history chain invalid condition.",
+        stability: "provisional",
+        exit_code: 4,
+        class: "conflict",
+        recovery: "Inspect the structured error guidance and retry the suggested command.",
+        sources: ["core/history/workspace-history.ts"],
+        emitting_commands: ["*"],
+        canonical_code: "workspace_history_chain_invalid",
+        aliases: [],
+    },
     {
         code: "workspace_history_state_conflict",
         meaning: "Workspace history state conflict condition.",
@@ -1629,4 +1677,4 @@ export const PM_ERROR_CODE_CATALOG_PART_2 = [
     },
 ];
 //# sourceMappingURL=generated-error-code-catalog-part-2.js.map
-//# debugId=5d64a86d-6ba6-5bbe-a83a-9703690a851e
+//# debugId=43b9f478-8b90-5644-aa06-b6787514ffa1