@chengxianglibra/dsh-data-analysis 0.1.1 → 0.2.0

package/lib/environment/binding.js

@@ -39,10 +39,36 @@ _dsh_sys.argv = [_dsh_sys.argv[0], *_dsh_sys.argv[4:]]
 const IMPORT_IDENTITY_PROGRAM = String.raw `
 print(_dsh_json.dumps(_dsh_actual, sort_keys=True))
 `.trim();
-function redactSubprocessOutput(result, environmentOverlay) {
-    if (environmentOverlay === undefined)
+const PRESENTATION_IDENTITY_PRELUDE = String.raw `
+try:
+    import dsh_data_analysis_presentation as _dsh_presentation
+    from importlib.metadata import distribution as _dsh_distribution
+    _dsh_presentation_distribution = _dsh_distribution("dsh-data-analysis-presentation-kit")
+    _dsh_presentation_path = _dsh_os.path.realpath(_dsh_presentation.__file__ or "")
+    if (
+        _dsh_presentation.__version__ != _dsh_expected_presentation["version"]
+        or _dsh_presentation_distribution.version != _dsh_expected_presentation["version"]
+        or _dsh_presentation_path != _dsh_os.path.realpath(_dsh_expected_presentation["packagePath"])
+        or _dsh_presentation_path != _dsh_os.path.realpath(_dsh_presentation_distribution.locate_file("dsh_data_analysis_presentation/__init__.py"))
+        or not callable(_dsh_presentation.write_dataset)
+    ):
+        raise ValueError("presentation helper identity mismatch")
+except Exception:
+    print(_dsh_json.dumps({"kind": "presentation-identity-mismatch"}), file=_dsh_sys.stderr)
+    raise SystemExit(78)
+`.trim();
+function redactSubprocessOutput(result, environmentOverlay, secretValues = []) {
+    if (environmentOverlay === undefined && secretValues.length === 0)
         return result;
-    const secrets = Object.values(environmentOverlay).filter((value) => value !== undefined && value !== '');
+    // These exact process controls carry no credential material. Redacting '1' would
+    // corrupt public schema IDs such as marivo.semantic_ref/v1.
+    const secrets = Object.entries(environmentOverlay ?? {})
+        .filter(([key, value]) => !((key === 'MARIVO_TELEMETRY' && value === 'off') ||
+        (key === 'PYTHONDONTWRITEBYTECODE' && value === '1')))
+        .map(([, value]) => value)
+        .filter((value) => value !== undefined && value !== '');
+    secrets.push(...secretValues.filter(Boolean));
+    secrets.sort((a, b) => b.length - a.length);
     const redactText = (source) => {
         let text = source;
         for (const secret of secrets)
@@ -116,6 +142,9 @@ function fingerprint(binding) {
         binding.marivoVersion,
         binding.packagePath,
         binding.subprocessPolicyId,
+        ...(binding.presentationKit === undefined
+            ? []
+            : [binding.presentationKit.version, binding.presentationKit.packagePath]),
     ];
     return createHash('sha256').update(JSON.stringify(payload)).digest('hex');
 }
@@ -142,7 +171,14 @@ export class MarivoEnvironment {
     subprocessPolicy;
     #failed = false;
     constructor(binding, subprocessPolicy) {
-        this.binding = Object.freeze({ ...binding });
+        this.binding = Object.freeze({
+            ...binding,
+            ...(binding.presentationKit === undefined
+                ? {}
+                : {
+                    presentationKit: Object.freeze({ ...binding.presentationKit }),
+                }),
+        });
         this.subprocessPolicy = subprocessPolicy;
     }
     get status() {
@@ -158,11 +194,14 @@ export class MarivoEnvironment {
         }
         if (request.program.trim() === '')
             throw new TypeError('checked Python program must not be empty');
+        const presentationPrelude = this.binding.presentationKit === undefined
+            ? ''
+            : `_dsh_expected_presentation = ${JSON.stringify(this.binding.presentationKit)}\n${PRESENTATION_IDENTITY_PRELUDE}\n`;
         const rawResult = await this.subprocessPolicy.run({
             executable: this.binding.pythonExecutable,
             args: [
                 '-c',
-                `${CHECKED_IDENTITY_PRELUDE}\n${request.program}`,
+                `${CHECKED_IDENTITY_PRELUDE}\n${presentationPrelude}${request.program}`,
                 this.binding.pythonExecutable,
                 this.binding.marivoVersion,
                 this.binding.packagePath,
@@ -171,13 +210,14 @@ export class MarivoEnvironment {
             ...(request.environmentOverlay === undefined
                 ? {}
                 : { environmentOverlay: request.environmentOverlay }),
+            ...(request.stdin === undefined ? {} : { stdin: request.stdin }),
             ...(request.limits === undefined ? {} : { limits: request.limits }),
             ...(request.signal === undefined ? {} : { signal: request.signal }),
         });
-        const result = redactSubprocessOutput(rawResult, request.environmentOverlay);
+        const result = redactSubprocessOutput(rawResult, request.environmentOverlay, request.secretValues);
         if (result.exitCode === 78) {
             this.#failed = true;
-            throw new MarivoEnvironmentError('binding-identity-mismatch', 'Marivo import identity changed; explicit rebind is required', {
+            throw new MarivoEnvironmentError('binding-identity-mismatch', 'Bound Runtime import identity changed; explicit rebind is required', {
                 fingerprint: this.binding.fingerprint,
                 exitCode: result.exitCode,
                 stderr: result.stderr.toString('utf8').slice(0, 2_000),
@@ -194,7 +234,7 @@ export class MarivoEnvironment {
         });
         if (result.exitCode !== 0) {
             this.#failed = true;
-            throw new MarivoEnvironmentError('binding-identity-mismatch', 'Marivo import identity changed; explicit rebind is required', {
+            throw new MarivoEnvironmentError('binding-identity-mismatch', 'Bound Runtime import identity changed; explicit rebind is required', {
                 fingerprint: this.binding.fingerprint,
                 exitCode: result.exitCode,
                 stderr: result.stderr.toString('utf8').slice(0, 2_000),
@@ -213,7 +253,7 @@ export class MarivoEnvironment {
             this.#failed = true;
             if (cause instanceof MarivoEnvironmentError)
                 throw cause;
-            throw new MarivoEnvironmentError('binding-identity-mismatch', 'Marivo import identity changed; explicit rebind is required', { fingerprint: this.binding.fingerprint }, { cause });
+            throw new MarivoEnvironmentError('binding-identity-mismatch', 'Bound Runtime import identity changed; explicit rebind is required', { fingerprint: this.binding.fingerprint }, { cause });
         }
     }
 }
@@ -225,6 +265,10 @@ export function createSharedMarivoRuntimeRunner(runtime, options = {}) {
         pythonExecutable: runtime.pythonExecutable,
         marivoVersion: runtime.marivoVersion,
         packagePath: runtime.packagePath,
+        presentationKit: {
+            version: runtime.presentationKitVersion,
+            packagePath: runtime.presentationKitPackagePath,
+        },
         subprocessPolicyId: subprocessPolicy.id,
     };
     return new MarivoEnvironment({ ...partialBinding, fingerprint: fingerprint(partialBinding) }, subprocessPolicy);
@@ -263,6 +307,7 @@ export async function bindMarivoEnvironment(config, options = {}) {
         pythonExecutable,
         marivoVersion: report.marivo.version,
         packagePath: normalizeAbsolute(report.marivo.package_path),
+        ...(options.presentationKit === undefined ? {} : { presentationKit: options.presentationKit }),
         subprocessPolicyId: subprocessPolicy.id,
     };
     const binding = {

package/lib/environment/runtime.js

@@ -11,38 +11,42 @@ import { FixedSubprocessPolicy } from "./subprocess.js";
 export const SHARED_PYTHON_SPEC = '3.10';
 const PINNED_MARIVO_VERSION = MARIVO_VERSION;
 export const SHARED_MARIVO_PACKAGE_SPEC = MARIVO_PACKAGE_SPEC;
-export const REPORT_KIT_DISTRIBUTION = 'dsh-data-analysis-report-kit';
-export const REPORT_KIT_VERSION = '3.0.0';
-export const REPORT_KIT_PANDAS_RANGE = '>=2.2.0,<3.0.0';
-export const REPORT_KIT_WHEEL_FILENAME = 'dsh_data_analysis_report_kit-3.0.0-py3-none-any.whl';
+export const PRESENTATION_KIT_DISTRIBUTION = 'dsh-data-analysis-presentation-kit';
+export const PRESENTATION_KIT_VERSION = '1.1.0';
+export const PRESENTATION_KIT_PANDAS_RANGE = '>=2.2.0,<3.0.0';
+export const PRESENTATION_KIT_WHEEL_FILENAME = 'dsh_data_analysis_presentation_kit-1.1.0-py3-none-any.whl';
 export const DEFAULT_SHARED_RUNTIME_INSTALL_TIMEOUT_MS = 600_000;
 const INSTALLATION_SCHEMA = RUNTIME_INSTALLATION_VERSION;
 const INSTALLATION_FILENAME = 'installation.json';
 const SKILL_NAMES = ['marivo-analysis', 'marivo-semantic'];
-const REPORT_ADAPTER_KIND = 'dsh-data-analysis-report-transport-adapter';
 const PROBE_SCRIPT = String.raw `
 import json
 import os
 import sys
+from importlib.metadata import distribution
 import marivo
+import ibis.backends.duckdb
+from marivo.semantic.definition import SemanticDefinition
 import pandas
-import dsh_data_analysis_report
+import dsh_data_analysis_presentation
 from packaging.specifiers import SpecifierSet
 from packaging.version import Version
 
+presentation_distribution = distribution("dsh-data-analysis-presentation-kit")
+
 print(json.dumps({
     "python_executable": os.path.abspath(sys.executable),
     "marivo_version": marivo.__version__,
     "package_path": os.path.abspath(marivo.__file__ or ""),
     "pandas_version": pandas.__version__,
     "pandas_supported": Version(pandas.__version__) in SpecifierSet(">=2.2.0,<3.0.0"),
-    "report_kit_version": dsh_data_analysis_report.__version__,
-    "report_kit_package_path": os.path.abspath(dsh_data_analysis_report.__file__ or ""),
-    "report_kit_public_imports": all(callable(value) for value in (
-        dsh_data_analysis_report.emit_computed,
-        dsh_data_analysis_report.emit_dataset,
-        dsh_data_analysis_report.emit_session_trace,
-    )),
+    "presentation_kit_version": dsh_data_analysis_presentation.__version__,
+    "presentation_kit_distribution_version": presentation_distribution.version,
+    "presentation_kit_package_path": os.path.abspath(dsh_data_analysis_presentation.__file__ or ""),
+    "presentation_kit_import_identity": os.path.realpath(dsh_data_analysis_presentation.__file__ or "") == os.path.realpath(
+        presentation_distribution.locate_file("dsh_data_analysis_presentation/__init__.py")
+    ),
+    "presentation_kit_public_imports": callable(dsh_data_analysis_presentation.write_dataset),
 }, sort_keys=True))
 `.trim();
 const PYTHON_VERSION_SCRIPT = String.raw `
@@ -56,8 +60,8 @@ print(json.dumps({
     "prefix": os.path.abspath(sys.prefix),
 }, sort_keys=True))
 `.trim();
-function administratorRepair(executable, reportKitWheel) {
-    const dependencies = [SHARED_MARIVO_PACKAGE_SPEC, `pandas${REPORT_KIT_PANDAS_RANGE}`];
+function administratorRepair(executable, presentationKitWheel) {
+    const dependencies = [SHARED_MARIVO_PACKAGE_SPEC, `pandas${PRESENTATION_KIT_PANDAS_RANGE}`];
     const commands = [
         {
             executable,
@@ -65,7 +69,7 @@ function administratorRepair(executable, reportKitWheel) {
         },
         {
             executable,
-            args: ['-m', 'pip', 'install', '--no-deps', reportKitWheel],
+            args: ['-m', 'pip', 'install', '--no-deps', presentationKitWheel],
         },
     ];
     const commandText = (command) => [command.executable, ...command.args].map((value) => JSON.stringify(value)).join(' ');
@@ -90,22 +94,22 @@ function normalizeAbsolute(name, value) {
 function defaultRuntimeRoot() {
     return path.join(resolveDshHome(), 'dsh-data-analysis', 'runtimes', 'marivo');
 }
-function bundledReportKitWheel() {
-    return fileURLToPath(new URL(`../../python/report-kit/dist/${REPORT_KIT_WHEEL_FILENAME}`, import.meta.url));
+function bundledPresentationKitWheel() {
+    return fileURLToPath(new URL(`../../python/presentation-kit/dist/${PRESENTATION_KIT_WHEEL_FILENAME}`, import.meta.url));
 }
-async function assertReportKitWheel(filename) {
+async function assertPresentationKitWheel(filename) {
     const selected = path.normalize(path.resolve(filename));
-    if (path.basename(selected) !== REPORT_KIT_WHEEL_FILENAME) {
-        throw new MarivoEnvironmentError('shared-runtime-report-kit-wheel-invalid', `Bundled report-kit wheel must be named ${REPORT_KIT_WHEEL_FILENAME}`, { expectedWheel: REPORT_KIT_WHEEL_FILENAME, actualWheel: path.basename(selected) });
+    if (path.basename(selected) !== PRESENTATION_KIT_WHEEL_FILENAME) {
+        throw new MarivoEnvironmentError('shared-runtime-presentation-kit-wheel-invalid', `Bundled presentation-kit wheel must be named ${PRESENTATION_KIT_WHEEL_FILENAME}`, { expectedWheel: PRESENTATION_KIT_WHEEL_FILENAME, actualWheel: path.basename(selected) });
     }
     try {
         if (!(await stat(selected)).isFile())
             throw new Error('not a file');
     }
     catch (cause) {
-        throw new MarivoEnvironmentError('shared-runtime-report-kit-wheel-unavailable', `Bundled report-kit wheel is unavailable: ${selected}`, {
-            distribution: REPORT_KIT_DISTRIBUTION,
-            version: REPORT_KIT_VERSION,
+        throw new MarivoEnvironmentError('shared-runtime-presentation-kit-wheel-unavailable', `Bundled presentation-kit wheel is unavailable: ${selected}`, {
+            distribution: PRESENTATION_KIT_DISTRIBUTION,
+            version: PRESENTATION_KIT_VERSION,
             wheel: selected,
         }, { cause });
     }
@@ -153,7 +157,7 @@ function parseJsonObject(stage, result) {
         throw new MarivoEnvironmentError('shared-runtime-install-failed', `Shared Marivo runtime stage returned invalid JSON: ${stage}`, { stage, stdout: boundedText(result.stdout), stderr: boundedText(result.stderr) }, { cause });
     }
 }
-async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, reportKitWheel, administrator, expectedMarivoVersion) {
+async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, presentationKitWheel, administrator, expectedMarivoVersion) {
     const canonical = await assertExecutable(executable);
     const policy = new FixedSubprocessPolicy(runtimeRoot, environment);
     const result = await policy.run({
@@ -161,15 +165,15 @@ async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, rep
         args: ['-c', PROBE_SCRIPT],
         limits: { timeoutMs, stdoutMaxBytes: 16_384, stderrMaxBytes: 16_384 },
     });
-    const repair = administrator ? administratorRepair(canonical, reportKitWheel) : undefined;
+    const repair = administrator ? administratorRepair(canonical, presentationKitWheel) : undefined;
     if (administrator && result.exitCode !== 0) {
-        throw new MarivoEnvironmentError('shared-runtime-package-unavailable', `Administrator Python must provide Marivo ${PINNED_MARIVO_VERSION}, pandas ${REPORT_KIT_PANDAS_RANGE}, and ${REPORT_KIT_DISTRIBUTION} ${REPORT_KIT_VERSION}. ${repair.message}`, {
+        throw new MarivoEnvironmentError('shared-runtime-package-unavailable', `Administrator Python must provide Marivo ${PINNED_MARIVO_VERSION} with the duckdb extra, pandas ${PRESENTATION_KIT_PANDAS_RANGE}, and ${PRESENTATION_KIT_DISTRIBUTION} ${PRESENTATION_KIT_VERSION}. ${repair.message}`, {
             pythonExecutable: canonical,
             marivoVersion: PINNED_MARIVO_VERSION,
-            pandasRange: REPORT_KIT_PANDAS_RANGE,
-            reportKitDistribution: REPORT_KIT_DISTRIBUTION,
-            reportKitVersion: REPORT_KIT_VERSION,
-            reportKitWheel: reportKitWheel,
+            pandasRange: PRESENTATION_KIT_PANDAS_RANGE,
+            presentationKitDistribution: PRESENTATION_KIT_DISTRIBUTION,
+            presentationKitVersion: PRESENTATION_KIT_VERSION,
+            presentationKitWheel: presentationKitWheel,
             exitCode: result.exitCode,
             stderr: boundedText(result.stderr),
             repairCommands: repair.commands,
@@ -184,12 +188,15 @@ async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, rep
         typeof probe.pandas_version !== 'string' ||
         probe.pandas_version.length === 0 ||
         typeof probe.pandas_supported !== 'boolean' ||
-        typeof probe.report_kit_version !== 'string' ||
-        probe.report_kit_version.length === 0 ||
-        typeof probe.report_kit_package_path !== 'string' ||
-        probe.report_kit_package_path.length === 0 ||
-        probe.report_kit_public_imports !== true) {
-        throw new MarivoEnvironmentError('shared-runtime-identity-mismatch', 'Shared Runtime returned an incomplete package identity', { probe });
+        typeof probe.presentation_kit_version !== 'string' ||
+        probe.presentation_kit_version.length === 0 ||
+        typeof probe.presentation_kit_distribution_version !== 'string' ||
+        probe.presentation_kit_distribution_version.length === 0 ||
+        typeof probe.presentation_kit_package_path !== 'string' ||
+        probe.presentation_kit_package_path.length === 0 ||
+        probe.presentation_kit_import_identity !== true ||
+        probe.presentation_kit_public_imports !== true) {
+        throw new MarivoEnvironmentError('shared-runtime-identity-mismatch', 'Shared Runtime returned an incomplete or mismatched package identity', { probe, ...(repair === undefined ? {} : { repairCommands: repair.commands }) });
     }
     const actualPython = await realpath(path.resolve(probe.python_executable));
     const selectedPython = await realpath(canonical);
@@ -202,18 +209,20 @@ async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, rep
         });
     }
     if (!probe.pandas_supported) {
-        throw new MarivoEnvironmentError('shared-runtime-pandas-unsupported', `Shared Runtime pandas ${probe.pandas_version} is unsupported; install ${REPORT_KIT_PANDAS_RANGE}.${repair === undefined ? '' : ` ${repair.message}`}`, {
-            supportedPandasRange: REPORT_KIT_PANDAS_RANGE,
+        throw new MarivoEnvironmentError('shared-runtime-pandas-unsupported', `Shared Runtime pandas ${probe.pandas_version} is unsupported; install ${PRESENTATION_KIT_PANDAS_RANGE}.${repair === undefined ? '' : ` ${repair.message}`}`, {
+            supportedPandasRange: PRESENTATION_KIT_PANDAS_RANGE,
             actualPandasVersion: probe.pandas_version,
             ...(repair === undefined ? {} : { repairCommands: repair.commands }),
         });
     }
-    if (probe.report_kit_version !== REPORT_KIT_VERSION) {
-        throw new MarivoEnvironmentError('shared-runtime-report-kit-unsupported', `Shared Runtime report kit ${probe.report_kit_version} is unsupported; install ${REPORT_KIT_VERSION} from ${reportKitWheel}.${repair === undefined ? '' : ` ${repair.message}`}`, {
-            supportedReportKitVersion: REPORT_KIT_VERSION,
-            actualReportKitVersion: probe.report_kit_version,
-            reportKitPackagePath: probe.report_kit_package_path,
-            reportKitWheel,
+    if (probe.presentation_kit_version !== PRESENTATION_KIT_VERSION ||
+        probe.presentation_kit_distribution_version !== PRESENTATION_KIT_VERSION) {
+        throw new MarivoEnvironmentError('shared-runtime-presentation-kit-unsupported', `Shared Runtime presentation kit module ${probe.presentation_kit_version} and distribution ${probe.presentation_kit_distribution_version} must both be ${PRESENTATION_KIT_VERSION}; install from ${presentationKitWheel}.${repair === undefined ? '' : ` ${repair.message}`}`, {
+            supportedPresentationKitVersion: PRESENTATION_KIT_VERSION,
+            actualPresentationKitVersion: probe.presentation_kit_version,
+            actualPresentationKitDistributionVersion: probe.presentation_kit_distribution_version,
+            presentationKitPackagePath: probe.presentation_kit_package_path,
+            presentationKitWheel,
             ...(repair === undefined ? {} : { repairCommands: repair.commands }),
         });
     }
@@ -230,9 +239,11 @@ async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, rep
         package_path: path.resolve(probe.package_path),
         pandas_version: probe.pandas_version,
         pandas_supported: probe.pandas_supported,
-        report_kit_version: probe.report_kit_version,
-        report_kit_package_path: path.resolve(probe.report_kit_package_path),
-        report_kit_public_imports: true,
+        presentation_kit_version: probe.presentation_kit_version,
+        presentation_kit_distribution_version: probe.presentation_kit_distribution_version,
+        presentation_kit_package_path: path.resolve(probe.presentation_kit_package_path),
+        presentation_kit_import_identity: true,
+        presentation_kit_public_imports: true,
     };
 }
 async function validateSkills(skillsRoot) {
@@ -308,12 +319,12 @@ async function readInstallation(runtimeRoot) {
             'marivoVersion',
             'packagePath',
             'pythonExecutable',
-            'reportAdapterKind',
-            'reportKitPackagePath',
-            'reportKitVersion',
+            'presentationKitDistribution',
+            'presentationKitPackagePath',
+            'presentationKitVersion',
             'schema',
             'skillsRoot',
-        ];
+        ].sort();
         if (fields.length !== expectedFields.length ||
             fields.some((field, index) => field !== expectedFields[index]) ||
             record.schema !== INSTALLATION_SCHEMA ||
@@ -323,11 +334,11 @@ async function readInstallation(runtimeRoot) {
             record.pythonExecutable.length === 0 ||
             typeof record.packagePath !== 'string' ||
             record.packagePath.length === 0 ||
-            record.reportAdapterKind !== REPORT_ADAPTER_KIND ||
-            typeof record.reportKitVersion !== 'string' ||
-            record.reportKitVersion.length === 0 ||
-            typeof record.reportKitPackagePath !== 'string' ||
-            record.reportKitPackagePath.length === 0 ||
+            record.presentationKitDistribution !== PRESENTATION_KIT_DISTRIBUTION ||
+            typeof record.presentationKitVersion !== 'string' ||
+            record.presentationKitVersion.length === 0 ||
+            typeof record.presentationKitPackagePath !== 'string' ||
+            record.presentationKitPackagePath.length === 0 ||
             typeof record.skillsRoot !== 'string' ||
             record.skillsRoot.length === 0)
             return undefined;
@@ -349,13 +360,13 @@ async function writeInstallation(runtimeRoot, record) {
     await rename(temporary, installationPath);
     return installationPath;
 }
-async function validatedExisting(runtimeRoot, configuredPython, environment, timeoutMs, reportKitWheel) {
+async function validatedExisting(runtimeRoot, configuredPython, environment, timeoutMs, presentationKitWheel) {
     const record = await readInstallation(runtimeRoot);
     if (record === undefined)
         return undefined;
     if (record.marivoVersion !== PINNED_MARIVO_VERSION)
         return undefined;
-    if (record.reportKitVersion !== REPORT_KIT_VERSION)
+    if (record.presentationKitVersion !== PRESENTATION_KIT_VERSION)
         return undefined;
     const expectedPython = configuredPython ?? venvPython(runtimeRoot);
     const expectedSkillsRoot = path.join(runtimeRoot, 'skills');
@@ -365,10 +376,11 @@ async function validatedExisting(runtimeRoot, configuredPython, environment, tim
         const selectedPython = await assertExecutable(expectedPython);
         if (path.normalize(record.pythonExecutable) !== selectedPython)
             return undefined;
-        const probe = await probeRuntime(runtimeRoot, selectedPython, environment, timeoutMs, reportKitWheel, configuredPython !== undefined, record.marivoVersion);
+        const probe = await probeRuntime(runtimeRoot, selectedPython, environment, timeoutMs, presentationKitWheel, configuredPython !== undefined, record.marivoVersion);
         if (path.normalize(probe.package_path) !== path.normalize(record.packagePath))
             return undefined;
-        if (path.normalize(probe.report_kit_package_path) !== path.normalize(record.reportKitPackagePath))
+        if (path.normalize(probe.presentation_kit_package_path) !==
+            path.normalize(record.presentationKitPackagePath))
             return undefined;
         await validateSkills(record.skillsRoot);
         return {
@@ -376,8 +388,8 @@ async function validatedExisting(runtimeRoot, configuredPython, environment, tim
             pythonExecutable: probe.python_executable,
             marivoVersion: probe.marivo_version,
             packagePath: probe.package_path,
-            reportKitVersion: probe.report_kit_version,
-            reportKitPackagePath: probe.report_kit_package_path,
+            presentationKitVersion: probe.presentation_kit_version,
+            presentationKitPackagePath: probe.presentation_kit_package_path,
             skillsRoot: record.skillsRoot,
             installationPath: path.join(runtimeRoot, INSTALLATION_FILENAME),
         };
@@ -451,53 +463,51 @@ async function backupInvalidRuntime(runtimeRoot) {
     }
     await rename(runtimeRoot, `${runtimeRoot}.invalid-${Date.now()}-${randomUUID()}`);
 }
-async function installManagedRuntime(runtimeRoot, uvExecutable, reportKitWheel, environment, timeoutMs) {
+async function installManagedRuntime(runtimeRoot, bootstrapPythonExecutable, presentationKitWheel, environment, timeoutMs) {
     const policy = new FixedSubprocessPolicy(runtimeRoot, environment);
     const limits = { timeoutMs, stdoutMaxBytes: 1_048_576, stderrMaxBytes: 1_048_576 };
-    requireSuccess('install managed Python', await policy.run({
-        executable: uvExecutable,
-        args: ['python', 'install', SHARED_PYTHON_SPEC],
-        limits,
-    }));
-    const found = requireSuccess('resolve managed Python', await policy.run({
-        executable: uvExecutable,
-        args: ['python', 'find', '--managed-python', SHARED_PYTHON_SPEC],
-        limits,
-    }));
-    const managedPython = found.stdout.toString('utf8').trim();
-    if (!path.isAbsolute(managedPython)) {
-        throw new MarivoEnvironmentError('shared-runtime-install-failed', 'uv returned a non-absolute managed Python path', { managedPython });
-    }
-    const canonicalManagedPython = await assertExecutable(managedPython);
-    const version = parseJsonObject('validate managed Python', await policy.run({
-        executable: canonicalManagedPython,
-        args: ['-c', PYTHON_VERSION_SCRIPT],
-        limits,
-    }));
+    let version;
+    try {
+        version = parseJsonObject('validate local Python', await policy.run({
+            executable: bootstrapPythonExecutable,
+            args: ['-c', PYTHON_VERSION_SCRIPT],
+            limits,
+        }));
+    }
+    catch (error) {
+        if (!(error instanceof MarivoEnvironmentError))
+            throw error;
+        throw new MarivoEnvironmentError('shared-runtime-install-failed', 'Could not validate local Python. Install Python 3.10+ with venv/ensurepip, or set bootstrapPythonExecutable to its absolute path.', { pythonExecutable: bootstrapPythonExecutable, causeCode: error.code });
+    }
     if (!Array.isArray(version.version) ||
         typeof version.version[0] !== 'number' ||
         typeof version.version[1] !== 'number' ||
         version.version[0] < 3 ||
         (version.version[0] === 3 && version.version[1] < 10)) {
-        throw new MarivoEnvironmentError('shared-runtime-install-failed', 'uv managed Python does not satisfy Marivo >=3.10', { version: version.version, pythonExecutable: canonicalManagedPython });
+        throw new MarivoEnvironmentError('shared-runtime-install-failed', `Local Python does not satisfy Marivo >=${SHARED_PYTHON_SPEC}; detected ${Array.isArray(version.version) ? version.version.join('.') : 'unknown'}`, { version: version.version, pythonExecutable: bootstrapPythonExecutable });
+    }
+    if (typeof version.python_executable !== 'string' ||
+        !path.isAbsolute(version.python_executable)) {
+        throw new MarivoEnvironmentError('shared-runtime-install-failed', 'Local Python returned a non-absolute interpreter path');
     }
-    requireSuccess('create shared virtual environment', await policy.run({
-        executable: uvExecutable,
-        args: ['venv', '--python', canonicalManagedPython, '--seed', path.join(runtimeRoot, '.venv')],
+    const canonicalPython = await assertExecutable(version.python_executable);
+    requireSuccess('create shared virtual environment (requires Python venv/ensurepip; install python3-venv on Debian/Ubuntu)', await policy.run({
+        executable: canonicalPython,
+        args: ['-m', 'venv', path.join(runtimeRoot, '.venv')],
         limits,
     }));
     const executable = venvPython(runtimeRoot);
     requireSuccess(`install Marivo ${PINNED_MARIVO_VERSION}`, await policy.run({
-        executable: uvExecutable,
-        args: ['pip', 'install', '--python', executable, '--upgrade', SHARED_MARIVO_PACKAGE_SPEC],
+        executable,
+        args: ['-m', 'pip', 'install', '--upgrade', SHARED_MARIVO_PACKAGE_SPEC],
         limits,
     }));
-    requireSuccess(`install report kit ${REPORT_KIT_VERSION}`, await policy.run({
-        executable: uvExecutable,
-        args: ['pip', 'install', '--python', executable, '--no-deps', reportKitWheel],
+    requireSuccess(`install presentation kit ${PRESENTATION_KIT_VERSION}`, await policy.run({
+        executable,
+        args: ['-m', 'pip', 'install', '--no-deps', presentationKitWheel],
         limits,
     }));
-    return probeRuntime(runtimeRoot, executable, environment, timeoutMs, reportKitWheel, false, PINNED_MARIVO_VERSION);
+    return probeRuntime(runtimeRoot, executable, environment, timeoutMs, presentationKitWheel, false, PINNED_MARIVO_VERSION);
 }
 /** Ensure and validate the one DSH-home-owned Marivo installation. */
 export async function ensureSharedMarivoRuntime(config = {}, options = {}) {
@@ -507,37 +517,39 @@ export async function ensureSharedMarivoRuntime(config = {}, options = {}) {
     const configuredPython = config.pythonExecutable === undefined
         ? undefined
         : normalizeAbsolute('pythonExecutable', config.pythonExecutable);
-    const uvExecutable = config.uvExecutable === undefined
-        ? 'uv'
-        : normalizeAbsolute('uvExecutable', config.uvExecutable);
+    const bootstrapPythonExecutable = config.bootstrapPythonExecutable === undefined
+        ? process.platform === 'win32'
+            ? 'python'
+            : 'python3'
+        : normalizeAbsolute('bootstrapPythonExecutable', config.bootstrapPythonExecutable);
     const timeoutMs = positiveTimeout(config.installTimeoutMs);
-    const reportKitWheel = path.normalize(path.resolve(options.reportKitWheelPath ?? bundledReportKitWheel()));
-    const existing = await validatedExisting(runtimeRoot, configuredPython, options.environment, timeoutMs, reportKitWheel);
+    const presentationKitWheel = path.normalize(path.resolve(options.presentationKitWheelPath ?? bundledPresentationKitWheel()));
+    const existing = await validatedExisting(runtimeRoot, configuredPython, options.environment, timeoutMs, presentationKitWheel);
     if (existing !== undefined)
         return existing;
     await mkdir(path.dirname(runtimeRoot), { recursive: true });
     const lockPath = `${runtimeRoot}.install-lock`;
     const release = await acquireLock(lockPath, timeoutMs, options.waitIntervalMs ?? 100);
     try {
-        const afterLock = await validatedExisting(runtimeRoot, configuredPython, options.environment, timeoutMs, reportKitWheel);
+        const afterLock = await validatedExisting(runtimeRoot, configuredPython, options.environment, timeoutMs, presentationKitWheel);
         if (afterLock !== undefined)
             return afterLock;
         if (configuredPython === undefined)
-            await assertReportKitWheel(reportKitWheel);
+            await assertPresentationKitWheel(presentationKitWheel);
         await backupInvalidRuntime(runtimeRoot);
         await mkdir(runtimeRoot, { recursive: true });
         const probe = configuredPython === undefined
-            ? await installManagedRuntime(runtimeRoot, uvExecutable, reportKitWheel, options.environment, timeoutMs)
-            : await probeRuntime(runtimeRoot, configuredPython, options.environment, timeoutMs, reportKitWheel, true, PINNED_MARIVO_VERSION);
+            ? await installManagedRuntime(runtimeRoot, bootstrapPythonExecutable, presentationKitWheel, options.environment, timeoutMs)
+            : await probeRuntime(runtimeRoot, configuredPython, options.environment, timeoutMs, presentationKitWheel, true, PINNED_MARIVO_VERSION);
         const skillsRoot = await syncSkills(runtimeRoot, probe.package_path);
         const record = {
             schema: INSTALLATION_SCHEMA,
             marivoVersion: probe.marivo_version,
             pythonExecutable: probe.python_executable,
             packagePath: probe.package_path,
-            reportAdapterKind: REPORT_ADAPTER_KIND,
-            reportKitVersion: probe.report_kit_version,
-            reportKitPackagePath: probe.report_kit_package_path,
+            presentationKitDistribution: PRESENTATION_KIT_DISTRIBUTION,
+            presentationKitVersion: probe.presentation_kit_version,
+            presentationKitPackagePath: probe.presentation_kit_package_path,
             skillsRoot,
         };
         const installationPath = await writeInstallation(runtimeRoot, record);
@@ -546,8 +558,8 @@ export async function ensureSharedMarivoRuntime(config = {}, options = {}) {
             pythonExecutable: probe.python_executable,
             marivoVersion: probe.marivo_version,
             packagePath: probe.package_path,
-            reportKitVersion: probe.report_kit_version,
-            reportKitPackagePath: probe.report_kit_package_path,
+            presentationKitVersion: probe.presentation_kit_version,
+            presentationKitPackagePath: probe.presentation_kit_package_path,
             skillsRoot,
             installationPath,
         };

package/lib/environment/subprocess.js

@@ -71,7 +71,7 @@ export class FixedSubprocessPolicy {
                 shell: false,
                 windowsHide: true,
                 detached: process.platform !== 'win32',
-                stdio: ['ignore', 'pipe', 'pipe'],
+                stdio: ['pipe', 'pipe', 'pipe'],
             });
             let child;
             try {
@@ -84,6 +84,9 @@ export class FixedSubprocessPolicy {
                 }));
                 return;
             }
+            // A child may reject its input before all bytes are written. Do not log payloads.
+            child.stdin.on('error', () => { });
+            child.stdin.end(request.stdin);
             const stdout = [];
             const stderr = [];
             let stdoutBytes = 0;
@@ -127,6 +130,8 @@ export class FixedSubprocessPolicy {
             timeout.unref();
             const onAbort = () => terminate(new MarivoEnvironmentError('subprocess-cancelled', 'Marivo subprocess was cancelled'));
             request.signal?.addEventListener('abort', onAbort, { once: true });
+            if (request.signal?.aborted)
+                onAbort();
             child.stdout.on('data', (chunk) => {
                 stdoutBytes += chunk.byteLength;
                 if (stdoutBytes > limits.stdoutMaxBytes) {

package/lib/environment/summary.js

@@ -10,9 +10,9 @@ export function environmentPayload(runtime, environment) {
             version: environment.binding.marivoVersion,
             packagePath: environment.binding.packagePath,
         },
-        reportKit: {
-            version: runtime.reportKitVersion,
-            packagePath: runtime.reportKitPackagePath,
+        presentationKit: {
+            version: runtime.presentationKitVersion,
+            packagePath: runtime.presentationKitPackagePath,
         },
         fingerprint: environment.binding.fingerprint,
     };