principles-disciple 1.71.0 → 1.73.0

package/scripts/sync-plugin.mjs

@@ -17,7 +17,7 @@
  *   --help             Show help message
  */
 
-import { copyFileSync, cpSync, existsSync, lstatSync, rmSync, readFileSync, readFileSync as readFileSyncRaw, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, rmSync, readFileSync, readFileSync as readFileSyncRaw, mkdirSync, writeFileSync, readdirSync } from 'fs';
 import { createHash } from 'crypto';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -27,6 +27,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const SOURCE_DIR = join(__dirname, '..');
+const ROOT_DIR = join(SOURCE_DIR, '..', '..');
+const PD_CLI_SOURCE_DIR = join(ROOT_DIR, 'packages', 'pd-cli');
 
 /**
  * Cross-platform home directory resolution.
@@ -42,6 +44,8 @@ function getHomeDir() {
 
 const OPENCLAW_DIR = join(getHomeDir(), '.openclaw');
 const INSTALL_DIR = join(OPENCLAW_DIR, 'extensions', 'principles-disciple');
+const INSTALLED_PD_CLI_DIR = join(INSTALL_DIR, 'pd-cli');
+const INSTALLED_BIN_DIR = join(INSTALL_DIR, 'bin');
 function getConfiguredWorkspaceDir() {
   const configPath = join(OPENCLAW_DIR, 'openclaw.json');
   try {
@@ -58,13 +62,15 @@ function getConfiguredWorkspaceDir() {
   return join(OPENCLAW_DIR, 'workspace-main');
 }
 
-// Files and directories to sync
+// Files and directories to sync.
+// NOTE: openclaw.plugin.json is NOT included here — it is synced separately
+// via syncFilteredManifest() which filters the skills array by language
+// BEFORE writing to the install target, preventing the en/zh collision.
 const SYNC_ITEMS = [
     'dist',
     'templates',
     'scripts',
     'docs',
-    'openclaw.plugin.json',
     'package.json',
 ];
 
@@ -371,10 +377,6 @@ function buildPlugin() {
             cwd: SOURCE_DIR,
             stdio: 'inherit'
         });
-        execSync('node scripts/build-web.mjs --production', {
-            cwd: SOURCE_DIR,
-            stdio: 'inherit'
-        });
     } catch (error) {
         console.error('\n❌ Build failed');
         console.error(`   ${error.message}`);
@@ -384,6 +386,36 @@ function buildPlugin() {
     verifyBundleContents();
 }
 
+/**
+ * Build the Runtime V2 CLI that agents invoke through the `pd` command.
+ * This is intentionally part of plugin sync so installed OpenClaw agents do not
+ * depend on a repo checkout, stale global npm package, or guessed CLI path.
+ */
+function buildPdCli() {
+    console.log('\n🔨 Building PD CLI...');
+
+    if (!existsSync(join(PD_CLI_SOURCE_DIR, 'package.json'))) {
+        console.error(`❌ PD CLI package not found: ${PD_CLI_SOURCE_DIR}`);
+        process.exit(1);
+    }
+
+    try {
+        execSync('npm run build --workspace=@principles/core', {
+            cwd: ROOT_DIR,
+            stdio: 'inherit'
+        });
+        execSync('npm run build --workspace=@principles/pd-cli', {
+            cwd: ROOT_DIR,
+            stdio: 'inherit'
+        });
+        console.log('✅ PD CLI built');
+    } catch (error) {
+        console.error('\n❌ PD CLI build failed');
+        console.error(`   ${error.message}`);
+        process.exit(1);
+    }
+}
+
 /**
  * Verify the built bundle contains all critical symbols.
  */
@@ -400,7 +432,6 @@ function verifyBundleContents() {
         { name: 'checkPainFlag',          reason: 'pain flag detection' },
         { name: 'processEvolutionQueue',  reason: 'queue processing' },
         { name: 'acquireQueueLock',       reason: 'queue lock for pd-reflect and worker' },
-        { name: 'write_pain_flag',        reason: 'pain signal recording tool' },
     ];
 
     const missing = [];
@@ -472,11 +503,6 @@ function writeBuildFingerprint() {
         console.warn(`⚠️  Could not write fingerprint: ${err.message}`);
     }
 
-    try {
-        const rootManifest = JSON.parse(readFileSync(manifestSrc, 'utf-8'));
-        rootManifest.buildFingerprint = manifest.buildFingerprint;
-        writeFileAtomic(manifestSrc, JSON.stringify(rootManifest, null, 2) + '\n');
-    } catch { /* ignore */ }
 }
 
 /**
@@ -525,22 +551,33 @@ function verifyInstalledFingerprint() {
 }
 
 /**
- * Update the plugin version in openclaw.json after successful sync.
- * This ensures the recorded version always matches the installed version.
+ * Update the plugin version in installs.json after successful sync.
+ * OpenClaw manages install records in ~/.openclaw/plugins/installs.json,
+ * NOT in openclaw.json (plugins.installs is a legacy/transient field).
  */
 function updateInstalledPluginVersion(version) {
-    const configPath = join(OPENCLAW_DIR, 'openclaw.json');
+    const installsDir = join(OPENCLAW_DIR, 'plugins');
+    const installsPath = join(installsDir, 'installs.json');
     try {
-        const raw = readFileSync(configPath, 'utf-8');
-        const config = JSON.parse(raw);
-        if (config?.plugins?.installs?.['principles-disciple']) {
-            config.plugins.installs['principles-disciple'].version = version;
-            config.plugins.installs['principles-disciple'].installedAt = new Date().toISOString();
-            writeFileAtomic(configPath, JSON.stringify(config, null, 2) + '\n');
-            console.log(`✅ openclaw.json updated: version=${version}`);
+        if (!existsSync(installsDir)) {
+            mkdirSync(installsDir, { recursive: true });
         }
+        let installs = { version: 1, installRecords: {} };
+        if (existsSync(installsPath)) {
+            const raw = readFileSync(installsPath, 'utf-8');
+            installs = JSON.parse(raw);
+        }
+        if (!installs.installRecords) installs.installRecords = {};
+        installs.installRecords['principles-disciple'] = {
+            source: 'path',
+            installPath: INSTALL_DIR,
+            version: version,
+            installedAt: new Date().toISOString(),
+        };
+        writeFileAtomic(installsPath, JSON.stringify(installs, null, 2) + '\n');
+        console.log(`✅ installs.json updated: version=${version}`);
     } catch (err) {
-        console.warn(`⚠️  Could not update openclaw.json: ${err.message}`);
+        console.warn(`⚠️  Could not update installs.json: ${err.message}`);
     }
 }
 
@@ -604,36 +641,93 @@ function ensureInstallDir() {
 }
 
 /**
- * Sync skills directories based on the skills field in openclaw.plugin.json.
- * Reads the manifest to find declared skill paths, resolves them relative to
- * source root, then copies each to the install target.
+ * Sync the openclaw.plugin.json manifest but filter the skills array to only
+ * include paths matching the selected language (zh or en).
+ *
+ * This MUST run BEFORE syncSkillDirs, and it should
+ * never be done via syncItem('openclaw.plugin.json') + subsequent modification
+ * because the post-modification step can fail silently (catch block) leaving
+ * both en/zh skills in the manifest, which triggers OpenClaw's "plugin skill
+ * name collision" warning on startup.
  */
-function syncSkillDirs() {
-    const manifestPath = join(SOURCE_DIR, 'openclaw.plugin.json');
-    if (!existsSync(manifestPath)) return;
+function syncFilteredManifest(lang) {
+    const sourcePath = join(SOURCE_DIR, 'openclaw.plugin.json');
+    const targetPath = join(INSTALL_DIR, 'openclaw.plugin.json');
+
+    if (!existsSync(sourcePath)) return;
+
+    console.log(`  📄 openclaw.plugin.json (filtered for lang: ${lang})`);
 
-    let skillsPaths;
+    let manifest;
     try {
-        const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-        skillsPaths = manifest.skills;
-    } catch {
-        return;
+        manifest = JSON.parse(readFileSync(sourcePath, 'utf-8'));
+    } catch (err) {
+        console.error(`❌ Failed to read source manifest: ${err.message}`);
+        process.exit(1);
+    }
+
+    if (!manifest.skills || !Array.isArray(manifest.skills)) return;
+
+    const selectedLang = (lang || 'zh').toLowerCase();
+    if (!['zh', 'en'].includes(selectedLang)) {
+        console.error(`❌ Invalid language: ${selectedLang}. Expected zh or en.`);
+        process.exit(1);
     }
 
-    if (!skillsPaths || !Array.isArray(skillsPaths)) return;
+    const filtered = manifest.skills.filter(sp => {
+        if (typeof sp !== 'string') return false;
+        return sp.includes(`/langs/${selectedLang}/`);
+    });
+
+    if (filtered.length === 0) {
+        console.error(`❌ No skills match language "${selectedLang}" in source manifest`);
+        process.exit(1);
+    }
+
+    manifest.skills = filtered;
+
+    // Use syncItem semantics: remove target, then write freshly
+    if (existsSync(targetPath)) {
+        rmSync(targetPath, { force: true });
+    }
+    writeFileSync(targetPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+    console.log(`  ✅ skills filtered to lang: ${selectedLang} (${filtered.length} path(s))`);
+}
 
-    for (const sp of skillsPaths) {
-        if (typeof sp !== 'string') continue;
-        const source = join(SOURCE_DIR, sp);
-        const name = sp.split('/').pop();
-        const target = join(INSTALL_DIR, 'skills', name);
-        if (!existsSync(source)) {
-            console.warn(`  ⚠️  skills path not found: ${sp}`);
-            continue;
+/**
+ * @deprecated Replaced by syncFilteredManifest(). Kept for backwards
+ * compatibility with old installs that may call it externally.
+ * syncFilteredManifest filters the skills array BEFORE writing the manifest
+ * to disk, avoiding the en/zh collision window entirely.
+ */
+function filterInstalledManifestSkills(lang) {
+    const installedManifestPath = join(INSTALL_DIR, 'openclaw.plugin.json');
+    if (!existsSync(installedManifestPath)) return;
+
+    try {
+        const manifest = JSON.parse(readFileSync(installedManifestPath, 'utf-8'));
+        if (!manifest.skills || !Array.isArray(manifest.skills)) return;
+
+        const selectedLang = (lang || 'zh').toLowerCase();
+        if (!['zh', 'en'].includes(selectedLang)) {
+            console.error(`❌ Invalid language: ${selectedLang}. Expected zh or en.`);
+            process.exit(1);
         }
-        if (existsSync(target)) rmSync(target, { recursive: true, force: true });
-        cpSync(source, target, { recursive: true });
-        console.log(`  📄 skills/${name} (from ${sp})`);
+        const filtered = manifest.skills.filter(sp => {
+            if (typeof sp !== 'string') return false;
+            return sp.includes(`/langs/${selectedLang}/`);
+        });
+
+        if (filtered.length === 0) {
+            console.error(`❌ No skills match language "${selectedLang}" in installed manifest`);
+            process.exit(1);
+        }
+
+        manifest.skills = filtered;
+        writeFileSync(installedManifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+        console.log(`  📄 openclaw.plugin.json skills filtered to lang: ${selectedLang}`);
+    } catch (err) {
+        console.warn(`  ⚠️  Failed to filter installed manifest skills: ${err.message}`);
     }
 }
 
@@ -653,6 +747,113 @@ function syncItem(item) {
     }
 }
 
+function quoteCmdPath(filePath) {
+    return filePath.replace(/"/g, '""');
+}
+
+/**
+ * Copy the built pd-cli package into the plugin install directory and create
+ * deterministic shims. The global shim points at the installed plugin copy, not
+ * at a developer checkout.
+ */
+function syncPdCli() {
+    console.log('\n📦 Syncing PD CLI...');
+
+    const distDir = join(PD_CLI_SOURCE_DIR, 'dist');
+    if (!existsSync(join(distDir, 'index.js'))) {
+        console.error('❌ PD CLI dist/index.js missing. Run without --skip-build or build @principles/pd-cli first.');
+        process.exit(1);
+    }
+
+    rmSync(INSTALLED_PD_CLI_DIR, { recursive: true, force: true });
+    mkdirSync(INSTALLED_PD_CLI_DIR, { recursive: true });
+    cpSync(distDir, join(INSTALLED_PD_CLI_DIR, 'dist'), { recursive: true });
+    copyFileSync(join(PD_CLI_SOURCE_DIR, 'package.json'), join(INSTALLED_PD_CLI_DIR, 'package.json'));
+
+    mkdirSync(INSTALLED_BIN_DIR, { recursive: true });
+    const installedEntry = join(INSTALLED_PD_CLI_DIR, 'dist', 'index.js');
+
+    if (isWindows()) {
+        const cmdShim = [
+            '@echo off',
+            `node "${quoteCmdPath(installedEntry)}" %*`,
+            '',
+        ].join('\r\n');
+        const psShim = [
+            '$ErrorActionPreference = "Stop"',
+            `$entry = "${installedEntry.replace(/`/g, '``').replace(/"/g, '`"')}"`,
+            '& node $entry @args',
+            'exit $LASTEXITCODE',
+            '',
+        ].join('\r\n');
+        writeFileSync(join(INSTALLED_BIN_DIR, 'pd.cmd'), cmdShim, 'utf-8');
+        writeFileSync(join(INSTALLED_BIN_DIR, 'pd.ps1'), psShim, 'utf-8');
+    } else {
+        const shShim = [
+            '#!/usr/bin/env sh',
+            `exec node "${installedEntry.replace(/"/g, '\\"')}" "$@"`,
+            '',
+        ].join('\n');
+        const target = join(INSTALLED_BIN_DIR, 'pd');
+        writeFileSync(target, shShim, 'utf-8');
+        chmodSync(target, 0o755);
+    }
+
+    installGlobalPdShim();
+}
+
+function getNpmGlobalBinDir() {
+    try {
+        const prefix = execSync('npm prefix -g', { encoding: 'utf-8' }).trim();
+        if (!prefix) return null;
+        return process.platform === 'win32' ? prefix : join(prefix, 'bin');
+    } catch {
+        return null;
+    }
+}
+
+function installGlobalPdShim() {
+    const globalBin = getNpmGlobalBinDir();
+    if (!globalBin) {
+        console.warn('⚠️  Could not resolve npm global bin directory. Use plugin-local bin/pd shim.');
+        return;
+    }
+
+    try {
+        mkdirSync(globalBin, { recursive: true });
+        if (isWindows()) {
+            const pluginCmd = join(INSTALLED_BIN_DIR, 'pd.cmd');
+            const pluginPs = join(INSTALLED_BIN_DIR, 'pd.ps1');
+            writeFileSync(join(globalBin, 'pd.cmd'), `@echo off\r\ncall "${quoteCmdPath(pluginCmd)}" %*\r\n`, 'utf-8');
+            writeFileSync(
+                join(globalBin, 'pd.ps1'),
+                `$shim = "${pluginPs.replace(/`/g, '``').replace(/"/g, '`"')}"\r\n& $shim @args\r\nexit $LASTEXITCODE\r\n`,
+                'utf-8'
+            );
+        } else {
+            const pluginSh = join(INSTALLED_BIN_DIR, 'pd');
+            const globalSh = join(globalBin, 'pd');
+            writeFileSync(globalSh, `#!/usr/bin/env sh\nexec "${pluginSh.replace(/"/g, '\\"')}" "$@"\n`, 'utf-8');
+            chmodSync(globalSh, 0o755);
+        }
+        console.log(`✅ Global pd shim installed: ${globalBin}`);
+    } catch (err) {
+        console.warn(`⚠️  Could not install global pd shim: ${err.message}`);
+        console.warn(`   Use plugin-local shim: ${join(INSTALLED_BIN_DIR, isWindows() ? 'pd.cmd' : 'pd')}`);
+    }
+}
+
+function verifyPdCliShim() {
+    const localShim = join(INSTALLED_BIN_DIR, isWindows() ? 'pd.cmd' : 'pd');
+    try {
+        execSync(`"${localShim}" --version`, { stdio: 'pipe', shell: true });
+        console.log(`✅ PD CLI shim verified: ${localShim}`);
+    } catch (err) {
+        console.error(`❌ PD CLI shim verification failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+
 /**
  * Recursive directory copy (Windows-safe, no symlinks).
  */
@@ -711,7 +912,7 @@ function injectLocalWorkspacePackages() {
 function installTargetDependencies() {
     console.log('\n📦 Installing production dependencies in target...');
     try {
-        execSync('npm install --production --no-audit --no-fund', {
+        execSync('npm install --omit=dev --no-audit --no-fund --prefer-offline', {
             cwd: INSTALL_DIR,
             stdio: 'inherit'
         });
@@ -770,6 +971,35 @@ function getTempDir() {
     return '/tmp';
 }
 
+/**
+ * Strip Anaconda/Miniconda entries from PATH on Windows.
+ *
+ * Anaconda ships an ancient cygpath (2016, at
+ * D:\ProgramData\anaconda3\Library\usr\bin\cygpath) that converts Unix-style
+ * paths INCORRECTLY in MINGW/MSYS — e.g. "/c/Users/..." becomes
+ * "D:\ProgramData\anaconda3\Library\c\Users\..." instead of "C:\Users\...".
+ * npm-installed CLI POSIX shims (openclaw, pd, etc.) call cygpath -w for path
+ * conversion and break when the wrong cygpath is found first in PATH.
+ *
+ * This does not affect schtasks (runs in a clean session) or PowerShell
+ * Start-Process (uses Split-Path, not cygpath). It protects the port check
+ * and error-recovery paths that execSync child processes.
+ */
+function sanitizePathForWindows() {
+    const pathSep = isWindows() ? ';' : ':';
+    const originalPath = process.env.PATH || '';
+    const entries = originalPath.split(pathSep).filter(Boolean);
+    const sanitized = entries.filter(entry => {
+        const lower = entry.toLowerCase().replace(/[/\\]/g, '/');
+        return !lower.includes('/anaconda') && !lower.includes('/conda') && !lower.includes('/miniconda');
+    });
+    if (sanitized.length !== entries.length) {
+        const removed = entries.length - sanitized.length;
+        process.env.PATH = sanitized.join(pathSep);
+        console.log(`   🧹 Sanitized PATH: removed ${removed} Anaconda/Conda entr${removed > 1 ? 'ies' : 'y'} (fixes cygpath bug on MINGW/MSYS)`);
+    }
+}
+
 /**
  * Restart OpenClaw Gateway (cross-platform).
  */
@@ -791,6 +1021,10 @@ function restartGateway() {
 function restartGatewayWindows() {
     const logPath = join(getTempDir(), 'openclaw-auto-restart.log');
 
+    // Strip Anaconda from PATH so any execSync child process (especially the
+    // port-check Test-NetConnection shell) does not inherit poisoned cygpath.
+    sanitizePathForWindows();
+
     try {
         // Kill existing gateway processes first — taskkill fails across Windows sessions,
         // use WMIC which can terminate processes regardless of session boundary.
@@ -832,40 +1066,66 @@ function restartGatewayWindows() {
 
         // Trigger via schtasks — reliable, avoids CLI busy-port misdetection
         console.log('   Starting gateway via scheduled task...');
-        execSync('schtasks /Run /TN "OpenClaw Gateway"', { stdio: 'inherit' });
+        let gatewayStarted = false;
+        try {
+            execSync('schtasks /Run /TN "OpenClaw Gateway"', { stdio: 'pipe' });
+            gatewayStarted = true;
+        } catch {
+            // schtasks failed — try direct CLI fallback via PowerShell
+            // PowerShell shim resolves paths correctly in Anaconda environments
+            // where cmd /c can produce wrong path prefixes (e.g. conda prefix + npm path)
+            console.log('   Scheduled task not available, trying direct gateway start via PowerShell...');
+            try {
+                execSync(
+                    'powershell -NoProfile -Command "Start-Process -WindowStyle Hidden -FilePath \'openclaw\' -ArgumentList \'gateway\'"',
+                    { stdio: 'pipe', timeout: 5000 }
+                );
+                gatewayStarted = true;
+            } catch {
+                // Gateway may already be running or no perms — not fatal
+            }
+        }
 
         // Wait for gateway to be listening on port (同步等待，不异步)
         const port = 18789;
-        const deadline = Date.now() + 30000;
-        const pollInterval = 1000;
+        const deadline = Date.now() + 60000; // Gateway 初始化可能需要 20+ 秒 (如 Windows schtasks 重启)
         let gatewayListening = false;
 
         while (Date.now() < deadline) {
             try {
+                // 使用 Test-NetConnection 替代有语法问题的 Get-NetTCPConnection + Measure-Object
                 const result = execSync(
-                    `powershell -NoProfile -Command "Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Measure-Object -Line).Count"`,
+                    `powershell -NoProfile -Command "(Test-NetConnection -ComputerName localhost -Port ${port} -WarningAction SilentlyContinue).TcpTestSucceeded"`,
                     { encoding: 'utf-8', timeout: 5000 }
                 ).trim();
-                if (parseInt(result) > 0) {
+                if (result === 'True') {
                     gatewayListening = true;
                     break;
                 }
             } catch { /* port not listening yet */ }
-            execSync('timeout /t 1 /nobreak > nul', { shell: true, stdio: 'ignore' });
+            try {
+                execSync('timeout /t 1 /nobreak > nul', { shell: true, stdio: 'ignore' });
+            } catch { /* ignore */ }
         }
 
         if (!gatewayListening) {
-            console.error('\n❌ Gateway did not start on port 18789 within 30s.');
-            console.error('   Please restart manually: openclaw gateway start');
-            process.exit(1);
+            console.warn('\n⚠️  Gateway may not be running on port 18789 (plugin files are installed).');
+            console.warn('   If the gateway was started but is unreachable, try:');
+            console.warn('     1. From PowerShell: openclaw gateway start');
+            console.warn('     2. If using Git Bash, strip Anaconda from PATH first:');
+            console.warn('        PATH=$(echo "$PATH" | tr ":" "\\n" | grep -iv anaconda | tr "\\n" ":") openclaw gateway start');
+            return false;
         }
 
         console.log('   ✅ Gateway is listening on port 18789');
+        return true;
 
     } catch (error) {
-        console.error(`\n❌ Gateway restart failed: ${error.message}`);
-        console.error('   You may need to manually restart: openclaw gateway start');
-        process.exit(1);
+        console.warn(`\n⚠️  Gateway restart failed: ${error.message}`);
+        console.warn('   Plugin files are installed. Run "openclaw gateway start" manually.');
+        console.warn('   If using Git Bash with Anaconda in PATH, first run:');
+        console.warn('     export PATH=$(echo "$PATH" | tr ":" "\\n" | grep -iv anaconda | tr "\\n" ":")');
+        return false;
     }
 }
 
@@ -906,7 +1166,7 @@ function restartGatewayLinux() {
                     console.warn(`⚠️  Post-restart verification skipped: ${e.message}`);
                 }
             }, 8000);
-            return;
+            return true; // systemctl restart triggered successfully
         } catch { /* systemctl not available, fall through to manual restart */ }
 
         // Manual process management
@@ -919,22 +1179,29 @@ function restartGatewayLinux() {
 
         console.log(`   Starting new gateway (logs: ${logPath})...`);
         execSync(`nohup openclaw gateway --force > ${logPath} 2>&1 &`, { stdio: 'ignore' });
-        console.log('✅ Gateway restart triggered.');
-
-        setTimeout(() => {
-            if (existsSync(logPath)) {
-                const logs = readFileSync(logPath, 'utf-8');
-                if (logs.includes('Principles Disciple Plugin registered')) {
-                    console.log('✅ SUCCESS: Principles Disciple plugin registered successfully (manual restart)!');
-                } else if (logs.includes('failed to load')) {
-                    console.error('\n❌ CRITICAL: Manual restart triggered but PD plugin FAILED to load!');
-                    process.exit(1);
+
+        // Wait for process to actually start (up to 15s)
+        const deadline = Date.now() + 15000;
+        while (Date.now() < deadline) {
+            try {
+                const running = execSync(
+                    'pgrep -f "openclaw-gateway|openclaw gateway"',
+                    { encoding: 'utf-8', stdio: 'pipe' }
+                ).trim();
+                if (running) {
+                    console.log('✅ Gateway restart triggered.');
+                    return true;
                 }
-            }
-        }, 8000);
+            } catch { /* not ready yet */ }
+            execSync('sleep 1');
+        }
+
+        console.error(`❌ Gateway did not come back up. Check ${logPath}`);
+        return false;
+
     } catch (error) {
         console.error(`\n❌ Failed to restart gateway: ${error.message}`);
-        process.exit(1);
+        return false;
     }
 }
 
@@ -968,16 +1235,41 @@ function main() {
 
     if (!args.skipDeps) installDependencies();
 
-    buildPlugin();
+    if (!args.skipBuild) {
+        buildPlugin();
+        buildPdCli();
+    } else {
+        console.log('\n⏭️  Skipping build step (--skip-build)');
+    }
     cleanTargetDir(args.force);
     ensureInstallDir();
 
     console.log('\n📦 Syncing files to OpenClaw...');
     for (const item of SYNC_ITEMS) syncItem(item);
-    syncSkillDirs();
+
+    // After syncing templates, remove the non-selected language to avoid
+    // waste on disk. OpenClaw only loads skills declared in the filtered
+    // manifest (syncFilteredManifest), but having unselected lang files on
+    // disk inflates the install footprint and confuses inspection.
+    {
+        const langsDir = join(INSTALL_DIR, 'templates', 'langs');
+        if (existsSync(langsDir)) {
+            const normalizedLang = (args.lang || 'zh').toLowerCase();
+            const unselectedLang = normalizedLang === 'zh' ? 'en' : 'zh';
+            const unselectedPath = join(langsDir, unselectedLang);
+            if (existsSync(unselectedPath)) {
+                rmSync(unselectedPath, { recursive: true, force: true });
+                console.log(`  🗑️  removed templates/langs/${unselectedLang} (lang: ${normalizedLang})`);
+            }
+        }
+    }
+
+    syncFilteredManifest(args.lang);
+    syncPdCli();
 
     injectLocalWorkspacePackages();
     installTargetDependencies();
+    verifyPdCliShim();
 
     console.log('\n🔍 Verifying installed plugin can load native dependencies...');
     try {
@@ -1040,7 +1332,20 @@ function main() {
     console.log('╚════════════════════════════════════════════════════════════╝');
 
     if (args.restart) {
-        restartGateway();
+        const restarted = restartGateway();
+        if (!restarted) {
+            console.warn('\n⚠️  Plugin files installed but gateway restart was not confirmed.');
+            console.warn('   The gateway may already be running. Verify with:');
+            console.warn('     PowerShell: openclaw gateway status');
+            console.warn('     Git Bash:   Test-NetConnection -ComputerName localhost -Port 18789');
+            console.warn('');
+            console.warn('   If "openclaw gateway start" fails with a path error on Git Bash:');
+            console.warn('     this is caused by Anaconda\'s old cygpath tool polluting PATH.');
+            console.warn('     Run: export PATH=$(echo "$PATH" | tr ":" "\\n" | grep -iv anaconda | tr "\\n" ":")');
+            console.warn('     Then: openclaw gateway start');
+            console.warn('');
+            console.warn('   Or simply restart from PowerShell (not affected by the cygpath bug).');
+        }
     } else {
         console.log('\n💡 Restart OpenClaw Gateway to load the new version.');
         console.log('   (Plugin code changes require a full gateway restart)');

package/src/commands/archive-impl.ts

@@ -20,6 +20,7 @@ import {
 import type { Implementation, ImplementationLifecycleState } from '../types/principle-tree-schema.js';
 import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
 import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
+import { normalizeCommandArgs } from '../utils/io.js';
 
 /**
  * Get all implementations from the ledger.
@@ -49,7 +50,7 @@ export function handleArchiveImplCommand(ctx: PluginCommandContext): PluginComma
   const lang = (ctx.config?.language as string) || 'en';
   const isZh = lang === 'zh';
 
-  const args = (ctx.args || '').trim().split(/\s+/);
+  const args = normalizeCommandArgs(ctx.args).trim().split(/\s+/);
   const subcommand = args[0] || '';
 
   // Subcommand: list

package/src/commands/capabilities.ts

@@ -3,7 +3,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
-import { atomicWriteFileSync } from '../utils/io.js';
+import { atomicWriteFileSync, normalizeCommandArgs } from '../utils/io.js';
 import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
 
 const TOOLS_TO_SCAN = [
@@ -75,7 +75,7 @@ export function handleBootstrapTools(ctx: PluginCommandContext): PluginCommandRe
 }
 
 export function handleResearchTools(ctx: PluginCommandContext): PluginCommandResult {
-  const category = ctx.args?.trim() || "modern high-performance CLI tools for coding and architecture";
+  const category = normalizeCommandArgs(ctx.args).trim() || "modern high-performance CLI tools for coding and architecture";
   
   return {
     text: