@unbrained/pm-cli 2026.8.22 → 2026.8.24

package/dist/core/shared/author.js

@@ -4,7 +4,7 @@
  * Provides shared primitives and utilities for Author.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e0ab2d6f-0925-540d-8d24-a7f0687b4bf0")}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]="8d89d381-5c6e-5f96-ba03-298fc6db9bba")}catch(e){}}();
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
@@ -50,7 +50,11 @@ export const BUILTIN_HARNESS_SIGNAL_DESCRIPTORS = [
             effort: ["CODEX_REASONING_EFFORT", "CODEX_EFFORT"],
             role: ["CODEX_SESSION_ROLE"],
         },
-        provenance_resolvers: { version: "ai_agent_version" },
+        provenance_resolvers: {
+            model: "codex_session_file",
+            effort: "codex_session_file",
+            version: "ai_agent_version",
+        },
         provenance_unavailable_dimensions: ["topic"],
         argv_markers: ["codex"],
         client_names: ["codex"],
@@ -108,8 +112,61 @@ export const BUILTIN_HARNESS_SIGNAL_DESCRIPTORS = [
         client_names: [],
     },
 ];
-const registeredHarnessSignalDescriptors = new Map();
+const PROVENANCE_PROBE_POLICY = Object.freeze({
+    max_bytes: 1_048_576,
+    max_lines: 4_096,
+    network_access: false,
+    subprocess_access: false,
+});
+const CODEX_PROVENANCE_PROBE_POLICY = Object.freeze({
+    ...PROVENANCE_PROBE_POLICY,
+    max_bytes: 4_194_304,
+});
 const HARNESS_NAMESPACE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+function buildBuiltinProvenanceAdapter(descriptor) {
+    const unavailableDimensions = normalizeHarnessSignalDescriptor(descriptor).provenance_unavailable_dimensions;
+    const dimensions = new Set([
+        "model",
+        "version",
+        ...Object.keys(descriptor.provenance_environment_keys ?? {}),
+        ...Object.keys(descriptor.provenance_resolvers ?? {}),
+    ]);
+    return Object.freeze({
+        contract_version: 1,
+        adapter_version: "v1",
+        priority: 0,
+        harness: descriptor.harness,
+        descriptor,
+        supported_dimensions: Object.freeze([...dimensions].sort()),
+        native_sources: Object.freeze([
+            "environment",
+            "argv",
+            "mcp_client",
+            ...(Object.values(descriptor.provenance_resolvers ?? {}).some((resolver) => resolver?.endsWith("session_file"))
+                ? ["session_file"]
+                : []),
+        ]),
+        probe_policy: descriptor.harness === "codex"
+            ? CODEX_PROVENANCE_PROBE_POLICY
+            : PROVENANCE_PROBE_POLICY,
+        normalization: Object.freeze({
+            model_family: "v1",
+            effort: "v1",
+            preserve_raw: true,
+        }),
+        confidence: "high",
+        waivers: Object.freeze(Object.fromEntries(unavailableDimensions.map((dimension) => [
+            dimension,
+            "Harness does not expose this dimension.",
+        ]))),
+    });
+}
+/** Built-in versioned adapters for supported interactive agent harnesses. */
+export const BUILTIN_AGENT_PROVENANCE_ADAPTERS = Object.freeze(BUILTIN_HARNESS_SIGNAL_DESCRIPTORS.filter((descriptor) => descriptor.harness !== "ci")
+    .map(buildBuiltinProvenanceAdapter)
+    .sort((left, right) => left.harness.localeCompare(right.harness)));
+const registeredAgentProvenanceAdapters = new Map();
+const registeredHarnessSignalDescriptors = new Map();
 function nonBlank(value) {
     const trimmed = typeof value === "string" ? value.trim() : undefined;
     return trimmed && trimmed.length > 0 ? trimmed : undefined;
@@ -149,7 +206,8 @@ function normalizeHarnessSignalDescriptor(descriptor) {
             .filter((entry) => typeof entry[0] === "string" &&
             HARNESS_NAMESPACE_PATTERN.test(entry[0]) &&
             (entry[1] === "ai_agent_version" ||
-                entry[1] === "claude_session_file"))),
+                entry[1] === "claude_session_file" ||
+                entry[1] === "codex_session_file"))),
         provenance_unavailable_dimensions: boundedUniqueStrings(descriptor.provenance_unavailable_dimensions).map((value) => value.toLowerCase()),
         argv_markers: boundedUniqueStrings(descriptor.argv_markers).map((value) => value.toLowerCase()),
         client_names: boundedUniqueStrings(descriptor.client_names).map((value) => value.toLowerCase()),
@@ -168,8 +226,16 @@ function literalSignalMatches(value, marker) {
     return segments.includes(marker) || value.trim().toLowerCase() === marker;
 }
 function currentHarnessSignalDescriptors(localDescriptors = []) {
+    const adapterDescriptors = new Map(BUILTIN_HARNESS_SIGNAL_DESCRIPTORS.filter((descriptor) => descriptor.harness !== "ci").map((descriptor) => [
+        descriptor.harness,
+        normalizeHarnessSignalDescriptor(descriptor),
+    ]));
+    for (const { adapter } of registeredAgentProvenanceAdapters.values()) {
+        adapterDescriptors.set(adapter.harness, normalizeHarnessSignalDescriptor(adapter.descriptor));
+    }
     const descriptors = [
-        ...NORMALIZED_BUILTIN_HARNESS_SIGNAL_DESCRIPTORS,
+        ...adapterDescriptors.values(),
+        ...NORMALIZED_BUILTIN_HARNESS_SIGNAL_DESCRIPTORS.filter((descriptor) => descriptor.harness === "ci"),
         ...[...registeredHarnessSignalDescriptors.values()].map((entry) => entry.descriptor),
         ...(workspaceHarnessSignalsStorage.getStore()?.descriptors ?? []),
         ...localDescriptors.map(normalizeHarnessSignalDescriptor),
@@ -243,9 +309,10 @@ function boundedProvenanceValue(provenance, dimension) {
     return nonBlank(provenance?.[dimension])?.slice(0, 256);
 }
 const MAX_PROVENANCE_PROBE_BYTES = 1_048_576;
+const MAX_CODEX_PROVENANCE_PROBE_BYTES = 4_194_304;
+const codexProvenanceSnapshotCache = new Map();
+const EMPTY_CODEX_PROVENANCE_SNAPSHOT = Object.freeze({});
 function parseClaudeProvenanceLine(line, dimension) {
-    if (line.length === 0 || line.length > 262_144)
-        return undefined;
     let parsed;
     try {
         parsed = JSON.parse(line);
@@ -253,8 +320,6 @@ function parseClaudeProvenanceLine(line, dimension) {
     catch {
         return undefined;
     }
-    if (typeof parsed !== "object" || parsed === null)
-        return undefined;
     const record = parsed;
     const message = typeof record.message === "object" && record.message !== null
         ? record.message
@@ -273,22 +338,140 @@ function readClaudeSessionProvenance(dimension, signals, env) {
         const file = fs.openSync(sessionPath, "r");
         try {
             const size = fs.fstatSync(file).size;
-            const length = Math.min(size, MAX_PROVENANCE_PROBE_BYTES);
-            const buffer = Buffer.alloc(length);
-            fs.readSync(file, buffer, 0, length, Math.max(0, size - length));
-            const lines = buffer.toString("utf8").split("\n").reverse();
-            for (const line of lines.slice(0, 4_096)) {
+            const tailLength = Math.min(size, MAX_PROVENANCE_PROBE_BYTES);
+            const tail = Buffer.alloc(tailLength);
+            fs.readSync(file, tail, 0, tailLength, Math.max(0, size - tailLength));
+            const lines = tail.toString("utf8").split("\n").reverse().slice(0, 4_096);
+            for (const line of lines) {
+                if (line.length === 0 || line.length > 262_144)
+                    continue;
                 const value = parseClaudeProvenanceLine(line, dimension);
                 if (value)
                     return value;
             }
+        }
+        finally {
+            fs.closeSync(file);
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function findCodexSessionFile(root, session) {
+    let visited = 0;
+    const visit = (directory, depth) => {
+        if (depth > 4 || visited >= 512)
             return undefined;
+        let entries;
+        try {
+            entries = fs
+                .readdirSync(directory, { withFileTypes: true })
+                .sort((left, right) => right.name.localeCompare(left.name));
+        }
+        catch {
+            return undefined;
+        }
+        for (const entry of entries) {
+            visited += 1;
+            if (visited > 512)
+                return undefined;
+            const entryPath = path.join(directory, entry.name);
+            if (entry.isFile() && entry.name.endsWith(`-${session}.jsonl`)) {
+                return entryPath;
+            }
+            if (entry.isDirectory()) {
+                const found = visit(entryPath, depth + 1);
+                if (found)
+                    return found;
+            }
+        }
+        return undefined;
+    };
+    return visit(root, 0);
+}
+function codexProvenanceWindows(size) {
+    if (size <= MAX_CODEX_PROVENANCE_PROBE_BYTES) {
+        return [{ offset: 0, length: size }];
+    }
+    const halfBudget = Math.floor(MAX_CODEX_PROVENANCE_PROBE_BYTES / 2);
+    return [
+        { offset: size - halfBudget, length: halfBudget },
+        { offset: 0, length: halfBudget },
+    ];
+}
+function mergeCodexTurnContext(snapshot, line) {
+    if (line.length === 0 || line.length > 262_144)
+        return;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return;
+    }
+    const record = parsed;
+    if (record.type !== "turn_context")
+        return;
+    const payload = typeof record.payload === "object" && record.payload !== null
+        ? record.payload
+        : undefined;
+    snapshot.model ??= nonBlank(payload?.model)?.slice(0, 256);
+    snapshot.effort ??= nonBlank(payload?.effort)?.slice(0, 256);
+}
+function readCodexProvenanceSnapshot(file, size) {
+    const snapshot = {};
+    let linesRemaining = 4_096;
+    for (const window of codexProvenanceWindows(size)) {
+        const buffer = Buffer.alloc(window.length);
+        fs.readSync(file, buffer, 0, window.length, window.offset);
+        const lines = buffer
+            .toString("utf8")
+            .split("\n")
+            .reverse()
+            .slice(0, linesRemaining);
+        linesRemaining -= lines.length;
+        for (const line of lines) {
+            mergeCodexTurnContext(snapshot, line);
+            if (snapshot.model && snapshot.effort)
+                break;
+        }
+        if ((snapshot.model && snapshot.effort) || linesRemaining <= 0)
+            break;
+    }
+    return snapshot;
+}
+function readCodexSessionProvenance(dimension, signals, env) {
+    const session = nonBlank(env.CODEX_THREAD_ID);
+    if (!session || !/^[A-Za-z0-9_-]{1,128}$/u.test(session))
+        return undefined;
+    const sessionsRoot = path.join(signals.home_dir ?? os.homedir(), ".codex", "sessions");
+    const cacheKey = `${sessionsRoot}\0${session}`;
+    const cached = codexProvenanceSnapshotCache.get(cacheKey);
+    if (cached)
+        return cached[dimension];
+    const sessionPath = findCodexSessionFile(sessionsRoot, session);
+    if (!sessionPath) {
+        codexProvenanceSnapshotCache.set(cacheKey, EMPTY_CODEX_PROVENANCE_SNAPSHOT);
+        return undefined;
+    }
+    try {
+        const file = fs.openSync(sessionPath, "r");
+        try {
+            const size = fs.fstatSync(file).size;
+            const snapshot = readCodexProvenanceSnapshot(file, size);
+            codexProvenanceSnapshotCache.set(cacheKey, snapshot);
+            return snapshot[dimension];
         }
         finally {
             fs.closeSync(file);
         }
     }
     catch {
+        codexProvenanceSnapshotCache.set(cacheKey, EMPTY_CODEX_PROVENANCE_SNAPSHOT);
         return undefined;
     }
 }
@@ -303,6 +486,9 @@ function resolveProvenanceProbe(dimension, signals, env, descriptor) {
     if (resolver === "claude_session_file") {
         return readClaudeSessionProvenance(dimension, signals, env);
     }
+    if (resolver === "codex_session_file") {
+        return readCodexSessionProvenance(dimension, signals, env);
+    }
     if (resolver === "ai_agent_version") {
         const value = nonBlank(env.AI_AGENT);
         if (!value ||
@@ -320,7 +506,9 @@ function provenanceResolverHasInput(resolver, descriptor, env) {
         const value = nonBlank(env.AI_AGENT);
         return (value !== undefined && literalSignalMatches(value, descriptor.harness));
     }
-    return nonBlank(env.CLAUDE_CODE_SESSION_ID) !== undefined;
+    return resolver === "codex_session_file"
+        ? nonBlank(env.CODEX_THREAD_ID) !== undefined
+        : nonBlank(env.CLAUDE_CODE_SESSION_ID) !== undefined;
 }
 function effectiveHarnessDetectionSignals(signals) {
     if (signals)
@@ -482,6 +670,135 @@ export function registerHarnessSignalDescriptors(descriptors) {
         }
     };
 }
+function normalizeAgentProvenanceAdapter(adapter) {
+    const descriptor = normalizeHarnessSignalDescriptor(adapter.descriptor);
+    const harness = adapter.harness.trim().toLowerCase();
+    if (adapter.contract_version !== 1) {
+        throw new Error(`Unsupported provenance adapter contract for "${harness}": ${adapter.contract_version}`);
+    }
+    if (descriptor.harness !== harness) {
+        throw new Error(`Provenance adapter harness "${harness}" does not match descriptor "${descriptor.harness}".`);
+    }
+    const adapterVersion = nonBlank(adapter.adapter_version)?.slice(0, 64);
+    if (!adapterVersion) {
+        throw new Error(`Provenance adapter "${harness}" requires a version.`);
+    }
+    if (!Number.isSafeInteger(adapter.priority)) {
+        throw new Error(`Provenance adapter "${harness}" requires an integer priority.`);
+    }
+    if (adapter.probe_policy.network_access !== false ||
+        adapter.probe_policy.subprocess_access !== false ||
+        adapter.probe_policy.max_bytes > MAX_CODEX_PROVENANCE_PROBE_BYTES ||
+        adapter.probe_policy.max_lines > 4_096) {
+        throw new Error(`Provenance adapter "${harness}" exceeds the bounded local probe policy.`);
+    }
+    return Object.freeze({
+        ...adapter,
+        adapter_version: adapterVersion,
+        harness,
+        descriptor,
+        supported_dimensions: Object.freeze(boundedUniqueStrings(adapter.supported_dimensions)
+            .map((dimension) => dimension.toLowerCase())
+            .sort()),
+        native_sources: Object.freeze([...new Set(adapter.native_sources)]),
+        probe_policy: Object.freeze({ ...adapter.probe_policy }),
+        normalization: Object.freeze({ ...adapter.normalization }),
+        ...(adapter.waivers
+            ? {
+                waivers: Object.freeze(Object.fromEntries(Object.entries(adapter.waivers)
+                    .slice(0, 32)
+                    .map(([dimension, reason]) => [
+                    dimension.slice(0, 64),
+                    reason.slice(0, 256),
+                ]))),
+            }
+            : {}),
+    });
+}
+/** Return the effective built-in or explicitly higher-priority package adapters. */
+export function listAgentProvenanceAdapters() {
+    const effective = new Map(BUILTIN_AGENT_PROVENANCE_ADAPTERS.map((adapter) => [
+        adapter.harness,
+        adapter,
+    ]));
+    for (const { adapter } of registeredAgentProvenanceAdapters.values()) {
+        effective.set(adapter.harness, adapter);
+    }
+    return Object.freeze([...effective.values()].sort((left, right) => left.harness.localeCompare(right.harness)));
+}
+/**
+ * Register package adapters until disposal. Replacing a built-in requires an
+ * explicitly greater priority; equal-priority ambiguity fails closed.
+ */
+export function registerAgentProvenanceAdapters(adapters) {
+    const normalized = adapters.map(normalizeAgentProvenanceAdapter);
+    const builtins = new Map(BUILTIN_AGENT_PROVENANCE_ADAPTERS.map((adapter) => [
+        adapter.harness,
+        adapter,
+    ]));
+    const seen = new Set();
+    for (const adapter of normalized) {
+        if (seen.has(adapter.harness)) {
+            throw new Error(`Provenance adapter collision for "${adapter.harness}".`);
+        }
+        const builtin = builtins.get(adapter.harness);
+        if (builtin && adapter.priority <= builtin.priority) {
+            throw new Error(`Provenance adapter override for "${adapter.harness}" requires priority greater than ${builtin.priority}.`);
+        }
+        const registered = registeredAgentProvenanceAdapters.get(adapter.harness);
+        if (registered &&
+            JSON.stringify(registered.adapter) !== JSON.stringify(adapter)) {
+            throw new Error(`Provenance adapter collision for "${adapter.harness}".`);
+        }
+        seen.add(adapter.harness);
+    }
+    for (const adapter of normalized) {
+        const registered = registeredAgentProvenanceAdapters.get(adapter.harness);
+        registeredAgentProvenanceAdapters.set(adapter.harness, {
+            adapter,
+            registrations: (registered?.registrations ?? 0) + 1,
+        });
+    }
+    let active = true;
+    return () => {
+        if (!active)
+            return;
+        active = false;
+        for (const adapter of normalized) {
+            const registered = registeredAgentProvenanceAdapters.get(adapter.harness);
+            if (!registered || registered.registrations <= 1) {
+                registeredAgentProvenanceAdapters.delete(adapter.harness);
+            }
+            else {
+                registered.registrations -= 1;
+            }
+        }
+    };
+}
+/** Normalize model-family or effort vocabulary while retaining the raw value. */
+export function normalizeAgentProvenanceAdapterValue(dimension, value) {
+    const raw = value.trim().slice(0, 256);
+    let normalized = raw.toLowerCase();
+    if (dimension === "model") {
+        const family = /^(gpt-\d+(?:\.\d+)?)/u.exec(normalized)?.[1];
+        if (family)
+            normalized = family;
+    }
+    else {
+        normalized = normalized.replaceAll(/[_\s-]+/gu, "");
+        const effortAliases = {
+            minimal: "low",
+            low: "low",
+            medium: "medium",
+            high: "high",
+            xhigh: "xhigh",
+            max: "max",
+            ultra: "ultra",
+        };
+        normalized = effortAliases[normalized] ?? normalized;
+    }
+    return { raw, normalized, vocabulary: "v1" };
+}
 /** Run one invocation with host-provided detection signals available downstream. */
 export function runWithHarnessDetectionSignals(signals, callback) {
     return harnessDetectionStorage.run(signals, callback);
@@ -713,4 +1030,4 @@ export function resolveAuthor(candidate, fallback) {
     return identity.author;
 }
 //# sourceMappingURL=author.js.map
-//# debugId=e0ab2d6f-0925-540d-8d24-a7f0687b4bf0
+//# debugId=8d89d381-5c6e-5f96-ba03-298fc6db9bba

package/dist/core/shared/constants.js

@@ -1,5 +1,5 @@
 
-!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]="70cce114-b8a7-5770-ae42-eec473515709")}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]="4bb01c24-e203-5f9f-ba23-25888bd7f6ea")}catch(e){}}();
 import { createDefaultExtensionGovernancePolicy } from "../extensions/extension-types.js";
 export { ITEM_METADATA_KEY_ORDER, ITEM_PROJECT_CONTEXT_KEYS, } from "./item-metadata-contract.js";
 /**
@@ -232,6 +232,7 @@ export const SETTINGS_DEFAULTS = {
     },
     testing: {
         record_results_to_items: false,
+        allow_untrusted_linked_tests: false,
     },
     telemetry: {
         enabled: true,
@@ -402,4 +403,4 @@ export function resolveTelemetryErrorCategory(errorCode) {
     return "unknown";
 }
 //# sourceMappingURL=constants.js.map
-//# debugId=70cce114-b8a7-5770-ae42-eec473515709
+//# debugId=4bb01c24-e203-5f9f-ba23-25888bd7f6ea

package/dist/core/store/settings-validator.d.ts

@@ -69,6 +69,7 @@ export interface ParsedSettings {
     /** Value that configures or reports testing for this contract. */
     testing?: {
         record_results_to_items: boolean;
+        allow_untrusted_linked_tests?: boolean;
     };
     /** Value that configures or reports telemetry for this contract. */
     telemetry?: {

package/dist/core/store/settings-validator.js

@@ -12,7 +12,7 @@
  * byte-identical to the previous implementation.
  */
 
-!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]="8883f930-193e-5133-835a-f15b1b62f6be")}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]="0e135793-d2ed-505b-b73e-6db55218d8af")}catch(e){}}();
 import { GOVERNANCE_PRESET_VALUES, RUNTIME_FIELD_COMMAND_VALUES, RUNTIME_FIELD_TYPE_VALUES, RUNTIME_STATUS_ROLE_VALUES, RUNTIME_UNKNOWN_FIELD_POLICY_VALUES, } from "../../types.js";
 // Generic over `never` so it is assignable to every `Outcome<T>`.
 const FAIL = { ok: false };
@@ -326,7 +326,10 @@ const settingsCheck = vObject({
     })),
     governance: governanceSettings,
     workflow: vOptional(vObject({ definition_of_done: vArray(vString) })),
-    testing: vOptional(vObject({ record_results_to_items: vBoolean })),
+    testing: vOptional(vObject({
+        record_results_to_items: vBoolean,
+        allow_untrusted_linked_tests: vOptional(vBoolean),
+    })),
     telemetry: vOptional(vObject({
         enabled: vBoolean,
         first_run_prompt_completed: vOptional(vBoolean),
@@ -415,4 +418,4 @@ export function validateSettings(raw) {
     return { success: true, data: result.value };
 }
 //# sourceMappingURL=settings-validator.js.map
-//# debugId=8883f930-193e-5133-835a-f15b1b62f6be
+//# debugId=0e135793-d2ed-505b-b73e-6db55218d8af

package/dist/core/store/settings.js

@@ -4,7 +4,7 @@
  * Reads and writes tracker storage with format-aware helpers for Settings.
  */
 
-!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]="67bf189e-e816-536d-9051-589a2e468423")}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]="5b95183e-9fd3-55cf-9059-8736f692e96e")}catch(e){}}();
 import { validateSettings } from "./settings-validator.js";
 import { runActiveOnReadHooks, runActiveOnWriteHooks, } from "../extensions/index.js";
 import { GOVERNANCE_PRESET_DEFAULTS, SETTINGS_DEFAULTS, } from "../shared/constants.js";
@@ -730,6 +730,8 @@ function mergeSettings(settings) {
         testing: {
             record_results_to_items: settings.testing?.record_results_to_items ??
                 defaults.testing.record_results_to_items,
+            allow_untrusted_linked_tests: settings.testing?.allow_untrusted_linked_tests ??
+                defaults.testing.allow_untrusted_linked_tests,
         },
         telemetry: buildTelemetrySettings(settings, defaults),
         agent_guidance: normalizeAgentGuidanceSettings(settings.agent_guidance ?? defaults.agent_guidance),
@@ -816,6 +818,7 @@ function orderSerializedSettingsSections(ordered) {
     ]);
     ordered.testing = orderObject(ordered.testing, [
         "record_results_to_items",
+        "allow_untrusted_linked_tests",
     ]);
     ordered.telemetry = orderObject(ordered.telemetry, [
         "enabled",
@@ -1304,4 +1307,4 @@ export const settingsStoreTestOnly = {
     selectedSettingsReadCacheSignaturesEqual,
 };
 //# sourceMappingURL=settings.js.map
-//# debugId=67bf189e-e816-536d-9051-589a2e468423
+//# debugId=5b95183e-9fd3-55cf-9059-8736f692e96e

package/dist/mcp/server.d.ts

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { readRequiredString, runAction } from "../sdk/runtime.js";
+import { readRequiredString, type PmActionInput } from "../sdk/runtime.js";
 interface JsonRpcRequest {
     jsonrpc?: string;
     id?: string | number | null;
     method?: string;
     params?: Record<string, unknown>;
 }
+declare function runMcpAction(args: PmActionInput): Promise<unknown>;
 declare function nearestDeclaredKey(unexpected: string, declared: string[]): string | undefined;
 declare function detectUnexpectedTopLevelKeys(toolName: string, args: Record<string, unknown>, toolDeclaredKeys?: Map<string, string[]>): string[];
 declare function collectMutationGuardWarnings(toolName: string, action: string | undefined, args: Record<string, unknown>): Promise<string[]>;
@@ -14,7 +15,7 @@ declare function resultContent(result: unknown, warnings?: string[], tokenAccoun
 declare function errorContent(error: unknown): Record<string, unknown>;
 /** Retain at most 32 own, valid provenance values without cloning unbounded input. */
 declare function boundMcpClientProvenance(value: unknown): Record<string, string>;
-/** Implements handle request for the public runtime surface of this module. */
+/** Dispatch one MCP request under supported process-level reproducibility settings. */
 export declare function handleRequest(request: JsonRpcRequest): Promise<Record<string, unknown> | undefined>;
 declare function writeError(id: JsonRpcRequest["id"], error: unknown): void;
 /** Implements process rpc line for the public runtime surface of this module. */
@@ -53,7 +54,7 @@ export declare const _testOnly: {
     readonly readScalarString: typeof import("../sdk/runtime-input.js").readRuntimeScalarString;
     readonly readScalarStringAllowBlank: typeof import("../sdk/runtime-input.js").readRuntimeScalarStringAllowBlank;
     readonly readStringArray: typeof import("../sdk/runtime-input.js").readRuntimeStringArray;
-    runAction: typeof runAction;
+    runAction: typeof runMcpAction;
     readonly updateManyOptionsFromFlat: typeof import("../sdk/runtime-input.js").updateManyOptionsFromFlat;
     readonly withAddNoteOption: typeof import("../sdk/runtime-input.js").withAddNoteOption;
     readonly withFilesDiscoveryOptions: typeof import("../sdk/runtime-input.js").withFilesDiscoveryOptions;