principles-disciple 1.11.0 → 1.13.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.13.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "c159a298aac0",
-    "bundleMd5": "e54bd6b71182252dd335aa016c9caa0e",
-    "builtAt": "2026-04-06T05:28:57.508Z"
+    "gitSha": "ad52c5fcc9c5",
+    "bundleMd5": "3dc29cb961c7132e1ad419550686df6c",
+    "builtAt": "2026-04-10T01:19:54.357Z"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.11.0",
+  "version": "1.13.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

@@ -17,7 +17,7 @@
  *   --help             Show help message
  */
 
-import { copyFileSync, cpSync, existsSync, rmSync, readFileSync, readFileSync as readFileSyncRaw, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { copyFileSync, cpSync, existsSync, rmSync, readFileSync, readFileSync as readFileSyncRaw, mkdirSync, writeFileSync, readdirSync, statSync } from 'fs';
 import { createHash } from 'crypto';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -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
  */
@@ -583,6 +667,158 @@ function syncItem(item) {
     }
 }
 
+/**
+ * Sync workspace templates to all workspace directories.
+ * This ensures workspaces get the latest template files when the plugin is updated.
+ *
+ * IMPORTANT SAFETY RULES:
+ * - Core files (AGENTS.md, SOUL.md, IDENTITY.md, USER.md, etc.) are NEVER overwritten.
+ *   They are only copied on first-time workspace creation (file doesn't exist).
+ *   Users heavily customize these files — overwriting would destroy their work.
+ * - Non-core templates (pain_samples, THINKING_OS.md, workspace boilerplate) are synced
+ *   via MD5 comparison (only update if template content changed and workspace hasn't diverged).
+ *
+ * Syncs:
+ *   - templates/workspace/** → workspace root (recursive, skip core files)
+ *   - templates/langs/{lang}/core/** → workspace root (ONLY if missing)
+ *   - templates/langs/{lang}/pain/** → .state/pain_samples/
+ *   - templates/langs/{lang}/principles/THINKING_OS.md → .principles/THINKING_OS.md
+ */
+function syncWorkspaceTemplates(lang) {
+    const workspacesRoot = OPENCLAW_DIR;
+    if (!existsSync(workspacesRoot)) return;
+
+    const entries = readdirSync(workspacesRoot);
+    const workspaceDirs = entries.filter(e =>
+        e.startsWith('workspace-') || e === 'workspace'
+    );
+
+    if (workspaceDirs.length === 0) return;
+
+    // Core files that should NEVER be overwritten after creation
+    const CORE_FILES = new Set([
+        'AGENTS.md', 'SOUL.md', 'BOOT.md', 'BOOTSTRAP.md',
+        'IDENTITY.md', 'USER.md', 'TOOLS.md', 'HEARTBEAT.md',
+        'PRINCIPLES.md', 'PROFILE.json',
+    ]);
+
+    let updated = 0;
+
+    // Helper: compute MD5 of a file
+    function md5(filePath) {
+        try {
+            const content = readFileSyncRaw(filePath);
+            return createHash('md5').update(content).digest('hex');
+        } catch {
+            return null;
+        }
+    }
+
+    for (const ws of workspaceDirs) {
+        const wsDir = join(workspacesRoot, ws);
+
+        // 1. templates/workspace/** → workspace root (recursive)
+        const workspaceTemplateDir = join(SOURCE_DIR, 'templates', 'workspace');
+        if (existsSync(workspaceTemplateDir)) {
+            updated += syncDirRecursive(workspaceTemplateDir, wsDir, md5, CORE_FILES);
+        }
+
+        // 2. templates/langs/{lang}/core/** → workspace root (ONLY if file missing)
+        const coreDir = join(SOURCE_DIR, 'templates', 'langs', lang, 'core');
+        if (existsSync(coreDir)) {
+            updated += syncCoreFiles(coreDir, wsDir);
+        } else {
+            const zhCoreDir = join(SOURCE_DIR, 'templates', 'langs', 'zh', 'core');
+            if (existsSync(zhCoreDir)) {
+                updated += syncCoreFiles(zhCoreDir, wsDir);
+            }
+        }
+
+        // 3. templates/langs/{lang}/pain/** → .state/pain_samples/
+        const painSrc = join(SOURCE_DIR, 'templates', 'langs', lang, 'pain');
+        const painDest = join(wsDir, '.state', 'pain_samples');
+        if (existsSync(painSrc)) {
+            updated += syncDirRecursive(painSrc, painDest, md5, CORE_FILES);
+        }
+
+        // 4. templates/langs/{lang}/principles/THINKING_OS.md → .principles/THINKING_OS.md
+        const thinkingOsSrc = join(SOURCE_DIR, 'templates', 'langs', lang, 'principles', 'THINKING_OS.md');
+        const thinkingOsDest = join(wsDir, '.principles', 'THINKING_OS.md');
+        if (existsSync(thinkingOsSrc)) {
+            const srcMd5 = md5(thinkingOsSrc);
+            const destMd5 = existsSync(thinkingOsDest) ? md5(thinkingOsDest) : null;
+            if (srcMd5 !== destMd5) {
+                if (!existsSync(join(wsDir, '.principles'))) {
+                    mkdirSync(join(wsDir, '.principles'), { recursive: true });
+                }
+                cpSync(thinkingOsSrc, thinkingOsDest, { force: true });
+                updated++;
+            }
+        }
+    }
+
+    if (updated > 0) {
+        console.log(`   📄 Workspace templates → ${updated} file(s) synced across ${workspaceDirs.length} workspace(s)`);
+    }
+}
+
+/**
+ * Sync core files ONLY if they don't exist yet.
+ * NEVER overwrites existing core files (user customizations).
+ */
+function syncCoreFiles(srcDir, destDir) {
+    let count = 0;
+    if (!existsSync(srcDir)) return count;
+
+    const items = readdirSync(srcDir);
+    for (const item of items) {
+        const srcPath = join(srcDir, item);
+        const destPath = join(destDir, item);
+        const stat = statSync(srcPath);
+
+        if (stat.isDirectory()) continue;
+        // Core files: only copy if missing
+        if (!existsSync(destPath)) {
+            cpSync(srcPath, destPath, { force: false });
+            count++;
+        }
+    }
+    return count;
+}
+
+/**
+ * Recursively sync source dir to dest dir, skipping core files that already exist.
+ * Non-core files: only copy if missing or different (MD5).
+ */
+function syncDirRecursive(srcDir, destDir, md5Fn, coreFiles) {
+    let count = 0;
+    if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+    }
+
+    const items = readdirSync(srcDir);
+    for (const item of items) {
+        const srcPath = join(srcDir, item);
+        const destPath = join(destDir, item);
+        const stat = statSync(srcPath);
+
+        if (stat.isDirectory()) {
+            count += syncDirRecursive(srcPath, destPath, md5Fn, coreFiles);
+        } else {
+            // Skip core files that already exist
+            if (coreFiles.has(item) && existsSync(destPath)) continue;
+
+            const srcMd5 = md5Fn(srcPath);
+            const destMd5 = existsSync(destPath) ? md5Fn(destPath) : null;
+            if (srcMd5 !== destMd5) {
+                cpSync(srcPath, destPath, { force: true });
+                count++;
+            }
+        }
+    }
+    return count;
+}
+
 /**
  * Install production dependencies in target directory
  */
@@ -693,12 +929,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.');
@@ -736,6 +977,9 @@ function main() {
     // Step 7: Sync skills
     syncSkills(args.lang);
 
+    // Step 7.5: Sync THINKING_OS.md to all workspace .principles/ directories
+    syncWorkspaceTemplates(args.lang);
+
     // Step 8: Install production dependencies in target (ALWAYS — cleanTargetDir wiped node_modules)
     // --skip-deps only applies to SOURCE directory deps, not the installed plugin.
     installTargetDependencies();