create-principles-disciple 1.121.7 → 1.121.9

package/dist/installer.js

@@ -2,15 +2,17 @@ import { existsSync, readdirSync, statSync, readFileSync, writeFileSync, mkdirSy
 import fse from 'fs-extra';
 import * as path from 'path';
 import * as http from 'http';
-import { execSync, execFileSync, spawn } from 'child_process';
+import { execFileSync, spawn } from 'child_process';
 import ora from 'ora';
 import { select } from '@inquirer/prompts';
 import { logger } from './utils/logger.js';
 import { checkOpenClawGateway, stopOpenClawGateway, restartOpenClawGateway } from './utils/env.js';
 import { t } from './i18n.js';
-import { generateConfigYamlContent, HostRuntimeConfigMigrationInfraError, migrateHostRuntimeFlagsInConfigYaml, getConfigYamlPath, readEnabledChannelsFromConfigYaml, getOpenClawDir, getPluginExtDir, getPdBackupsDir, getInstalledPdCliDir, getInstalledBinDir, getInstalledConsoleDir, isWindows, } from './mvp-config.js';
+import { generateConfigYamlContent, HostRuntimeConfigMigrationInfraError, migrateHostRuntimeFlagsInConfigYaml, getConfigYamlPath, readEnabledChannelsFromConfigYaml, getOpenClawDir, getPdDir, getPdRuntimeDir, getInstallManifestPath, getPdRuntimeBackupsDir, getPluginExtDir, getInstalledPluginDir, getInstalledLayoutPackageDir, getPdBackupsDir, getInstalledPdCliDir, getInstalledBinDir, getInstalledConsoleDir, isWindows, } from './mvp-config.js';
 import { getHostInstallers } from './installers/index.js';
+import { parseInstallManifest } from '@principles/install-layout';
 import { applySkillLanguageSelection } from './skill-language.js';
+import { parseReleaseAssetIdentity, parseReleaseAssetManifest, ReleaseAssetManifestError, verifyReleaseAssetManifestAsync, verifyReleaseAssetTarget, } from './update/release-asset-manifest.js';
 /** PRI-343: Keep in sync with @principles/core CONVERSATION_ACCESS_CONFIG_KEY */
 export const CONVERSATION_ACCESS_CONFIG_KEY = 'allowConversationAccess';
 function isRecord(value) {
@@ -56,35 +58,125 @@ export function ensureConversationAccess(config) {
 }
 const INSTALL_TIMEOUT_MS = parseInt(process.env.PD_INSTALL_TIMEOUT_MS || '300000', 10);
 // 超时常量
-const PD_CLI_VERIFICATION_TIMEOUT_MS = 10_000;
+const PD_CLI_VERIFICATION_TIMEOUT_MS = 30_000;
 const STORY_A_VERIFICATION_TIMEOUT_MS = 30_000;
 const CONSOLE_HEALTH_CHECK_TIMEOUT_MS = 8_000;
 const CONSOLE_WARMUP_TIME_MS = 6_000;
-// 端口范围常量
-const CONSOLE_PORT_RANGE_MIN = 3100;
-const CONSOLE_PORT_RANGE_MAX = 3199;
-// Task 8: auto-launch console via `pd console open` after successful install
-const CONSOLE_AUTOLAUNCH_BASE_PORT = 3100;
-const CONSOLE_AUTOLAUNCH_PORT_SCAN_LIMIT = 20; // 3100..3119 (matches pd console open PORT_FALLBACK_LIMIT)
+// 端口范围常量。PD_CONSOLE_PORT_BASE 允许在操作系统保留了大段端口
+// (如 Windows excludedportrange) 的机器上整体平移探测窗口；未设置时
+// 保持历史默认 3100–3199。resolveConsolePortBase() 是唯一 resolved
+// base：安装验证窗口、console 健康检查、autolaunch 扫描、测试全部
+// 消费它——任何新窗口不得再硬编码第二个 base。
+export function resolveConsolePortBase() {
+    const raw = process.env.PD_CONSOLE_PORT_BASE;
+    if (raw === undefined)
+        return 3100;
+    // Number() (not parseInt) so '3300.5' is rejected instead of silently
+    // truncating to 3300.
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 1024 || parsed > 65000) {
+        throw new Error(`PD_CONSOLE_PORT_BASE must be an integer in [1024, 65000], got: ${JSON.stringify(raw)}`);
+    }
+    return parsed;
+}
+const CONSOLE_PORT_RANGE_MIN = resolveConsolePortBase();
+const CONSOLE_PORT_RANGE_MAX = CONSOLE_PORT_RANGE_MIN + 99;
+// Task 8: auto-launch console via `pd console open` after successful install.
+// Derived from the SAME resolved base as the verification window above.
+const CONSOLE_AUTOLAUNCH_BASE_PORT = CONSOLE_PORT_RANGE_MIN;
+const CONSOLE_AUTOLAUNCH_PORT_SCAN_LIMIT = 20; // base..base+19 (matches pd console open PORT_FALLBACK_LIMIT)
 const CONSOLE_AUTOLAUNCH_READY_TIMEOUT_MS = 12_000;
 const CONSOLE_AUTOLAUNCH_POLL_INTERVAL_MS = 500;
 // 允许的原生模块白名单
 const ALLOWED_NATIVE_MODULES = ['better-sqlite3'];
-function getCapturingExecOptions(cwd, timeoutOverride) {
-    return {
-        cwd,
-        stdio: 'pipe',
-        env: process.env,
-        timeout: timeoutOverride ?? INSTALL_TIMEOUT_MS,
-    };
+// Shared components use ~/.pd/runtime. The plugin package is host-neutral for
+// Codex-only installs; OpenClaw/all still receive their adapter copy under
+// ~/.openclaw/extensions for host discovery.
+let activeHostTarget = 'openclaw';
+function installsOpenClaw(host) {
+    return host === 'openclaw' || host === 'all';
+}
+function installedPluginDir() {
+    return getInstalledPluginDir();
+}
+function pluginInstallDirs() {
+    return installsOpenClaw(activeHostTarget)
+        ? [getInstalledPluginDir(), getPluginExtDir()]
+        : [getInstalledPluginDir()];
+}
+export function mergeInstallManifestHosts(current, host) {
+    const hosts = new Set();
+    const parsed = parseInstallManifest(current);
+    if (current !== undefined && !parsed.manifest) {
+        throw new Error(parsed.error ?? 'install_manifest_malformed');
+    }
+    for (const existingHost of parsed.manifest?.hosts ?? [])
+        hosts.add(existingHost);
+    if (host === 'all' || host === 'codex')
+        hosts.add('codex');
+    if (host === 'all' || host === 'openclaw')
+        hosts.add('openclaw');
+    return [...hosts];
+}
+function resolveInstallManifestHosts(host) {
+    let current;
+    try {
+        current = JSON.parse(readFileSync(getInstallManifestPath(), 'utf8'));
+    }
+    catch (error) {
+        if (existsSync(getInstallManifestPath()))
+            throw error;
+    }
+    return mergeInstallManifestHosts(current, host);
+}
+function writeInstallManifest(hosts) {
+    mkdirSync(getPdDir(), { recursive: true });
+    writeFileSync(getInstallManifestPath(), JSON.stringify({ layoutVersion: 1, mode: 'canonical', hosts }, null, 2) + '\n', 'utf8');
+}
+function installBundledLayoutPackage(pluginDir) {
+    const source = path.join(pluginDir, 'install-layout');
+    const destination = getInstalledLayoutPackageDir();
+    if (!existsSync(path.join(source, 'package.json')) || !existsSync(path.join(source, 'dist'))) {
+        throw new Error('Bundled @principles/install-layout is incomplete. Re-run the installer with a current package.');
+    }
+    rmSync(destination, { recursive: true, force: true });
+    cpSync(source, destination, { recursive: true });
+}
+/**
+ * Run npm with array-form argv, no shell (PRI-569 hardening).
+ *
+ * On Windows `npm` is an npm.cmd shim: Node cannot spawn .cmd without a
+ * shell (EINVAL/ENOENT), so win32 routes through cmd.exe with CONSTANT argv
+ * elements — args are compile-time literals at every call site; the one
+ * external-derived value (registry version) is regex-guarded before use.
+ * Returns captured stdout (encoding utf-8).
+ */
+function execNpm(args, cwd, timeoutOverride) {
+    // encoding:'utf-8' resolves the string overload of execFileSync (TS-typed);
+    // callers and tests must honor that contract (string output).
+    return (process.platform === 'win32'
+        ? execFileSync('cmd.exe', ['/c', 'npm', ...args], {
+            cwd,
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            env: process.env,
+            windowsHide: true,
+            timeout: timeoutOverride ?? INSTALL_TIMEOUT_MS,
+        })
+        : execFileSync('npm', args, {
+            cwd,
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            env: process.env,
+            timeout: timeoutOverride ?? INSTALL_TIMEOUT_MS,
+        })).trim();
 }
 /**
  * 执行 npm install 并提供友好的错误提示
  */
 async function runNpmInstall(cwd, componentName = 'npm') {
-    const execOpts = getCapturingExecOptions(cwd);
     try {
-        execSync('npm install --ignore-scripts --legacy-peer-deps', execOpts);
+        execNpm(['install', '--ignore-scripts', '--legacy-peer-deps'], cwd);
     }
     catch (e) {
         const errorMsg = e instanceof Error ? e.message : String(e);
@@ -101,23 +193,10 @@ async function runNpmInstall(cwd, componentName = 'npm') {
     }
 }
 /**
- * 重建原生模块
- */
-export async function rebuildNativeModules(cwd, componentName) {
-    for (const mod of ALLOWED_NATIVE_MODULES) {
-        const modPath = path.join(cwd, 'node_modules', mod);
-        if (!existsSync(modPath))
-            continue;
-        try {
-            execSync(`npm rebuild ${mod}`, getCapturingExecOptions(cwd));
-        }
-        catch (e) {
-            throw new Error(`${componentName} native module ${mod} rebuild failed: ${e instanceof Error ? e.message : String(e)}. Try manually: cd ${cwd} && npm rebuild ${mod}`, { cause: e });
-        }
-    }
-}
-/**
- * 验证原生模块
+ * 验证原生模块：better-sqlite3 随发布资产携带 prebuilt 二进制
+ * (prebuilds/*.node)，node-gyp-build 在 require 时解析——无需（也没有）
+ * npm rebuild 步骤。本函数的 require 探针就是唯一验证（历史上存在一个
+ * 名为 rebuildNativeModules 的空壳函数，已删除以避免误导维护者）。
  */
 export function verifyNativeModules(cwd, componentName) {
     for (const nativeMod of ALLOWED_NATIVE_MODULES) {
@@ -128,10 +207,147 @@ export function verifyNativeModules(cwd, componentName) {
             execFileSync(process.execPath, ['-e', `require('${nativeMod}')`], { cwd, stdio: 'pipe' });
         }
         catch {
-            throw new Error(`${componentName} native module ${nativeMod} verification failed after rebuild. The install cannot proceed.`);
+            throw new Error(`${componentName} native module ${nativeMod} failed its require probe: the prebuilt binary for this Node.js ABI is missing or incompatible (no rebuild step exists by design). Install the platform release asset matching this OS, architecture, and ABI.`);
         }
     }
 }
+const SELF_CONTAINED_DEPENDENCY_NEXT_ACTION = 'Install a complete platform release asset for this Node.js ABI and re-run the installer.';
+const SELF_CONTAINED_NATIVE_NEXT_ACTION = 'Install the platform release asset matching this operating system, architecture, and Node.js ABI.';
+export class SelfContainedDependencyError extends Error {
+    reason;
+    nextAction;
+    component;
+    dependency;
+    constructor(options) {
+        super(options.message, { cause: options.cause });
+        this.name = 'SelfContainedDependencyError';
+        this.reason = options.reason;
+        this.nextAction = options.nextAction;
+        this.component = options.component;
+        this.dependency = options.dependency;
+    }
+}
+function legacyNpmInstallEnabled() {
+    const value = process.env.PD_ALLOW_LEGACY_NPM_INSTALL;
+    return value === '1' || value === 'true';
+}
+/**
+ * Supported release assets are self-contained: installation validates the
+ * copied component and never resolves dependencies or runs lifecycle scripts.
+ * The old npm path remains opt-in for development/legacy recovery only.
+ */
+export async function prepareBundledComponentDependencies(cwd, componentName) {
+    const packageJsonPath = path.join(cwd, 'package.json');
+    let packageJsonRaw;
+    try {
+        packageJsonRaw = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    }
+    catch (error) {
+        throw new SelfContainedDependencyError({
+            reason: 'self_contained_package_manifest_invalid',
+            nextAction: SELF_CONTAINED_DEPENDENCY_NEXT_ACTION,
+            message: `${componentName} package.json is missing or malformed after copy.`,
+            component: componentName,
+            cause: error,
+        });
+    }
+    if (!isRecord(packageJsonRaw)) {
+        throw new SelfContainedDependencyError({
+            reason: 'self_contained_package_manifest_invalid',
+            nextAction: SELF_CONTAINED_DEPENDENCY_NEXT_ACTION,
+            message: `${componentName} package.json must contain an object.`,
+            component: componentName,
+        });
+    }
+    const { dependencies } = packageJsonRaw;
+    if (dependencies !== undefined && !isRecord(dependencies)) {
+        throw new SelfContainedDependencyError({
+            reason: 'self_contained_package_manifest_invalid',
+            nextAction: SELF_CONTAINED_DEPENDENCY_NEXT_ACTION,
+            message: `${componentName} package.json dependencies must contain an object.`,
+            component: componentName,
+        });
+    }
+    for (const dependency of Object.keys(dependencies ?? {})) {
+        if (!existsSync(path.join(cwd, 'node_modules', dependency))) {
+            throw new SelfContainedDependencyError({
+                reason: 'self_contained_runtime_dependency_missing',
+                nextAction: SELF_CONTAINED_DEPENDENCY_NEXT_ACTION,
+                message: `${componentName} self-contained release asset is missing declared runtime dependency ${dependency}.`,
+                component: componentName,
+                dependency,
+            });
+        }
+    }
+    try {
+        verifyNativeModules(cwd, componentName);
+    }
+    catch (error) {
+        throw new SelfContainedDependencyError({
+            reason: 'self_contained_native_module_unloadable',
+            nextAction: SELF_CONTAINED_NATIVE_NEXT_ACTION,
+            message: `${componentName} bundled better-sqlite3 cannot be loaded by this Node.js runtime.`,
+            component: componentName,
+            dependency: 'better-sqlite3',
+            cause: error,
+        });
+    }
+}
+const SELF_CONTAINED_COMPONENTS = [
+    ['Core', 'core'],
+    ['Host runtime', 'host-runtime'],
+    ['Plugin', 'plugin'],
+    ['PD CLI', 'pd-cli'],
+    ['Console', 'console'],
+    ['Install layout', 'install-layout'],
+];
+export async function preflightSelfContainedReleaseAsset(assetDir) {
+    const identityPath = path.join(assetDir, '_release', 'asset.json');
+    let identityValue;
+    try {
+        identityValue = JSON.parse(readFileSync(identityPath, 'utf8'));
+        const identity = parseReleaseAssetIdentity(identityValue);
+        verifyReleaseAssetTarget(identity, {
+            platform: process.platform,
+            arch: process.arch,
+            nodeAbi: process.versions.modules,
+        });
+    }
+    catch (error) {
+        const targetMismatch = error instanceof ReleaseAssetManifestError && error.code === 'asset_target_mismatch';
+        throw new SelfContainedDependencyError({
+            reason: targetMismatch ? 'self_contained_asset_target_mismatch' : 'self_contained_asset_identity_invalid',
+            nextAction: targetMismatch ? SELF_CONTAINED_NATIVE_NEXT_ACTION : SELF_CONTAINED_DEPENDENCY_NEXT_ACTION,
+            message: error instanceof Error ? error.message : 'Release asset identity is missing or malformed.',
+            component: 'Release asset',
+            cause: error,
+        });
+    }
+    try {
+        const manifestValue = JSON.parse(readFileSync(path.join(assetDir, '_release', 'manifest.json'), 'utf8'));
+        await verifyReleaseAssetManifestAsync(assetDir, parseReleaseAssetManifest(manifestValue));
+    }
+    catch (error) {
+        throw new SelfContainedDependencyError({
+            reason: 'self_contained_asset_integrity_invalid',
+            nextAction: SELF_CONTAINED_DEPENDENCY_NEXT_ACTION,
+            message: error instanceof Error ? error.message : 'Release asset manifest is missing, malformed, or does not match its files.',
+            component: 'Release asset',
+            cause: error,
+        });
+    }
+    for (const [componentName, componentDirectory] of SELF_CONTAINED_COMPONENTS) {
+        await prepareBundledComponentDependencies(path.join(assetDir, componentDirectory), componentName);
+    }
+}
+async function prepareComponentDependencies(cwd, componentName) {
+    if (!legacyNpmInstallEnabled()) {
+        await prepareBundledComponentDependencies(cwd, componentName);
+        return;
+    }
+    await runNpmInstall(cwd, componentName);
+    verifyNativeModules(cwd, componentName);
+}
 /**
  * 验证路径是否在工作区目录内，防止路径遍历攻击
  */
@@ -147,17 +363,18 @@ const INSTALL_STEPS = [
     { name: 'Checking workspace rule compatibility', weight: 1 },
     { name: 'Backing up existing install', weight: 3 },
     { name: 'Installing bundled @principles/core', weight: 8 },
+    { name: 'Validating bundled core dependencies', weight: 5 },
     { name: 'Installing bundled @principles/host-runtime', weight: 3 },
-    { name: 'Installing core dependencies', weight: 10 },
+    { name: 'Validating bundled host runtime dependencies', weight: 5 },
     { name: 'Installing plugin', weight: 10 },
     { name: 'Preparing core library for plugin', weight: 3 },
-    { name: 'Installing plugin dependencies', weight: 20 },
+    { name: 'Validating bundled plugin dependencies', weight: 10 },
     { name: 'Installing pd CLI', weight: 8 },
     { name: 'Preparing core library for pd-cli', weight: 3 },
     { name: 'Verifying pd CLI', weight: 3 },
     { name: 'Installing pd-console', weight: 8 },
     { name: 'Preparing core library for console', weight: 3 },
-    { name: 'Installing console dependencies', weight: 10 },
+    { name: 'Validating bundled console dependencies', weight: 5 },
     { name: 'Verifying pd-console', weight: 3 },
     { name: 'Copying templates', weight: 3 },
     { name: 'Generating config.yaml', weight: 2 },
@@ -224,34 +441,51 @@ export function migrateLegacyPdBackups() {
 /**
  * Exported for real-filesystem tests (tests/backup-location.test.ts).
  */
-export function backupExistingInstall() {
+export function backupExistingInstall(host = 'openclaw') {
     const extDir = getPluginExtDir();
-    if (!existsSync(extDir))
+    const runtimeDir = getPdRuntimeDir();
+    const hasExt = installsOpenClaw(host) && existsSync(extDir);
+    const hasRuntime = existsSync(runtimeDir);
+    if (!hasExt && !hasRuntime)
         return { type: 'no_existing', backupDir: null };
     // The backup must live OUTSIDE the extensions dir (see getPdBackupsDir):
     // OpenClaw plugin discovery scans every extensions/ child directory and
     // would discover the backup as a second principles-disciple plugin.
-    const backupsDir = getPdBackupsDir();
-    const backupDir = path.join(backupsDir, `principles-disciple.backup.${Date.now()}`);
+    const backupsDir = hasExt ? getPdBackupsDir() : getPdRuntimeBackupsDir();
+    const timestamp = Date.now();
+    const backupDir = hasExt ? path.join(backupsDir, `principles-disciple.backup.${timestamp}`) : null;
+    const runtimeBackupDir = hasRuntime ? path.join(getPdRuntimeBackupsDir(), `runtime.backup.${timestamp}`) : null;
     try {
         mkdirSync(backupsDir, { recursive: true });
-        renameSync(extDir, backupDir);
-        logger.info(`Backed up existing install to ${backupDir}`);
-        return { type: 'backed_up', backupDir };
+        if (backupDir)
+            renameSync(extDir, backupDir);
+        if (runtimeBackupDir) {
+            mkdirSync(getPdRuntimeBackupsDir(), { recursive: true });
+            renameSync(runtimeDir, runtimeBackupDir);
+        }
+        logger.info(`Backed up existing install to ${backupDir ?? runtimeBackupDir}`);
+        return { type: 'backed_up', backupDir, runtimeBackupDir };
     }
     catch (e) {
         throw new Error(`Could not backup existing install at ${extDir}: ${e instanceof Error ? e.message : String(e)}. Aborting to prevent data loss — resolve the lock or rename manually and re-run.`, { cause: e });
     }
 }
-function restoreBackup(backupDir) {
-    if (!backupDir || !existsSync(backupDir))
+function restoreBackup(backupDir, runtimeBackupDir) {
+    if ((!backupDir || !existsSync(backupDir)) && (!runtimeBackupDir || !existsSync(runtimeBackupDir)))
         return { restored: true };
     const extDir = getPluginExtDir();
+    const runtimeDir = getPdRuntimeDir();
     try {
-        if (existsSync(extDir)) {
+        if (backupDir && existsSync(extDir)) {
             rmSync(extDir, { recursive: true, force: true });
         }
-        renameSync(backupDir, extDir);
+        if (backupDir && existsSync(backupDir))
+            renameSync(backupDir, extDir);
+        if (runtimeBackupDir && existsSync(runtimeBackupDir)) {
+            if (existsSync(runtimeDir))
+                rmSync(runtimeDir, { recursive: true, force: true });
+            renameSync(runtimeBackupDir, runtimeDir);
+        }
         logger.info('Restored previous install from backup');
         return { restored: true };
     }
@@ -261,14 +495,16 @@ function restoreBackup(backupDir) {
         return { restored: false, error: msg };
     }
 }
-function cleanupBackup(backupDir) {
-    if (!backupDir || !existsSync(backupDir))
-        return;
-    try {
-        rmSync(backupDir, { recursive: true, force: true });
-    }
-    catch {
-        // non-fatal
+function cleanupBackup(backupDir, runtimeBackupDir) {
+    for (const backup of [backupDir, runtimeBackupDir]) {
+        if (!backup || !existsSync(backup))
+            continue;
+        try {
+            rmSync(backup, { recursive: true, force: true });
+        }
+        catch {
+            // non-fatal
+        }
     }
 }
 /**
@@ -532,17 +768,28 @@ export async function checkBuiltPlugin(pluginDir) {
     }
 }
 export async function installPluginToStaging(pluginDir, language) {
-    const extDir = getPluginExtDir();
     const builtPluginDir = path.join(pluginDir, 'plugin');
-    await fse.ensureDir(extDir);
-    await fse.copy(builtPluginDir, extDir, { overwrite: true });
-    // Skill-language selection: OpenClaw publishes skills by name with no
-    // locale mechanism, so the installed manifest must declare exactly one
-    // language root. The shipped manifest declares zh (product default);
-    // --lang en installs rewrite it to the en root here.
-    const selection = applySkillLanguageSelection(extDir, language);
-    if (!selection.applied) {
-        logger.warn(`Skill language "${language}" not applied (${selection.note ?? 'unknown'}) — published skills stay at the manifest default`);
+    for (const targetDir of pluginInstallDirs()) {
+        await fse.ensureDir(targetDir);
+        await fse.copy(builtPluginDir, targetDir, { overwrite: true });
+        // The published plugin declares its bundled core as file:./core. Keep that
+        // package-local contract while storing the actual core once in the shared
+        // host-neutral runtime directory.
+        const pluginCoreLink = path.join(targetDir, 'core');
+        if (!existsSync(pluginCoreLink)) {
+            const coreDir = path.join(getPdRuntimeDir(), 'core');
+            if (isWindows())
+                symlinkSync(coreDir, pluginCoreLink, 'junction');
+            else
+                symlinkSync(path.relative(targetDir, coreDir), pluginCoreLink, 'dir');
+        }
+        // OpenClaw publishes skills by name with no locale mechanism. Applying the
+        // same selected language to both copies also keeps the canonical package
+        // ready if another host is attached later.
+        const selection = applySkillLanguageSelection(targetDir, language);
+        if (!selection.applied) {
+            logger.warn(`Skill language "${language}" not applied at ${targetDir} (${selection.note ?? 'unknown'}) — published skills stay at the manifest default`);
+        }
     }
 }
 // ADR-0020 §2.3: The OpenClaw config write logic previously lived here as
@@ -551,42 +798,13 @@ export async function installPluginToStaging(pluginDir, language) {
 // `runHostInstallers()` below. This file no longer writes openclaw.json
 // directly — the HostInstaller interface keeps install/uninstall host-agnostic.
 async function installPluginDependencies() {
-    const extDir = getPluginExtDir();
-    const packageJsonPath = path.join(extDir, 'package.json');
-    const nodeModulesPath = path.join(extDir, 'node_modules');
-    if (!existsSync(packageJsonPath)) {
-        throw new Error('Plugin package.json not found after copy — install is corrupted');
-    }
-    const packageJsonRaw = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-    if (typeof packageJsonRaw !== 'object' || packageJsonRaw === null || Array.isArray(packageJsonRaw)) {
-        throw new Error('Plugin package.json is malformed');
-    }
-    const pkg = packageJsonRaw;
-    const deps = (typeof pkg.dependencies === 'object' && pkg.dependencies !== null && !Array.isArray(pkg.dependencies))
-        ? Object.keys(pkg.dependencies)
-        : [];
-    const devDeps = (typeof pkg.devDependencies === 'object' && pkg.devDependencies !== null && !Array.isArray(pkg.devDependencies))
-        ? Object.keys(pkg.devDependencies)
-        : [];
-    const allDeps = [...deps, ...devDeps];
-    let needsInstall = !existsSync(nodeModulesPath);
-    if (!needsInstall) {
-        for (const dep of allDeps) {
-            if (!existsSync(path.join(extDir, 'node_modules', dep))) {
-                needsInstall = true;
-                break;
-            }
-        }
-    }
-    if (needsInstall) {
-        await runNpmInstall(extDir, 'Plugin');
+    for (const extDir of pluginInstallDirs()) {
+        await prepareComponentDependencies(extDir, 'Plugin');
     }
-    await rebuildNativeModules(extDir, 'Plugin');
-    verifyNativeModules(extDir, 'Plugin');
 }
 function getNpmGlobalBinDir() {
     try {
-        const prefix = execSync('npm prefix -g', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const prefix = execNpm(['prefix', '-g']).trim();
         if (!prefix)
             return null;
         return process.platform === 'win32' ? prefix : path.join(prefix, 'bin');
@@ -596,6 +814,10 @@ function getNpmGlobalBinDir() {
     }
 }
 function installGlobalPdShim() {
+    if (!legacyNpmInstallEnabled()) {
+        logger.info('Skipping npm global shim discovery for the self-contained release asset.');
+        return false;
+    }
     // Allow skipping global shim installation in smoke tests to avoid
     // polluting the host's npm global bin dir. The bundled pd-cli is
     // still installed locally (getInstalledBinDir); only the global
@@ -630,6 +852,10 @@ function installGlobalPdShim() {
     }
 }
 function tryUpgradePdCliFromNpm(installedPdCliDir) {
+    if (!legacyNpmInstallEnabled()) {
+        logger.info('Skipping npm pd-cli upgrade for the self-contained release asset.');
+        return;
+    }
     // Allow skipping the npm upgrade in smoke tests / offline environments.
     // The bundled pd-cli is built from the current repo state and is the
     // authoritative version for testing. Upgrading to an npm-published version
@@ -640,12 +866,11 @@ function tryUpgradePdCliFromNpm(installedPdCliDir) {
         return;
     }
     try {
-        const npmVersion = execSync('npm view @principles/pd-cli version', {
-            encoding: 'utf-8',
-            timeout: 15_000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        if (!npmVersion || !/^\d+\.\d+\.\d+/.test(npmVersion))
+        const npmVersion = execNpm(['view', '@principles/pd-cli', 'version'], undefined, 15_000).trim();
+        // Fully anchored semver: this value is interpolated into a cmd.exe
+        // command line below, so a registry response carrying shell
+        // metacharacters after a valid-looking prefix must be rejected outright.
+        if (!npmVersion || !/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/.test(npmVersion))
             return;
         const localPkgPath = path.join(installedPdCliDir, 'package.json');
         const localPkg = JSON.parse(readFileSync(localPkgPath, 'utf-8'));
@@ -656,11 +881,29 @@ function tryUpgradePdCliFromNpm(installedPdCliDir) {
         const tmpDir = path.join(installedPdCliDir, '__npm_upgrade_tmp');
         try {
             mkdirSync(tmpDir, { recursive: true });
-            execSync(`npm pack @principles/pd-cli@${npmVersion} --pack-destination "${tmpDir}"`, {
-                encoding: 'utf-8',
-                timeout: 30_000,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
+            // Platform dispatch (CodeRabbit review): cmd.exe does not exist on
+            // POSIX, where npm is a real executable and can be spawned directly.
+            // The only registry-derived value on this command line is npmVersion,
+            // restricted to a metacharacter-free semver charset by the anchored
+            // check above; tmpDir is the local install root (profile-derived, not
+            // attacker-controlled). CodeQL's js/indirect-command-line-injection
+            // cannot model the regex sanitizer — see the evidence-based dismissal
+            // on alert 431.
+            const packArgs = ['pack', `@principles/pd-cli@${npmVersion}`, '--pack-destination', tmpDir];
+            if (process.platform === 'win32') {
+                execFileSync('cmd.exe', ['/d', '/s', '/c', 'npm', ...packArgs], {
+                    encoding: 'utf-8',
+                    timeout: 30_000,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            else {
+                execFileSync('npm', packArgs, {
+                    encoding: 'utf-8',
+                    timeout: 30_000,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
             const tgzFiles = readdirSync(tmpDir).filter(f => f.endsWith('.tgz'));
             const [tgzFile] = tgzFiles;
             if (!tgzFile) {
@@ -669,7 +912,7 @@ function tryUpgradePdCliFromNpm(installedPdCliDir) {
             }
             const extractDir = path.join(tmpDir, 'extracted');
             mkdirSync(extractDir, { recursive: true });
-            execSync(`tar -xzf "${path.join(tmpDir, tgzFile)}" -C "${extractDir}"`, {
+            execFileSync('tar', ['-xzf', path.join(tmpDir, tgzFile), '-C', extractDir], {
                 encoding: 'utf-8',
                 timeout: 15_000,
                 stdio: ['pipe', 'pipe', 'pipe'],
@@ -706,12 +949,16 @@ function syncPdCli(pluginDir) {
     mkdirSync(installedPdCliDir, { recursive: true });
     cpSync(distDir, path.join(installedPdCliDir, 'dist'), { recursive: true });
     copyFileSync(path.join(pdCliSourceDir, 'package.json'), path.join(installedPdCliDir, 'package.json'));
+    const bundledNodeModules = path.join(pdCliSourceDir, 'node_modules');
+    if (existsSync(bundledNodeModules)) {
+        cpSync(bundledNodeModules, path.join(installedPdCliDir, 'node_modules'), { recursive: true });
+    }
     // Create node_modules/@principles/core symlink so pd-cli can resolve
     // its @principles/core dependency (rewritten to "file:../core" by bundle-plugin.mjs).
     // Without this, `node dist/index.js --version` fails because static imports
     // from @principles/core/runtime-v2 cannot be resolved.
     const coreLinkDir = path.join(installedPdCliDir, 'node_modules', '@principles');
-    const coreLinkTarget = path.join(getPluginExtDir(), 'core');
+    const coreLinkTarget = path.join(getPdRuntimeDir(), 'core');
     mkdirSync(coreLinkDir, { recursive: true });
     const coreLinkPath = path.join(coreLinkDir, 'core');
     if (!existsSync(coreLinkPath)) {
@@ -731,7 +978,7 @@ function syncPdCli(pluginDir) {
     // host-runtime's own better-sqlite3 / js-yaml / @principles/core dependencies
     // resolve through the plugin's <ext>/node_modules/ (shared via Node's upward
     // module resolution), so no separate npm install is needed.
-    const hostRuntimeLinkTarget = path.join(getPluginExtDir(), 'host-runtime');
+    const hostRuntimeLinkTarget = path.join(getPdRuntimeDir(), 'host-runtime');
     const hostRuntimeLinkPath = path.join(coreLinkDir, 'host-runtime');
     if (!existsSync(hostRuntimeLinkPath)) {
         if (isWindows()) {
@@ -750,7 +997,7 @@ function syncPdCli(pluginDir) {
     // Without this, `pd runtime init` crashes with ERR_MODULE_NOT_FOUND
     // because runtime-init.ts statically imports initTrajectorySchema/initWorkflowSchema.
     const pdLinkDir = path.join(installedPdCliDir, 'node_modules');
-    const pdLinkTarget = getPluginExtDir();
+    const pdLinkTarget = installedPluginDir();
     mkdirSync(pdLinkDir, { recursive: true });
     const pdLinkPath = path.join(pdLinkDir, 'principles-disciple');
     if (!existsSync(pdLinkPath)) {
@@ -798,20 +1045,35 @@ function syncPdCli(pluginDir) {
 function verifyPdCliShim() {
     const localShim = path.join(getInstalledBinDir(), isWindows() ? 'pd.cmd' : 'pd');
     let localOk = false;
+    let localError;
     try {
         const installedEntry = path.join(getInstalledPdCliDir(), 'dist', 'index.js');
         execFileSync(process.execPath, [installedEntry, '--version'], { stdio: 'pipe', timeout: PD_CLI_VERIFICATION_TIMEOUT_MS });
         localOk = true;
     }
     catch (e) {
-        const err = e;
-        const detail = err.stderr?.toString().slice(0, 500) ?? err.message ?? 'unknown error';
+        let detail = 'unknown error';
+        if (typeof e === 'object' && e !== null) {
+            const stderr = Object.hasOwn(e, 'stderr') ? Reflect.get(e, 'stderr') : undefined;
+            const message = Object.hasOwn(e, 'message') ? Reflect.get(e, 'message') : undefined;
+            const stderrText = Buffer.isBuffer(stderr) ? stderr.toString().trim().slice(0, 500) : '';
+            if (stderrText.length > 0)
+                detail = stderrText;
+            else if (typeof message === 'string' && message.trim().length > 0)
+                detail = message.trim().slice(0, 500);
+        }
+        else if (typeof e === 'string' && e.trim().length > 0) {
+            detail = e.trim().slice(0, 500);
+        }
+        localError = detail;
         logger.warn(`PD CLI local verification failed: ${detail}`);
     }
     const globalOk = (() => {
         try {
             if (isWindows()) {
-                execSync('pd --version', { stdio: 'pipe', timeout: PD_CLI_VERIFICATION_TIMEOUT_MS, shell: 'cmd' });
+                // 'pd' is an npm .cmd shim on Windows — resolve via cmd.exe with a
+                // constant argv array (no shell string, no interpolation).
+                execFileSync('cmd.exe', ['/c', 'pd', '--version'], { stdio: 'pipe', timeout: PD_CLI_VERIFICATION_TIMEOUT_MS, windowsHide: true });
             }
             else {
                 execFileSync('pd', ['--version'], { stdio: 'pipe', timeout: PD_CLI_VERIFICATION_TIMEOUT_MS });
@@ -822,7 +1084,7 @@ function verifyPdCliShim() {
             return false;
         }
     })();
-    return { localOk, globalOk, localPath: localShim };
+    return { localOk, globalOk, localPath: localShim, localError };
 }
 function installConsole(consoleDir) {
     const consoleSrc = path.join(consoleDir, 'console');
@@ -844,18 +1106,18 @@ function installConsole(consoleDir) {
     mkdirSync(path.dirname(pluginLinkPath), { recursive: true });
     if (!existsSync(pluginLinkPath)) {
         if (isWindows()) {
-            symlinkSync(getPluginExtDir(), pluginLinkPath, 'junction');
+            symlinkSync(installedPluginDir(), pluginLinkPath, 'junction');
         }
         else {
-            symlinkSync('../../', pluginLinkPath, 'dir');
+            symlinkSync(path.relative(path.dirname(pluginLinkPath), installedPluginDir()), pluginLinkPath, 'dir');
         }
     }
 }
 function getInstalledCoreDir() {
-    return path.join(getPluginExtDir(), 'core');
+    return path.join(getPdRuntimeDir(), 'core');
 }
 function getInstalledHostRuntimeDir() {
-    return path.join(getPluginExtDir(), 'host-runtime');
+    return path.join(getPdRuntimeDir(), 'host-runtime');
 }
 function installBundledCore(pluginDir) {
     const coreSrc = path.join(pluginDir, 'core');
@@ -893,22 +1155,19 @@ function ensureCoreDependency(_targetDir) {
 }
 async function installCoreDependencies() {
     const coreDir = getInstalledCoreDir();
-    const packageJsonPath = path.join(coreDir, 'package.json');
-    if (!existsSync(packageJsonPath)) {
-        throw new Error('Core package.json not found after copy — install is corrupted');
-    }
-    await runNpmInstall(coreDir, 'Core');
-    await rebuildNativeModules(coreDir, 'Core');
-    verifyNativeModules(coreDir, 'Core');
+    await prepareComponentDependencies(coreDir, 'Core');
+}
+async function installHostRuntimeDependencies() {
+    const hostRuntimeDir = getInstalledHostRuntimeDir();
+    await prepareComponentDependencies(hostRuntimeDir, 'Host runtime');
+}
+async function installPdCliDependencies() {
+    const pdCliDir = getInstalledPdCliDir();
+    await prepareComponentDependencies(pdCliDir, 'PD CLI');
 }
 async function installConsoleDependencies() {
     const consoleDest = getInstalledConsoleDir();
-    const packageJsonPath = path.join(consoleDest, 'package.json');
-    if (!existsSync(packageJsonPath)) {
-        throw new Error('Console package.json not found after copy — install is corrupted');
-    }
-    await runNpmInstall(consoleDest, 'Console');
-    await rebuildNativeModules(consoleDest, 'Console');
+    await prepareComponentDependencies(consoleDest, 'Console');
 }
 const CONSOLE_PORT_MAX_RETRIES = 3;
 async function verifyConsole(workspaceDir) {
@@ -1336,11 +1595,44 @@ export async function install(options, pluginDir, mode = {}) {
     // because jsonMode always implies non-interactive.
     const quiet = mode.quiet === true;
     const nonInteractive = mode.nonInteractive ?? quiet;
+    activeHostTarget = options.host;
+    if (!legacyNpmInstallEnabled()) {
+        try {
+            await preflightSelfContainedReleaseAsset(pluginDir);
+        }
+        catch (error) {
+            const preflightError = error instanceof SelfContainedDependencyError
+                ? error
+                : new SelfContainedDependencyError({
+                    reason: 'self_contained_asset_preflight_failed',
+                    nextAction: SELF_CONTAINED_DEPENDENCY_NEXT_ACTION,
+                    message: error instanceof Error ? error.message : String(error),
+                    component: 'Release asset',
+                    cause: error,
+                });
+            return {
+                success: false,
+                workspaceDir: options.workspaceDir,
+                configYamlPath: getConfigYamlPath(options.workspaceDir),
+                templatesCount: 0,
+                components: { plugin: 'skipped', cli: 'skipped', console: 'skipped' },
+                verification: { features: 'skipped', storyA: 'skipped' },
+                enabledChannels: options.channels,
+                nextAction: preflightError.nextAction,
+                reason: preflightError.reason,
+                component: preflightError.component,
+                dependency: preflightError.dependency,
+                error: `${preflightError.message} — ${t('rollback_no_changes')}`,
+            };
+        }
+    }
     // Gateway lock pre-flight: a running gateway holds native-module file handles
     // that make the backup rename fail with EPERM. Decide stop/abort/proceed
     // BEFORE mutating anything (cli-5: abort/stop-failed paths must not mutate).
     let restartedGateway = false;
-    const gatewayStatus = await checkOpenClawGateway();
+    const gatewayStatus = installsOpenClaw(options.host)
+        ? await checkOpenClawGateway()
+        : { isRunning: false };
     if (gatewayStatus.isRunning) {
         const action = await resolveGatewayAction(gatewayStatus, {
             stopGateway: options.stopGateway,
@@ -1376,6 +1668,8 @@ export async function install(options, pluginDir, mode = {}) {
     }
     const spinner = quiet ? null : ora('Installing...').start();
     let backupDir = null;
+    let runtimeBackupDir = null;
+    let installManifestHosts;
     const components = { plugin: 'skipped', cli: 'skipped', console: 'skipped' };
     const verification = { features: 'skipped', storyA: 'skipped' };
     let consoleProcess = null;
@@ -1416,22 +1710,33 @@ export async function install(options, pluginDir, mode = {}) {
         stepIndex++;
         if (spinner)
             updateProgress(spinner, stepIndex, 'Backing up existing install...');
-        migrateLegacyPdBackups();
-        const { backupDir: backupDirFromResult } = backupExistingInstall();
+        // Validate the existing host-ownership record before mutating runtime or
+        // host config. A malformed manifest must not be discovered only after the
+        // old installation has already been replaced (rc-3/rc-9).
+        installManifestHosts = resolveInstallManifestHosts(options.host);
+        if (installsOpenClaw(options.host))
+            migrateLegacyPdBackups();
+        const { backupDir: backupDirFromResult, runtimeBackupDir: runtimeBackupDirFromResult } = backupExistingInstall(options.host);
         backupDir = backupDirFromResult;
+        runtimeBackupDir = runtimeBackupDirFromResult ?? null;
         stepIndex++;
         if (spinner)
             updateProgress(spinner, stepIndex, 'Installing bundled @principles/core...');
         installBundledCore(pluginDir);
         stepIndex++;
+        if (spinner)
+            updateProgress(spinner, stepIndex, 'Validating bundled core dependencies...');
+        await installCoreDependencies();
+        stepIndex++;
         if (spinner)
             updateProgress(spinner, stepIndex, 'Installing bundled @principles/host-runtime...');
         installBundledHostRuntime(pluginDir);
         stepIndex++;
         if (spinner)
-            updateProgress(spinner, stepIndex, 'Installing core dependencies...');
-        await installCoreDependencies();
+            updateProgress(spinner, stepIndex, 'Validating bundled host runtime dependencies...');
+        await installHostRuntimeDependencies();
         stepIndex++;
+        installBundledLayoutPackage(pluginDir);
         if (spinner)
             updateProgress(spinner, stepIndex, 'Installing plugin...');
         await installPluginToStaging(pluginDir, options.language);
@@ -1441,13 +1746,14 @@ export async function install(options, pluginDir, mode = {}) {
         ensureCoreDependency(getPluginExtDir());
         stepIndex++;
         if (spinner)
-            updateProgress(spinner, stepIndex, 'Installing plugin dependencies...');
+            updateProgress(spinner, stepIndex, 'Validating bundled plugin dependencies...');
         await installPluginDependencies();
         components.plugin = 'verified';
         stepIndex++;
         if (spinner)
             updateProgress(spinner, stepIndex, 'Installing pd CLI...');
         syncPdCli(pluginDir);
+        await installPdCliDependencies();
         stepIndex++;
         if (spinner)
             updateProgress(spinner, stepIndex, 'Preparing core library for pd-cli...');
@@ -1457,7 +1763,7 @@ export async function install(options, pluginDir, mode = {}) {
             updateProgress(spinner, stepIndex, 'Verifying pd CLI...');
         const cliVerify = verifyPdCliShim();
         if (!cliVerify.localOk) {
-            throw new Error('PD CLI verification failed — local shim is not executable after install. Check Node.js and PATH configuration.');
+            throw new Error(`PD CLI verification failed — local shim is not executable after install: ${cliVerify.localError ?? 'unknown error'}. Check Node.js and PATH configuration.`);
         }
         if (cliVerify.globalOk) {
             components.cli = 'verified';
@@ -1477,7 +1783,7 @@ export async function install(options, pluginDir, mode = {}) {
         ensureCoreDependency(getInstalledConsoleDir());
         stepIndex++;
         if (spinner)
-            updateProgress(spinner, stepIndex, 'Installing console dependencies...');
+            updateProgress(spinner, stepIndex, 'Validating bundled console dependencies...');
         await installConsoleDependencies();
         stepIndex++;
         if (spinner)
@@ -1594,14 +1900,13 @@ export async function install(options, pluginDir, mode = {}) {
                 logger.info(`Host "${hr.hostId}" install: ${hr.reason ?? 'skipped'}. Next: ${hr.nextAction}`);
             }
         }
-        cleanupBackup(backupDir);
+        if (hostFailures.length > 0) {
+            throw new Error(`Host installation failed: ${hostFailures.join(' | ')}`);
+        }
+        writeInstallManifest(installManifestHosts);
+        cleanupBackup(backupDir, runtimeBackupDir);
         if (spinner) {
-            if (hostFailures.length > 0) {
-                spinner.warn('Install complete with host warnings');
-            }
-            else {
-                spinner.succeed('Install complete!');
-            }
+            spinner.succeed('Install complete!');
         }
         killConsoleChild();
         // Task 8: auto-launch console via `pd console open` (reuses PRI-300
@@ -1614,7 +1919,6 @@ export async function install(options, pluginDir, mode = {}) {
         // A host installer failure means the install is not fully successful,
         // even if all component verifications passed. The operator should see
         // success=false and be guided to fix the failed host.
-        const hasHostFailures = hostFailures.length > 0;
         const nextActions = [];
         if (components.cli === 'verified') {
             nextActions.push(`pd runtime canary --workspace "${options.workspaceDir}" --json`);
@@ -1635,10 +1939,8 @@ export async function install(options, pluginDir, mode = {}) {
         if (launchResult.fallbackAction) {
             nextActions.push(launchResult.fallbackAction);
         }
-        // Append host-failure remediation actions so the operator knows what to fix.
-        nextActions.push(...hostFailures);
         return {
-            success: isComplete && !hasHostFailures,
+            success: isComplete,
             workspaceDir: options.workspaceDir,
             configYamlPath,
             templatesCount: templatesCount + principlesCount,
@@ -1654,7 +1956,7 @@ export async function install(options, pluginDir, mode = {}) {
         if (spinner)
             spinner.fail('Install failed');
         killConsoleChild();
-        const restoreResult = restoreBackup(backupDir);
+        const restoreResult = restoreBackup(backupDir, runtimeBackupDir);
         const errorMsg = error instanceof Error ? error.message : String(error);
         // ERR-046 / rc-9: never claim a restore that didn't happen. When backupDir
         // is null, the backup step never completed (it threw — e.g. EPERM — or
@@ -1664,15 +1966,16 @@ export async function install(options, pluginDir, mode = {}) {
         const isLockError = /EPERM|EBUSY|EACCES|operation not permitted/i.test(errorMsg);
         const extDir = getPluginExtDir();
         // EP-11: all operator-visible failure/rollback text goes through t().
-        const rollbackSuffix = !backupDir
+        const hasBackup = Boolean(backupDir || runtimeBackupDir);
+        const rollbackSuffix = !hasBackup
             ? t('rollback_no_changes')
             : restoreResult.restored
                 ? t('rollback_restored')
                 : t('rollback_failed')
                     .replace('{restoreError}', restoreResult.error ?? '')
                     .replace('{extDir}', extDir)
-                    .replace('{backupDir}', backupDir);
-        const nextAction = !backupDir
+                    .replace('{backupDir}', backupDir ?? runtimeBackupDir ?? '');
+        const rollbackNextAction = !hasBackup
             ? (isLockError
                 ? t('next_no_changes_lock')
                 : t('next_no_changes_other'))
@@ -1680,13 +1983,19 @@ export async function install(options, pluginDir, mode = {}) {
                 ? t('next_restored')
                 : t('next_restore_failed')
                     .replace('{extDir}', extDir)
-                    .replace('{backupDir}', backupDir)
+                    .replace('{backupDir}', backupDir ?? runtimeBackupDir ?? '')
                     .replace('{errorMsg}', errorMsg);
-        const reason = !backupDir
+        const rollbackReason = !hasBackup
             ? (isLockError ? `install_aborted_lock: ${errorMsg}` : `install_failed_before_mutation: ${errorMsg}`)
             : restoreResult.restored
                 ? errorMsg
                 : `install_failed_rollback_failed: ${errorMsg}`;
+        const nextAction = error instanceof SelfContainedDependencyError
+            ? restoreResult.restored || !hasBackup
+                ? error.nextAction
+                : `${error.nextAction} ${rollbackNextAction}`
+            : rollbackNextAction;
+        const reason = error instanceof SelfContainedDependencyError ? error.reason : rollbackReason;
         return {
             success: false,
             workspaceDir: options.workspaceDir,
@@ -1697,6 +2006,8 @@ export async function install(options, pluginDir, mode = {}) {
             enabledChannels: options.channels,
             nextAction,
             reason,
+            component: error instanceof SelfContainedDependencyError ? error.component : undefined,
+            dependency: error instanceof SelfContainedDependencyError ? error.dependency : undefined,
             error: `${errorMsg} — ${rollbackSuffix}`,
         };
     }