principles-disciple 1.11.0 → 1.12.0

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# principles-disciple
+
+## 1.10.0
+
+### Minor Changes
+
+- 650ae5a: ## v1.9.1: WebUI Data Source Fixes
+
+  ### Phase 16-20 Complete
+
+  - **Phase 16**: Data Source Tracing - mapped all 4 WebUI pages to API endpoints
+  - **Phase 17**: Overview Page Fix - fixed `/api/central/overview`, `/api/overview`, `/api/overview/health`
+  - **Phase 18**: Loop/Samples + Feedback Fix - fixed `/api/samples`, `/api/feedback/*` data sources
+  - **Phase 19**: Gate Monitor Frontend - fixed `/api/gate/stats`, `/api/gate/blocks` types
+  - **Phase 20**: E2E Validation - 19 regression tests added for all API endpoints
+
+  ### Bug Fixes
+
+  - Fixed `evolution-worker.ts` missing `runtimeAdapter` parameter
+  - Fixed `nocturnal-train.ts` mode field type annotation
+  - Fixed `sync-version.sh` to include `create-principles-disciple` package
+
+  ### Infrastructure
+
+  - Added `@changesets/cli` for monorepo version management
+  - Added `data-endpoints-regression.test.ts` with 19 tests

package/README.md

@@ -0,0 +1,66 @@
+<!-- generated-by: gsd-doc-writer -->
+# principles-disciple
+
+Native OpenClaw plugin for Principles Disciple: an evolutionary programming agent framework with strategic guardrails and reflection loops.
+
+## Installation
+
+```bash
+npm install principles-disciple
+```
+
+Requires OpenClaw `>=2026.4.4` as a peer dependency.
+
+## Usage
+
+This plugin integrates with OpenClaw to provide an evolutionary programming framework. It intercepts agent operations through hooks to enforce security guardrails, track pain points, collect trajectory data, and enable deep reflection capabilities.
+
+### Slash Commands
+
+| Command | Description |
+|---------|-------------|
+| `/pd-init` | Initialize workspace |
+| `/pd-bootstrap` | Scan environment tools |
+| `/pd-research` | Research tools and capabilities |
+| `/pd-thinking` | Manage thinking models |
+| `/pd-status` | View evolution status |
+| `/pd-context` | Control context injection |
+| `/pd-focus` | Focus file management |
+| `/pd-evolution-status` | View evolution state |
+| `/pd-rollback` | Rollback to previous state |
+| `/pd-export` | Export trajectory/correction data |
+| `/pd-samples` | Review correction samples |
+| `/pd-nocturnal-review` | Review nocturnal training samples |
+| `/nocturnal-train` | Nocturnal training operations |
+| `/nocturnal-rollout` | Nocturnal rollout and promotion |
+| `/pd-workflow-debug` | Debug workflow state |
+| `/pd-help` | Show command reference |
+
+### Tools
+
+**`deep_reflect`** - Executes deep meta-cognitive reflection to analyze potential risks, logical gaps, or architectural improvements in the current task.
+
+Parameters:
+- `context` (required): Task context, code snippet, or current difficulty
+- `depth` (optional): Reflection depth 1-3 (default: 2)
+- `model_id` (optional): Force specific thinking model
+
+### Configuration
+
+The plugin accepts the following configuration options:
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `language` | `zh` | Interaction language (`en` or `zh`) |
+| `auditLevel` | `medium` | Security guardrail level (`low`, `medium`, `high`) |
+| `riskPaths` | `[]` | High-risk directories requiring explicit authorization |
+| `deep_reflection.enabled` | `true` | Enable AI deep reflection |
+| `deep_reflection.mode` | `auto` | Reflection trigger mode (`auto` or `forced`) |
+
+## Part of the principles monorepo
+
+See the root [README.md](https://github.com/csuzngjh/principles#readme) for the full project overview.
+
+## License
+
+MIT License - [LICENSE](https://github.com/csuzngjh/principles/blob/main/LICENSE)

package/esbuild.config.js

@@ -46,7 +46,7 @@ async function bundlePlugin() {
 
     console.log('Bundle created: dist/bundle.js');
 
-    const staticFiles = ['templates', 'agents', 'openclaw.plugin.json'];
+    const staticFiles = ['templates', 'openclaw.plugin.json'];
     const distDir = 'dist';
 
     for (const file of staticFiles) {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "c159a298aac0",
-    "bundleMd5": "e54bd6b71182252dd335aa016c9caa0e",
-    "builtAt": "2026-04-06T05:28:57.508Z"
+    "gitSha": "a320b37a2418",
+    "bundleMd5": "6a5838169d98e4e6419e736dd034d93a",
+    "builtAt": "2026-04-09T13:57:36.081Z"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",
@@ -32,8 +32,7 @@
     "build:production": "node esbuild.config.js --production && node scripts/build-web.mjs --production && node scripts/verify-build.mjs",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src/",
-    "postinstall": "node scripts/install-dependencies.cjs"
+    "lint": "eslint src/"
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.0",

package/run-nocturnal.mjs

@@ -0,0 +1,30 @@
+import { randomUUID } from 'crypto';
+import * as fs from 'fs';
+
+const workspaceDir = '/home/csuzngjh/.openclaw/workspace-main';
+const stateDir = '/home/csuzngjh/.openclaw/workspace-main/.state';
+
+console.error('WorkspaceDir:', workspaceDir);
+console.error('StateDir:', stateDir);
+
+try {
+  const bundlePath = './dist/nocturnal-service.bundle.js';
+  console.error('Importing from:', bundlePath);
+  
+  const mod = await import(bundlePath);
+  
+  console.log('Available exports:', Object.keys(mod));
+  
+  if (!mod.executeNocturnalReflection) {
+    throw new Error('executeNocturnalReflection not found in bundle. Available exports: ' + Object.keys(mod).join(', '));
+  }
+
+  console.error('Calling executeNocturnalReflection...');
+  const result = await mod.executeNocturnalReflection(workspaceDir, stateDir);
+  
+  console.log(JSON.stringify(result, null, 2));
+} catch (err) {
+  console.error('ERROR:', err.message);
+  if (err.stack) console.error(err.stack);
+  process.exit(1);
+}

package/scripts/db-migrate.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+/**
+ * Database Migration CLI
+ *
+ * Usage:
+ *   node scripts/db-migrate.mjs status              # Show migration status
+ *   node scripts/db-migrate.mjs run [--db trajectory.db|central.db|workflow.db]
+ *   node scripts/db-migrate.mjs rollback [--db trajectory.db|central.db|workflow.db]
+ */
+
+import { Database } from 'better-sqlite3';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Resolve paths
+const PROJECT_ROOT = join(__dirname, '..');
+const STATE_DIR = process.env.STATE_DIR || join(PROJECT_ROOT, '..', '.state');
+
+// We need to dynamically import the schema module since it's TypeScript
+// For CLI, we'll use the compiled JS version
+async function run() {
+  let SchemaModule;
+  try {
+    SchemaModule = await import('../dist/core/schema/index.js');
+  } catch {
+    // Try running from source with tsx
+    console.error('Schema module not found in dist/. Running from source...');
+    console.error('Please build the plugin first: node esbuild.config.js --production');
+    process.exit(1);
+  }
+
+  const { MigrationRunner, ensureDatabaseSchema, ALL_MIGRATIONS, DB_TYPES } = SchemaModule;
+
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command || command === '--help' || command === '-h') {
+    console.log(`
+Database Migration CLI
+
+Usage:
+  node scripts/db-migrate.mjs status              Show migration status for all databases
+  node scripts/db-migrate.mjs run [--db <db>]     Run pending migrations
+  node scripts/db-migrate.mjs rollback [--db <db>] Rollback latest migration
+
+Options:
+  --db <db>    Target database: trajectory.db, central.db, or workflow.db
+               (default: all databases)
+  --state-dir  Override state directory (default: .state/)
+
+Examples:
+  node scripts/db-migrate.mjs status
+  node scripts/db-migrate.mjs run --db trajectory.db
+  node scripts/db-migrate.mjs rollback --db central.db
+`);
+    return;
+  }
+
+  const dbFlag = args.indexOf('--db');
+  const targetDb = dbFlag >= 0 ? args[dbFlag + 1] : null;
+
+  const dbs = targetDb ? [targetDb] : DB_TYPES;
+
+  for (const dbType of dbs) {
+    if (!DB_TYPES.includes(dbType)) {
+      console.error(`Unknown database: ${dbType}. Valid options: ${DB_TYPES.join(', ')}`);
+      continue;
+    }
+
+    const dbPath = getDbPath(dbType);
+    const db = new Database(dbPath);
+
+    console.log(`\n=== ${dbType} (${dbPath}) ===`);
+
+    switch (command) {
+      case 'status':
+        showStatus(db, dbType, ALL_MIGRATIONS, MigrationRunner);
+        break;
+      case 'run':
+        runMigrations(db, dbType, ALL_MIGRATIONS, MigrationRunner);
+        break;
+      case 'rollback':
+        rollbackMigration(db, dbType, ALL_MIGRATIONS, MigrationRunner);
+        break;
+      case 'ensure':
+        console.log('Ensuring schema...');
+        ensureDatabaseSchema(db, dbType);
+        console.log('Schema ensured.');
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+    }
+
+    db.close();
+  }
+}
+
+function getDbPath(dbType) {
+  switch (dbType) {
+    case 'trajectory.db':
+      return join(STATE_DIR, 'trajectory.db');
+    case 'central.db':
+      return join(process.env.HOME, '.openclaw', '.central', 'aggregated.db');
+    case 'workflow.db':
+      return join(STATE_DIR, 'subagent_workflows.db');
+    default:
+      throw new Error(`Unknown database type: ${dbType}`);
+  }
+}
+
+function showStatus(db, dbType, migrations, Runner) {
+  const runner = new Runner(db);
+  const current = runner.getCurrentVersion();
+  const info = runner.getMigrationInfo(migrations, dbType);
+
+  console.log(`Current version: ${current}`);
+  console.log('');
+
+  for (const m of info) {
+    const status = m.applied ? '✅' : '⏳';
+    console.log(`  ${status} ${m.id}-${m.name}`);
+  }
+
+  if (info.length === 0) {
+    console.log('  No migrations defined for this database.');
+  }
+}
+
+function runMigrations(db, dbType, migrations, Runner) {
+  const runner = new Runner(db);
+
+  // First ensure base schema
+  console.log('Applying schema catalog...');
+  runner.applySchemaCatalog(dbType);
+
+  // Then run any additional migrations
+  const dbMigrations = migrations.filter(m => m.db === dbType);
+  if (dbMigrations.length > 0) {
+    const applied = runner.runMigrations(dbMigrations, dbType);
+    if (applied.length === 0) {
+      console.log('All migrations already applied.');
+    }
+  }
+
+  showStatus(db, dbType, migrations, Runner);
+}
+
+function rollbackMigration(db, dbType, migrations, Runner) {
+  const runner = new Runner(db);
+  const dbMigrations = migrations.filter(m => m.db === dbType);
+  const rolledBack = runner.rollback(dbMigrations, dbType);
+
+  if (rolledBack) {
+    console.log(`Rolled back migration ${rolledBack}`);
+  } else {
+    console.log('No migrations to roll back.');
+  }
+
+  showStatus(db, dbType, migrations, Runner);
+}
+
+run().catch(err => {
+  console.error('Migration CLI error:', err);
+  process.exit(1);
+});

package/scripts/sync-plugin.mjs

@@ -54,6 +54,7 @@ function parseArgs() {
         force: false,
         restart: false,
         dev: false,
+        bump: false,
         help: false,
     };
 
@@ -78,6 +79,11 @@ function parseArgs() {
                 args.dev = true;
                 args.force = true;
                 args.restart = true;
+                args.bump = true;
+                break;
+            case '--bump':
+            case '-b':
+                args.bump = true;
                 break;
             case '--force':
             case '-f':
@@ -112,7 +118,8 @@ Options:
   --skip-build       Skip build step (use existing dist/)
   --skip-deps        Skip dependency installation
   --restart          Automatically restart OpenClaw gateway after installation
-  --dev, -d          Developer mode: --force + --restart + clean stale backups (default for local dev)
+  --dev, -d          Developer mode: --force + --restart + --bump + clean stale backups
+  --bump, -b         Auto-bump patch version if there are uncommitted source changes
   --force, -f        Force overwrite without prompts
   --help, -h         Show this help message
 
@@ -123,9 +130,12 @@ Examples:
   # Install with English skills
   node scripts/sync-plugin.mjs --lang en
 
-  # Developer mode: build, deploy, restart, clean up (recommended for debugging)
+  # Developer mode: bump version, build, deploy, restart, clean up (recommended)
   node scripts/sync-plugin.mjs --dev
 
+  # Just bump version without deploying
+  node scripts/sync-plugin.mjs --bump --skip-build --skip-deps
+
   # Quick sync after local build
   node scripts/sync-plugin.mjs --skip-deps --skip-build
 
@@ -206,6 +216,80 @@ function getVersion(dir) {
     }
 }
 
+/**
+ * Auto-bump patch version if there are uncommitted source changes.
+ * Updates all version files: package.json (root + plugin), openclaw.plugin.json, README_ZH.md.
+ */
+function autoBumpVersion(sourceDir) {
+    const rootDir = join(sourceDir, '..', '..');
+    const pluginDir = sourceDir;
+
+    // Check for uncommitted changes in source files
+    try {
+        const diffOutput = execSync('git diff --name-only HEAD', {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        }).trim();
+        const changedFiles = diffOutput ? diffOutput.split('\n').filter(f => {
+            return f.startsWith('packages/openclaw-plugin/src/') ||
+                   f.startsWith('packages/openclaw-plugin/skills/') ||
+                   f.startsWith('scripts/') ||
+                   f === 'packages/openclaw-plugin/package.json' ||
+                   f === 'package.json' ||
+                   f === 'README_ZH.md';
+        }) : [];
+
+        if (changedFiles.length === 0) {
+            console.log('📋 No uncommitted source changes — skipping version bump');
+            return;
+        }
+
+        console.log(`📋 Found uncommitted changes in ${changedFiles.length} file(s) — bumping version...`);
+
+        const currentVersion = getVersion(pluginDir);
+        if (!currentVersion) {
+            console.error('❌ Cannot determine current version');
+            process.exit(1);
+        }
+
+        const [major, minor, patch] = currentVersion.split('.').map(Number);
+        const newVersion = `${major}.${minor}.${patch + 1}`;
+
+        // Update package.json (plugin)
+        const pkgPath = join(pluginDir, 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        pkg.version = newVersion;
+        writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+
+        // Update openclaw.plugin.json
+        const manifestPath = join(pluginDir, 'openclaw.plugin.json');
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+        manifest.version = newVersion;
+        writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+
+        // Update root package.json
+        const rootPkgPath = join(rootDir, 'package.json');
+        if (existsSync(rootPkgPath)) {
+            const rootPkg = JSON.parse(readFileSync(rootPkgPath, 'utf-8'));
+            rootPkg.version = newVersion;
+            writeFileSync(rootPkgPath, JSON.stringify(rootPkg, null, 2) + '\n', 'utf-8');
+        }
+
+        // Update README_ZH.md
+        const readmePath = join(rootDir, 'README_ZH.md');
+        if (existsSync(readmePath)) {
+            let readme = readFileSync(readmePath, 'utf-8');
+            readme = readme.replace(/v\d+\.\d+\.\d+/g, `v${newVersion}`);
+            writeFileSync(readmePath, readme, 'utf-8');
+        }
+
+        console.log(`✅ Version bumped: ${currentVersion} → ${newVersion}`);
+    } catch (err) {
+        console.warn(`⚠️  Auto-bump failed: ${err.message}`);
+        console.warn('   Continuing with current version');
+    }
+}
+
 /**
  * Install project dependencies
  */
@@ -693,12 +777,17 @@ function main() {
     console.log('║     Principles Disciple Plugin Installer                   ║');
     console.log('╚════════════════════════════════════════════════════════════╝\n');
 
-    // Dev mode: auto-force, auto-restart, clean stale backups
+    // Dev mode: auto-force, auto-restart, auto-bump, clean stale backups
     if (args.dev) {
-        console.log('🛠️  DEV MODE: force + restart + stale backup cleanup\n');
+        console.log('🛠️  DEV MODE: force + restart + bump + stale backup cleanup\n');
+    }
+
+    // Auto-bump version if requested
+    if (args.bump) {
+        autoBumpVersion(SOURCE_DIR);
     }
 
-    // Get source version
+    // Get source version (after potential bump)
     const sourceVersion = getVersion(SOURCE_DIR);
     if (!sourceVersion) {
         console.error('❌ Cannot determine source version. Check package.json.');

package/src/commands/archive-impl.ts

@@ -0,0 +1,136 @@
+/**
+ * Archive Implementation Command — CLI `/pd-archive-impl`
+ * ========================================================
+ *
+ * PURPOSE: Permanently archive an implementation (disabled -> archived,
+ * active -> archived, or candidate -> archived).
+ *
+ * Used for permanent cleanup of implementations that are no longer relevant.
+ */
+
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { refreshPrincipleLifecycle } from '../core/principle-internalization/lifecycle-refresh.js';
+import {
+  loadLedger,
+  transitionImplementationState,
+  updateImplementation,
+} from '../core/principle-tree-ledger.js';
+import type { Implementation, ImplementationLifecycleState } from '../types/principle-tree-schema.js';
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+
+/**
+ * Get all implementations from the ledger.
+ */
+function getAllImplementations(stateDir: string): Implementation[] {
+  const ledger = loadLedger(stateDir);
+  return Object.values(ledger.tree.implementations);
+}
+
+/**
+ * Valid archive transitions: disabled -> archived, active -> archived, candidate -> archived
+ */
+function canArchive(state: ImplementationLifecycleState): boolean {
+  return ['disabled', 'active', 'candidate'].includes(state);
+}
+
+/**
+ * Handle the /pd-archive-impl command.
+ *
+ * Usage:
+ *   /pd-archive-impl <implId>   - Archive an implementation
+ *   /pd-archive-impl list       - List archivable implementations
+ */
+export function handleArchiveImplCommand(ctx: PluginCommandContext): PluginCommandResult {
+  const workspaceDir = (ctx.config?.workspaceDir as string) || process.cwd();
+  const {stateDir} = WorkspaceContext.fromHookContext({ ...ctx, workspaceDir });
+  const lang = (ctx.config?.language as string) || 'en';
+  const isZh = lang === 'zh';
+
+  const args = (ctx.args || '').trim().split(/\s+/);
+  const subcommand = args[0] || '';
+
+  // Subcommand: list
+  if (subcommand === 'list') {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: Mutual recursion between helper functions - reordering would break logical grouping
+    return _handleListArchivable(stateDir, isZh);
+  }
+
+  // Archive by ID
+  const targetId = subcommand;
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: Mutual recursion between helper functions - reordering would break logical grouping
+  return _handleArchiveImpl(workspaceDir, stateDir, targetId, isZh);
+}
+
+function _handleListArchivable(
+  stateDir: string,
+  isZh: boolean
+): PluginCommandResult {
+  const allImpls = getAllImplementations(stateDir);
+  const archivable = allImpls.filter(
+    (impl) => canArchive(impl.lifecycleState || 'candidate')
+  );
+
+  if (archivable.length === 0) {
+    return {
+      text: isZh
+        ? '\n\u2139\ufe0f \u6ca1\u6709\u53ef\u5f52\u6863\u7684\u5b9e\u73b0\u3002'
+        : '\n\u2139\ufe0f No implementations available to archive.',
+    };
+  }
+
+  let output = isZh ? '\n\ud83d\udccb \u53ef\u5f52\u6863\u5b9e\u73b0\n' : '\n\ud83d\udccb Available Implementations to Archive\n';
+  output += `${'='.repeat(50)}\n`;
+
+  for (const impl of archivable) {
+    const stateLabel = impl.lifecycleState || 'candidate';
+    output += `  ${impl.id}\n`;
+    output += `    Rule: ${impl.ruleId} | State: ${stateLabel}\n\n`;
+  }
+
+  output += isZh
+    ? '\u7528\u6cd5: /pd-archive-impl <implId>'
+    : 'Usage: /pd-archive-impl <implId>';
+
+  return { text: output };
+}
+
+// eslint-disable-next-line @typescript-eslint/max-params -- Reason: Command handler signature must match OpenClaw plugin interface - breaking API change to options objects would affect public contracts
+function _handleArchiveImpl(
+  workspaceDir: string,
+  stateDir: string,
+  implId: string,
+  isZh: boolean
+): PluginCommandResult {
+  const allImpls = getAllImplementations(stateDir);
+  const target = allImpls.find((i) => i.id === implId);
+
+  if (!target) {
+    return {
+      text: isZh
+        ? `\u274c \u672a\u627e\u5230\u5b9e\u73b0: ${implId}`
+        : `\u274c Implementation not found: ${implId}`,
+    };
+  }
+
+  const currentState = target.lifecycleState || 'candidate';
+
+  if (!canArchive(currentState)) {
+    return {
+      text: isZh
+        ? `\u274c \u5b9e\u73b0 ${implId} \u4e0d\u80fd\u4ece ${currentState} \u5f52\u6863\u3002\u5df2\u5f52\u6863\u7684\u5b9e\u73b0\u4e0d\u80fd\u518d\u6b21\u5f52\u6863\u3002`
+        : `\u274c Implementation ${implId} cannot be archived from state: ${currentState}. Archived implementations cannot be archived again.`,
+    };
+  }
+
+  transitionImplementationState(stateDir, implId, 'archived');
+  updateImplementation(stateDir, implId, {
+    archivedAt: new Date().toISOString(),
+  });
+  refreshPrincipleLifecycle(workspaceDir, stateDir);
+
+  return {
+    text: isZh
+      ? `\n\u2705 \u5b9e\u73b0\u5df2\u5f52\u6863: ${implId}\n   \u72b6\u6001: ${currentState} -> archived`
+      : `\n\u2705 Implementation archived: ${implId}\n   State: ${currentState} -> archived`,
+  };
+}

package/src/commands/capabilities.ts

@@ -13,16 +13,18 @@ const TOOLS_TO_SCAN = [
   { name: 'shellcheck', cmd: ['shellcheck', '--version'] },
 ];
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: third-party API execSync returns dynamic output - type structure unknown at call site
 function scanEnvironment(wctx: WorkspaceContext): any {
   const tools: Record<string, { available: boolean; version?: string }> = {};
 
   for (const tool of TOOLS_TO_SCAN) {
     try {
-      const output = execSync(tool.cmd.join(' '), { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+      const [versionLine] = execSync(tool.cmd.join(' '), { stdio: ['ignore', 'pipe', 'ignore'] }).toString().split('\n');
       tools[tool.name] = {
         available: true,
-        version: output.split('\n')[0].trim(),
+        version: versionLine.trim(),
       };
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars -- Reason: catch parameter intentionally unused - we only care that the command failed
     } catch (_e) {
       tools[tool.name] = { available: false };
     }

package/src/commands/context.ts

@@ -1,7 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
-import { ContextInjectionConfig, defaultContextConfig } from '../types.js';
+import type { ContextInjectionConfig} from '../types.js';
+import { defaultContextConfig } from '../types.js';
 import { loadContextInjectionConfig } from '../hooks/prompt.js';
 
 /**
@@ -97,6 +98,7 @@ function showStatus(workspaceDir: string, isZh: boolean): string {
 /**
  * Toggle a boolean setting
  */
+// eslint-disable-next-line @typescript-eslint/max-params -- Reason: Command handler signature requires specific params - refactoring would break public API contract
 function toggleSetting(
     workspaceDir: string,
     key: 'thinkingOs' | 'reflectionLog',
@@ -211,6 +213,7 @@ function applyPreset(
     preset: 'minimal' | 'standard' | 'full',
     isZh: boolean
 ): string {
+    // eslint-disable-next-line @typescript-eslint/init-declarations -- Reason: assigned in switch block immediately after declaration
     let config: ContextInjectionConfig;
     
     switch (preset) {
@@ -311,6 +314,7 @@ export function handleContextCommand(ctx: PluginCommandContext): PluginCommandRe
     // Detect language from context
     const isZh = (ctx.config?.language as string) === 'zh';
     
+    // eslint-disable-next-line @typescript-eslint/init-declarations -- Reason: assigned in switch block immediately after declaration
     let result: string;
     
     switch (subCommand) {