@unbrained/pm-cli 2026.8.16 → 2026.8.18

package/dist/core/config/nested-settings.js

@@ -24,7 +24,7 @@
  */
 /** Search/provider/vector-store leaves. Order is the display order in `pm config list` and in error hints. */
 
-!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]="b4af534e-32f9-5271-b6f1-7d901c282de0")}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]="be95f220-5f66-5e8c-8447-996696d02e43")}catch(e){}}();
 export const NESTED_SETTING_DESCRIPTORS = [
     {
         key: "search_provider",
@@ -255,6 +255,12 @@ export const NESTED_SETTING_DESCRIPTORS = [
         choices: ["toon", "json"],
         summary: "Default output format for commands that support it: toon or json.",
     },
+    {
+        key: "ux_deprecation_hints",
+        path: "ux.deprecation_hints",
+        kind: "boolean",
+        summary: "Emit one stderr migration hint for deprecated command aliases.",
+    },
     {
         key: "locks_ttl_seconds",
         path: "locks.ttl_seconds",
@@ -520,4 +526,4 @@ export function writeNestedSettingValue(settings, descriptor, value) {
     return true;
 }
 //# sourceMappingURL=nested-settings.js.map
-//# debugId=b4af534e-32f9-5271-b6f1-7d901c282de0
+//# debugId=be95f220-5f66-5e8c-8447-996696d02e43

package/dist/core/extensions/exporter-output-contract.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module core/extensions/exporter-output-contract
+ *
+ * Validates SDK-declared exporter artifact channels independently from extension activation.
+ */
+import type { CommandHandlerContext, ExporterRegistrationOptions, ImportExportContext, RegisteredExporterArtifactOutputContract } from "./extension-types.js";
+/** Validates and normalizes the public artifact-channel metadata for one exporter registration. */
+export declare function normalizeExporterArtifactOutput(value: unknown): RegisteredExporterArtifactOutputContract;
+/** Enforces importer/exporter channel ownership and applies the stdout-specific derived description. */
+export declare function resolveImportExportArtifactOutput(method: "registerImporter" | "registerExporter", resolvedOptions: ExporterRegistrationOptions, descriptionWasDeclared: boolean): RegisteredExporterArtifactOutputContract | undefined;
+/** Snapshots a host command invocation into the stable importer/exporter context contract. */
+export declare function buildImportExportContext(context: CommandHandlerContext, registration: string, action: "import" | "export"): ImportExportContext;

package/dist/core/extensions/exporter-output-contract.js

@@ -0,0 +1,67 @@
+
+!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]="057f439e-ac5c-5715-9fd0-4410e003d481")}catch(e){}}();
+import { cloneContextSnapshot } from "./extension-runtime-helpers.js";
+import { asRegistrationRecord, assertOptionalStringField, } from "./registration-validation.js";
+/** Validates and normalizes the public artifact-channel metadata for one exporter registration. */
+export function normalizeExporterArtifactOutput(value) {
+    const candidate = asRegistrationRecord("registerExporter options.output", value);
+    const allowedKeys = new Set(["channel", "receipt", "media_type"]);
+    for (const key of Object.keys(candidate)) {
+        if (!allowedKeys.has(key)) {
+            throw new TypeError(`registerExporter options.output contains unsupported field ${key}`);
+        }
+    }
+    if (candidate.channel !== "stdout" && candidate.channel !== "file") {
+        throw new TypeError("registerExporter options.output.channel must be stdout|file");
+    }
+    if (candidate.receipt !== undefined &&
+        candidate.receipt !== "suppress" &&
+        candidate.receipt !== "render") {
+        throw new TypeError("registerExporter options.output.receipt must be suppress|render");
+    }
+    if (candidate.channel === "stdout" && candidate.receipt === "render") {
+        throw new TypeError("registerExporter stdout artifacts cannot render a host receipt");
+    }
+    assertOptionalStringField("registerExporter options.output.media_type", candidate.media_type);
+    return {
+        channel: candidate.channel,
+        receipt: candidate.receipt ??
+            (candidate.channel === "stdout" ? "suppress" : "render"),
+        ...(typeof candidate.media_type === "string"
+            ? { media_type: candidate.media_type }
+            : {}),
+    };
+}
+/** Enforces importer/exporter channel ownership and applies the stdout-specific derived description. */
+export function resolveImportExportArtifactOutput(method, resolvedOptions, descriptionWasDeclared) {
+    if (method === "registerImporter" && resolvedOptions.output !== undefined) {
+        throw new TypeError("registerImporter options.output is exporter-only");
+    }
+    if (method !== "registerExporter" || resolvedOptions.output === undefined) {
+        return undefined;
+    }
+    const output = normalizeExporterArtifactOutput(resolvedOptions.output);
+    if (!descriptionWasDeclared && output.channel === "stdout") {
+        resolvedOptions.description =
+            "Export items with the registered extension adapter. Artifact bytes are written exclusively to stdout and the host receipt is suppressed by default.";
+    }
+    return output;
+}
+/** Snapshots a host command invocation into the stable importer/exporter context contract. */
+export function buildImportExportContext(context, registration, action) {
+    return {
+        registration,
+        action,
+        command: context.command,
+        args: cloneContextSnapshot(context.args),
+        options: cloneContextSnapshot(context.options),
+        global: cloneContextSnapshot(context.global),
+        pm_root: context.pm_root,
+        source_workspace_root: context.source_workspace_root,
+        repo_root: context.repo_root,
+        pm_root_rel: context.pm_root_rel,
+        ...(context.sdk === undefined ? {} : { sdk: context.sdk }),
+    };
+}
+//# sourceMappingURL=exporter-output-contract.js.map
+//# debugId=057f439e-ac5c-5715-9fd0-4410e003d481

package/dist/core/extensions/extension-types.d.ts

@@ -715,6 +715,39 @@ export interface ImportExportRegistrationOptions {
     /** Value that configures or reports flags for this contract. */
     flags?: FlagDefinition[];
 }
+/**
+ * Declares where an exporter writes its artifact and whether the host may
+ * render the returned structured receipt after the exporter completes.
+ */
+export type ExporterArtifactOutputContract = {
+    /** Stdout exclusively carries artifact bytes. */
+    channel: "stdout";
+    /** Stdout artifacts cannot opt back into host rendering. */
+    receipt?: "suppress";
+    /** Optional IANA media type describing the emitted artifact. */
+    media_type?: string;
+} | {
+    /** The exporter writes its artifact to a file. */
+    channel: "file";
+    /** File exporters may render or suppress their bounded receipt. */
+    receipt?: "suppress" | "render";
+    /** Optional IANA media type describing the emitted artifact. */
+    media_type?: string;
+};
+/** Exporter command metadata plus its optional artifact-delivery contract. */
+export interface ExporterRegistrationOptions extends ImportExportRegistrationOptions {
+    /** Declaration for artifact bytes and the host receipt. */
+    output?: ExporterArtifactOutputContract;
+}
+/** Fully normalized exporter artifact contract stored in inventories. */
+export interface RegisteredExporterArtifactOutputContract {
+    /** Destination carrying the artifact bytes. */
+    channel: "stdout" | "file";
+    /** Explicit host receipt policy after normalization. */
+    receipt: "suppress" | "render";
+    /** Optional IANA media type describing the emitted artifact. */
+    media_type?: string;
+}
 /** Restricts flag value type values accepted by command, SDK, and storage contracts. */
 export type FlagValueType = "string" | "number" | "boolean";
 /** Documents the flag definition payload exchanged by command, SDK, and package integrations. */
@@ -1288,6 +1321,8 @@ export interface RegisteredExtensionExporter {
     name: string;
     /** Value that configures or reports exporter for this contract. */
     exporter: string;
+    /** Declared artifact channel and normalized receipt policy. */
+    output?: RegisteredExporterArtifactOutputContract;
 }
 /** Documents the registered extension search provider payload exchanged by command, SDK, and package integrations. */
 export interface RegisteredExtensionSearchProvider {
@@ -1447,7 +1482,7 @@ export interface ExtensionApi {
     /** Value that configures or reports register importer for this contract. */
     registerImporter(name: string, importer: Importer, options?: ImportExportRegistrationOptions): void;
     /** Value that configures or reports register exporter for this contract. */
-    registerExporter(name: string, exporter: Exporter, options?: ImportExportRegistrationOptions): void;
+    registerExporter(name: string, exporter: Exporter, options?: ExporterRegistrationOptions): void;
     /** Value that configures or reports register search provider for this contract. */
     registerSearchProvider(provider: SearchProviderDefinition): void;
     /** Value that configures or reports register vector store adapter for this contract. */

package/dist/core/extensions/extension-types.js

@@ -1,6 +1,6 @@
 /** Public contract for known extension capabilities, shared by SDK and presentation-layer consumers. */
 
-!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]="294f3a0c-e74d-5963-b966-8a4443855ce3")}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]="a54549aa-2f6c-5092-a3eb-5b36ee698ea4")}catch(e){}}();
 export const KNOWN_EXTENSION_CAPABILITIES = [
     "commands",
     "renderers",
@@ -100,4 +100,4 @@ export function createDefaultExtensionGovernancePolicy() {
     };
 }
 //# sourceMappingURL=extension-types.js.map
-//# debugId=294f3a0c-e74d-5963-b966-8a4443855ce3
+//# debugId=a54549aa-2f6c-5092-a3eb-5b36ee698ea4

package/dist/core/extensions/loader.js

@@ -4,12 +4,13 @@
  * Implements extension runtime contracts and governance for Loader.
  */
 
-!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]="2b8750c3-7b19-5240-8179-f83830af1b77")}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]="cccce7c1-dd08-5c9f-a74e-e639536b9a6a")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { pathExists } from "../fs/fs-utils.js";
 import { isPathWithinDirectory } from "../fs/path-utils.js";
+import { isHostOutputSuppressed, suppressHostOutput, } from "../output/output-control.js";
 import { resolvePmPackageRootFromModule } from "../packages/root.js";
 import { resolveGlobalPmRoot } from "../store/paths.js";
 import { asRecordLoose, resolveActivatablePropertyRecord, } from "../shared/primitives.js";
@@ -19,6 +20,7 @@ import { snapshotExtensionModuleGraph } from "./module-graph-snapshot.js";
 import { captureExtensionActivationRollback } from "./activation-transaction.js";
 import { collectPreflightCollisionWarnings, normalizePreflightOverride, } from "./preflight-ownership.js";
 import { assertCommandDefinitionMetadataStrings } from "./command-visibility-tier.js";
+import { buildImportExportContext, resolveImportExportArtifactOutput, } from "./exporter-output-contract.js";
 import { asRegistrationRecord, assertOptionalBooleanField, assertOptionalFlagDefaultField, assertOptionalStringArrayField, assertOptionalStringField, normalizeOptionalStringArrayField, } from "./registration-validation.js";
 import { describeExtensionLongFlagFailure, findExtensionFlagTokenFailure, } from "./flag-definition-validation.js";
 import { compareComparableVersions, evaluatePmMaxVersionBound, evaluatePmMinVersionBound, parseComparableVersion, } from "./version-compat.js";
@@ -26,8 +28,9 @@ import { createRelationshipKindRegistry, } from "../../sdk/relationships.js";
 import { normalizeNames, isKnownExtensionCapability, collectUnknownExtensionCapabilities, normalizeManifestCapabilities, formatUnknownExtensionCapabilityWarning, formatLegacyExtensionCapabilityAliasWarning, } from "./extension-capability-aliases.js";
 import { normalizeExtensionPolicy, serializeExtensionPolicy, hydrateExtensionPolicy, normalizePolicySandboxProfile, evaluateExtensionPolicyForExtension, evaluateExtensionPolicyForCapability, evaluateExtensionPolicyForRegistration, } from "./extension-policy.js";
 import { createEmptyExtensionHookRegistry, createEmptyExtensionCommandRegistry, createEmptyExtensionParserRegistry, createEmptyExtensionPreflightRegistry, createEmptyExtensionServiceRegistry, createEmptyExtensionRendererRegistry, createEmptyExtensionRegistrationRegistry, } from "./extension-registries.js";
-import { normalizeCommandName, cloneContextSnapshot, } from "./extension-runtime-helpers.js";
+import { normalizeCommandName } from "./extension-runtime-helpers.js";
 import { normalizeExtensionContributionInventory } from "./contribution-inventory.js";
+import { formatExtensionManifestSchemaWarnings } from "./manifest-schema.js";
 import { attachRuntimeDefinition, assertHookHandler, assertNonEmptyRegistrationString, assertRegistrationFunction, cloneRuntimeRegistrationValue, createRegistrationValidationError, extractRegistrationValidationTrace, isExtensionServiceName, isOutputRendererFormat, normalizeRegistrationRecord, normalizeRegistrationRecordList, normalizeRuntimeRegistrationRecord, normalizeRegistrationName, sanitizeRegistrationValue, toRegistrationCommandPath, validateAssuranceMeasurementProviderDefinition, } from "./registration-values.js";
 import { buildReadyExtensionCandidate, } from "./extension-candidate.js";
 export { parseUnknownExtensionCapabilityWarning, parseLegacyExtensionCapabilityAliasWarning, } from "./extension-capability-aliases.js";
@@ -513,8 +516,8 @@ function buildUnavailableExtensionScan(layer, directory, manifestPath, warning)
     };
 }
 /** Collect the non-fatal load warnings for a parsed extension manifest, in detection order: legacy capability aliases, unknown capabilities, an entry outside or absent from the extension directory, then the pm version floor/ceiling incompatibility warnings. */
-function collectScannedExtensionWarnings(layer, manifest, entryWithinDirectory, entryExists, pmVersionCompatibility, pmMaxVersionCompatibility) {
-    const extensionWarnings = [];
+function collectScannedExtensionWarnings(layer, manifest, rawManifest, entryWithinDirectory, entryExists, pmVersionCompatibility, pmMaxVersionCompatibility) {
+    const extensionWarnings = formatExtensionManifestSchemaWarnings(layer, manifest, rawManifest);
     if (Array.isArray(manifest.legacy_capability_aliases) &&
         manifest.legacy_capability_aliases.length > 0) {
         extensionWarnings.push(formatLegacyExtensionCapabilityAliasWarning(layer, manifest.name, manifest.legacy_capability_aliases));
@@ -543,14 +546,17 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
         return buildUnavailableExtensionScan(layer, directory, manifestPath, `extension_manifest_missing:${layer}:${directory}`);
     }
     let manifest;
+    let rawManifest;
     try {
         const parsed = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        rawManifest = asRecordLoose(parsed);
         manifest = parseExtensionManifestDocument(parsed);
     }
     catch {
+        rawManifest = null;
         manifest = null;
     }
-    if (!manifest) {
+    if (!manifest || !rawManifest) {
         return buildUnavailableExtensionScan(layer, directory, manifestPath, `extension_manifest_invalid:${layer}:${directory}`);
     }
     const entryPath = path.resolve(extensionDir, manifest.entry);
@@ -564,7 +570,7 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
     const enabledForLoad = shouldEnable(manifest.name, enabled, disabled);
     const pmVersionCompatibility = await evaluatePmMinVersionCompatibility(layer, manifest);
     const pmMaxVersionCompatibility = await evaluatePmMaxVersionCompatibility(layer, manifest, pmMaxVersionExceededMode);
-    const extensionWarnings = collectScannedExtensionWarnings(layer, manifest, entryWithinDirectory, entryExists, pmVersionCompatibility, pmMaxVersionCompatibility);
+    const extensionWarnings = collectScannedExtensionWarnings(layer, manifest, rawManifest, entryWithinDirectory, entryExists, pmVersionCompatibility, pmMaxVersionCompatibility);
     const extensionReady = entryWithinDirectory &&
         entryExists &&
         pmVersionCompatibility.allowed &&
@@ -1723,6 +1729,23 @@ class ExtensionApiRegistrar {
             profile: applyProjectProfileDefaults(snapshot),
         });
     }
+    /** Validates and records optional importer/exporter flag metadata through the schema policy gate. */
+    registerImportExportCommandFlags(method, commandPath, resolvedOptions) {
+        if (resolvedOptions.flags === undefined) {
+            return;
+        }
+        assertExtensionCapability(this.#loadedExtension, "schema", `${method} options.flags`);
+        if (!this.allowRegistration("schema.flags", `${method} options.flags`, "schema")) {
+            return;
+        }
+        validateFlagDefinitions(resolvedOptions.flags);
+        this.#registrationRegistry.flags.push({
+            layer: this.#loadedExtension.layer,
+            name: this.#loadedExtension.name,
+            target_command: commandPath,
+            flags: normalizeFlagDefinitions(`${method} options.flags`, resolvedOptions.flags),
+        });
+    }
     applyImportExportCommandMetadata(method, commandPath, options) {
         if (options !== undefined &&
             (typeof options !== "object" ||
@@ -1743,6 +1766,7 @@ class ExtensionApiRegistrar {
             description: options?.description ?? defaultDescription,
             arguments: options?.arguments ?? defaultArguments,
         };
+        const output = resolveImportExportArtifactOutput(method, resolvedOptions, options?.description !== undefined);
         assertOptionalStringField(`${method} options.action`, resolvedOptions.action);
         assertOptionalStringField(`${method} options.description`, resolvedOptions.description);
         assertOptionalStringField(`${method} options.intent`, resolvedOptions.intent);
@@ -1750,20 +1774,7 @@ class ExtensionApiRegistrar {
         const examples = normalizeOptionalStringArrayField(`${method} options.examples`, resolvedOptions.examples);
         const failureHints = normalizeOptionalStringArrayField(`${method} options.failure_hints`, resolvedOptions.failure_hints);
         const argumentsDefinition = normalizeCommandDefinitionArguments(resolvedOptions.arguments);
-        if (resolvedOptions.flags !== undefined) {
-            assertExtensionCapability(this.#loadedExtension, "schema", `${method} options.flags`);
-            // Route metadata flags through the same surface-policy gate as registerFlags so
-            // enforce-mode policies blocking schema.flags are honored even when importers are allowed.
-            if (this.allowRegistration("schema.flags", `${method} options.flags`, "schema")) {
-                validateFlagDefinitions(resolvedOptions.flags);
-                this.#registrationRegistry.flags.push({
-                    layer: this.#loadedExtension.layer,
-                    name: this.#loadedExtension.name,
-                    target_command: commandPath,
-                    flags: normalizeFlagDefinitions(`${method} options.flags`, resolvedOptions.flags),
-                });
-            }
-        }
+        this.registerImportExportCommandFlags(method, commandPath, resolvedOptions);
         const registration = {
             layer: this.#loadedExtension.layer,
             name: this.#loadedExtension.name,
@@ -1783,6 +1794,7 @@ class ExtensionApiRegistrar {
             registration.intent = intent;
         }
         this.#registrationRegistry.commands.push(registration);
+        return output;
     }
     registerImporter(name, importer, options) {
         assertExtensionCapability(this.#loadedExtension, "importers", "registerImporter");
@@ -1804,19 +1816,7 @@ class ExtensionApiRegistrar {
             layer: this.#loadedExtension.layer,
             name: this.#loadedExtension.name,
             command: commandPath,
-            run: async (context) => importer({
-                registration: normalizedName,
-                action: "import",
-                command: context.command,
-                args: cloneContextSnapshot(context.args),
-                options: cloneContextSnapshot(context.options),
-                global: cloneContextSnapshot(context.global),
-                pm_root: context.pm_root,
-                source_workspace_root: context.source_workspace_root,
-                repo_root: context.repo_root,
-                pm_root_rel: context.pm_root_rel,
-                ...(context.sdk === undefined ? {} : { sdk: context.sdk }),
-            }),
+            run: async (context) => importer(buildImportExportContext(context, normalizedName, "import")),
         });
     }
     registerExporter(name, exporter, options) {
@@ -1829,29 +1829,24 @@ class ExtensionApiRegistrar {
         const commandPath = toRegistrationCommandPath(normalizedName, "export");
         // Validate and register optional command metadata before mutating the registry
         // so an invalid options object leaves no partial exporter registration.
-        this.applyImportExportCommandMetadata("registerExporter", commandPath, options);
+        const output = this.applyImportExportCommandMetadata("registerExporter", commandPath, options);
         this.#registrationRegistry.exporters.push({
             layer: this.#loadedExtension.layer,
             name: this.#loadedExtension.name,
             exporter: normalizedName,
+            ...(output === undefined ? {} : { output }),
         });
         this.#commandRegistry.handlers.push({
             layer: this.#loadedExtension.layer,
             name: this.#loadedExtension.name,
             command: commandPath,
-            run: async (context) => exporter({
-                registration: normalizedName,
-                action: "export",
-                command: context.command,
-                args: cloneContextSnapshot(context.args),
-                options: cloneContextSnapshot(context.options),
-                global: cloneContextSnapshot(context.global),
-                pm_root: context.pm_root,
-                source_workspace_root: context.source_workspace_root,
-                repo_root: context.repo_root,
-                pm_root_rel: context.pm_root_rel,
-                ...(context.sdk === undefined ? {} : { sdk: context.sdk }),
-            }),
+            run: async (context) => {
+                const result = await exporter(buildImportExportContext(context, normalizedName, "export"));
+                return output?.receipt === "suppress" &&
+                    !isHostOutputSuppressed(result)
+                    ? suppressHostOutput(result)
+                    : result;
+            },
         });
     }
     registerSearchProvider(provider) {
@@ -2221,4 +2216,4 @@ export const _testOnlyLoader = {
     },
 };
 //# sourceMappingURL=loader.js.map
-//# debugId=2b8750c3-7b19-5240-8179-f83830af1b77
+//# debugId=cccce7c1-dd08-5c9f-a74e-e639536b9a6a

package/dist/core/extensions/manifest-schema.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module core/extensions/manifest-schema
+ *
+ * Defines the closed extension-manifest key vocabulary and returns pure schema
+ * diagnostics shared by SDK authoring checks and runtime discovery.
+ */
+import type { ExtensionLayer, ExtensionManifest } from "./extension-types.js";
+/** Canonical top-level keys accepted by an extension `manifest.json`. */
+export declare const KNOWN_EXTENSION_MANIFEST_KEYS: Set<string>;
+/** Pure closed-schema inspection result for one raw extension manifest. */
+export interface ExtensionManifestSchemaInspection {
+    /** Unknown top-level keys in deterministic lexical order. */
+    unknownKeys: string[];
+    /** Whether neither canonical pm compatibility bound is present. */
+    missingVersionBounds: boolean;
+}
+/** Inspect raw manifest keys without parsing, loading, or mutating an extension. */
+export declare function inspectExtensionManifestSchema(manifest: Readonly<Record<string, unknown>>): ExtensionManifestSchemaInspection;
+/** Format runtime discovery warnings for unknown keys and absent canonical compatibility bounds. */
+export declare function formatExtensionManifestSchemaWarnings(layer: ExtensionLayer, manifest: ExtensionManifest, rawManifest: Readonly<Record<string, unknown>>): string[];

package/dist/core/extensions/manifest-schema.js

@@ -0,0 +1,52 @@
+/**
+ * @module core/extensions/manifest-schema
+ *
+ * Defines the closed extension-manifest key vocabulary and returns pure schema
+ * diagnostics shared by SDK authoring checks and runtime discovery.
+ */
+/** Canonical top-level keys accepted by an extension `manifest.json`. */
+
+!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]="7d9d8924-3186-5aab-ac36-164fb08624a8")}catch(e){}}();
+export const KNOWN_EXTENSION_MANIFEST_KEYS = new Set([
+    "name",
+    "version",
+    "entry",
+    "priority",
+    "description",
+    "author",
+    "capabilities",
+    "manifest_version",
+    "pm_min_version",
+    "pm_max_version",
+    "engines",
+    "trusted",
+    "provenance",
+    "sandbox_profile",
+    "permissions",
+    "activation",
+    "contributions",
+    "legacy_capability_aliases",
+]);
+/** Inspect raw manifest keys without parsing, loading, or mutating an extension. */
+export function inspectExtensionManifestSchema(manifest) {
+    return {
+        unknownKeys: Object.keys(manifest)
+            .filter((key) => !KNOWN_EXTENSION_MANIFEST_KEYS.has(key))
+            .sort((left, right) => (left > right ? 1 : -1)),
+        missingVersionBounds: manifest.pm_min_version === undefined &&
+            manifest.pm_max_version === undefined,
+    };
+}
+/** Format runtime discovery warnings for unknown keys and absent canonical compatibility bounds. */
+export function formatExtensionManifestSchemaWarnings(layer, manifest, rawManifest) {
+    const inspection = inspectExtensionManifestSchema(rawManifest);
+    const warnings = inspection.unknownKeys.map((key) => key === "compatibility"
+        ? `extension_manifest_unknown_key:${layer}:${manifest.name}:key=compatibility:suggested=pm_min_version`
+        : `extension_manifest_unknown_key:${layer}:${manifest.name}:key=${key}`);
+    if (inspection.missingVersionBounds) {
+        warnings.push(`extension_manifest_no_version_bounds:${layer}:${manifest.name}:suggested=pm_min_version`);
+    }
+    return warnings;
+}
+//# sourceMappingURL=manifest-schema.js.map
+//# debugId=7d9d8924-3186-5aab-ac36-164fb08624a8

package/dist/core/history/event-index.d.ts

@@ -51,6 +51,11 @@ declare function loadDatabaseSync(loadModule: (specifier: string) => unknown): D
 declare function loadStableDatabaseSync(nodeVersion: string, loadModule: (specifier: string) => unknown): DatabaseSyncConstructor | null;
 /** Rebuild the complete optional event projection from authoritative streams. */
 export declare function rebuildHistoryEventIndex(pmRoot: string): Promise<boolean>;
+/**
+ * Query authoritative history streams when the optional SQLite accelerator is
+ * unavailable. The result preserves the index contract at higher read cost.
+ */
+export declare function queryHistoryEventStreams(pmRoot: string, query: HistoryEventIndexQuery): Promise<HistoryEventIndexQueryResult>;
 /**
  * Update an already-built event projection after one authoritative append.
  * Absence is a cheap no-op; corrupt projections are removed for lazy rebuild.