principles-disciple 1.155.0 → 1.157.0

package/dist/core/thinking-models.d.ts

@@ -10,7 +10,7 @@
  *   BUILTIN_PATTERNS (engine) → detection regexes per model id
  *   THINKING_MODELS (merged) → full definitions with patterns
  */
-export interface ThinkingModelDefinition {
+interface ThinkingModelDefinition {
     id: string;
     name: string;
     description: string;
@@ -18,11 +18,11 @@ export interface ThinkingModelDefinition {
     patterns: RegExp[];
     baselineScenarios: string[];
 }
-export interface ThinkingModelMatch {
+interface ThinkingModelMatch {
     modelId: string;
     matchedPattern: string;
 }
-export interface ThinkingScenarioContext {
+interface ThinkingScenarioContext {
     recentToolCalls?: {
         toolName: string;
         outcome: 'success' | 'failure' | 'blocked';
@@ -51,20 +51,6 @@ export interface ThinkingScenarioContext {
  * @param workspaceDir Optional. If provided, loads from that workspace's THINKING_OS.md.
  */
 export declare function listThinkingModels(workspaceDir?: string): ThinkingModelDefinition[];
-/**
- * Clear the cached model definitions.
- * Call this when THINKING_OS.md changes.
- */
-export declare function clearThinkingModelCache(): void;
-export declare function getThinkingModel(modelId: string, workspaceDir?: string): ThinkingModelDefinition | undefined;
 export declare function detectThinkingModelMatches(text: string, workspaceDir?: string): ThinkingModelMatch[];
-/**
- * Get all model definitions for display purposes (no patterns).
- */
-export declare function getThinkingModelDefinitions(workspaceDir?: string): {
-    modelId: string;
-    name: string;
-    description: string;
-    antiPattern?: string;
-}[];
 export declare function deriveThinkingScenarios(modelId: string, context: ThinkingScenarioContext): string[];
+export {};

package/dist/core/thinking-models.js

@@ -213,15 +213,7 @@ export function listThinkingModels(workspaceDir) {
     _cachedWorkspace = cacheKey;
     return models.slice();
 }
-/**
- * Clear the cached model definitions.
- * Call this when THINKING_OS.md changes.
- */
-export function clearThinkingModelCache() {
-    _cachedDefinitions = null;
-    _cachedWorkspace = null;
-}
-export function getThinkingModel(modelId, workspaceDir) {
+function getThinkingModel(modelId, workspaceDir) {
     const models = listThinkingModels(workspaceDir);
     return models.find(m => m.id === modelId);
 }
@@ -243,17 +235,6 @@ export function detectThinkingModelMatches(text, workspaceDir) {
     }
     return matches;
 }
-/**
- * Get all model definitions for display purposes (no patterns).
- */
-export function getThinkingModelDefinitions(workspaceDir) {
-    return listThinkingModels(workspaceDir).map(m => ({
-        modelId: m.id,
-        name: m.id + ': ' + m.name,
-        description: m.description,
-        antiPattern: m.antiPattern,
-    }));
-}
 export function deriveThinkingScenarios(modelId, context) {
     const scenarios = new Set(getThinkingModel(modelId)?.baselineScenarios ?? []);
     if ((context.recentToolCalls ?? []).some((call) => call.outcome === 'failure')) {

package/dist/core/trajectory.js

@@ -69,6 +69,8 @@ function applyTrajectorySchema(db) {
       empathy_signal_json TEXT NOT NULL,
       blob_ref TEXT,
       raw_excerpt TEXT,
+      stop_reason TEXT,
+      thinking_blocks_count INTEGER,
       created_at TEXT NOT NULL
     );
     CREATE TABLE IF NOT EXISTS user_turns (
@@ -95,6 +97,7 @@ function applyTrajectorySchema(db) {
       gfi_before REAL,
       gfi_after REAL,
       params_json TEXT NOT NULL,
+      result_preview TEXT,
       created_at TEXT NOT NULL
     );
     CREATE TABLE IF NOT EXISTS pain_events (
@@ -107,6 +110,8 @@ function applyTrajectorySchema(db) {
       origin TEXT,
       confidence REAL,
       text TEXT,
+      canonical_pain_id TEXT,
+      runtime_task_id TEXT,
       created_at TEXT NOT NULL
     );
     CREATE TABLE IF NOT EXISTS gate_blocks (
@@ -185,6 +190,12 @@ function applyTrajectorySchema(db) {
       started_at TEXT,
       completed_at TEXT,
       resolution TEXT,
+      task_kind TEXT,
+      priority TEXT,
+      retry_count INTEGER,
+      max_retries INTEGER,
+      last_error TEXT,
+      result_ref TEXT,
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     );

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.155.0",
+  "version": "1.157.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.155.0",
+  "version": "1.157.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/index.js",

package/dist/core/evolution-migration.d.ts

@@ -1,5 +0,0 @@
-export interface MigrationResult {
-    importedEvents: number;
-    streamPath: string;
-}
-export declare function migrateLegacyEvolutionData(workspaceDir: string): MigrationResult;

package/dist/core/evolution-migration.js

@@ -1,65 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { stableContentHash } from './evolution-reducer.js';
-import { SystemLogger } from './system-logger.js';
-function appendEvent(streamPath, event) {
-    fs.appendFileSync(streamPath, `${JSON.stringify(event)}\n`, 'utf8');
-}
-function loadImportedHashes(streamPath, workspaceDir) {
-    if (!fs.existsSync(streamPath))
-        return new Set();
-    const raw = fs.readFileSync(streamPath, 'utf8').trim();
-    if (!raw)
-        return new Set();
-    const hashes = new Set();
-    for (const line of raw.split('\n')) {
-        try {
-            const event = JSON.parse(line);
-            if (event.type !== 'legacy_import')
-                continue;
-            const hash = event.data.contentHash;
-            if (typeof hash === 'string')
-                hashes.add(hash);
-        }
-        catch (e) {
-            SystemLogger.log(workspaceDir, 'MIGRATION_WARN', `skip malformed line: ${String(e)}`);
-        }
-    }
-    return hashes;
-}
-export function migrateLegacyEvolutionData(workspaceDir) {
-    const streamPath = path.join(workspaceDir, 'memory', 'evolution.jsonl');
-    fs.mkdirSync(path.dirname(streamPath), { recursive: true });
-    const candidates = [
-        path.join(workspaceDir, 'memory', 'ISSUE_LOG.md'),
-        path.join(workspaceDir, 'memory', 'DECISIONS.md'),
-        path.join(workspaceDir, '.principles', 'PRINCIPLES.md'),
-    ];
-    const existingHashes = loadImportedHashes(streamPath, workspaceDir);
-    let importedEvents = 0;
-    for (const sourceFile of candidates) {
-        if (!fs.existsSync(sourceFile)) {
-            continue;
-        }
-        const content = fs.readFileSync(sourceFile, 'utf8').trim();
-        if (!content) {
-            continue;
-        }
-        const contentHash = stableContentHash(`${sourceFile}:${content}`);
-        if (existingHashes.has(contentHash)) {
-            continue;
-        }
-        appendEvent(streamPath, {
-            ts: new Date().toISOString(),
-            type: 'legacy_import',
-            data: {
-                sourceFile: path.relative(workspaceDir, sourceFile),
-                content,
-                contentHash,
-            },
-        });
-        importedEvents += 1;
-        existingHashes.add(contentHash);
-    }
-    return { importedEvents, streamPath };
-}

package/dist/core/rule-host-helpers.d.ts

@@ -1,8 +0,0 @@
-/**
- * Rule Host Helpers — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-helpers.ts
- */
-export type { RuleHostHelpers } from '@principles/core/runtime-v2';
-export { createRuleHostHelpers } from '@principles/core/runtime-v2';

package/dist/core/rule-host-helpers.js

@@ -1,7 +0,0 @@
-/**
- * Rule Host Helpers — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-helpers.ts
- */
-export { createRuleHostHelpers } from '@principles/core/runtime-v2';

package/dist/core/rule-host-types.d.ts

@@ -1,7 +0,0 @@
-/**
- * Rule Host Types — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-contracts.ts
- */
-export type { RuleHostInput, RuleHostDecision, RuleHostMeta, RuleHostResult, LoadedImplementation, } from '@principles/core/runtime-v2';

package/dist/core/rule-host-types.js

@@ -1,7 +0,0 @@
-/**
- * Rule Host Types — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-contracts.ts
- */
-export {};

package/dist/core/schema/db-types.d.ts

@@ -1,11 +0,0 @@
-/**
- * Shared type definitions for database operations.
- * Kept separate to avoid circular dependencies between schema-definitions and migration-runner.
- */
-/** Minimal interface for better-sqlite3 Database instances. */
-export interface Db {
-    exec(_sql: string): unknown;
-    get<T = unknown>(_sql: string, ..._params: unknown[]): T | undefined;
-    run(_sql: string, ..._params: unknown[]): unknown;
-    close(): void;
-}

package/dist/core/schema/db-types.js

@@ -1,5 +0,0 @@
-/**
- * Shared type definitions for database operations.
- * Kept separate to avoid circular dependencies between schema-definitions and migration-runner.
- */
-export {};

package/dist/core/schema/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * Schema Management — Unified database schema definitions and migrations.
- *
- * Usage:
- *   // In a database class constructor:
- *   import { ensureDatabaseSchema } from './schema';
- *   ensureDatabaseSchema(db, 'trajectory.db');
- *
- * CLI:
- *   node scripts/db-migrate.mjs status
- *   node scripts/db-migrate.mjs run
- */
-export { MigrationRunner, ensureDatabaseSchema } from './migration-runner.js';
-export { SCHEMAS, getCatalog, DB_TYPES } from './schema-definitions.js';
-export { ALL_MIGRATIONS } from './migrations/index.js';
-export type { Db } from './db-types.js';
-export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog, } from './migration-runner.js';

package/dist/core/schema/index.js

@@ -1,15 +0,0 @@
-/**
- * Schema Management — Unified database schema definitions and migrations.
- *
- * Usage:
- *   // In a database class constructor:
- *   import { ensureDatabaseSchema } from './schema';
- *   ensureDatabaseSchema(db, 'trajectory.db');
- *
- * CLI:
- *   node scripts/db-migrate.mjs status
- *   node scripts/db-migrate.mjs run
- */
-export { MigrationRunner, ensureDatabaseSchema } from './migration-runner.js';
-export { SCHEMAS, getCatalog, DB_TYPES } from './schema-definitions.js';
-export { ALL_MIGRATIONS } from './migrations/index.js';

package/dist/core/schema/migration-runner.d.ts

@@ -1,53 +0,0 @@
-/**
- * Migration Runner — Executes and tracks schema migrations.
- *
- * Each migration is versioned. The runner reads the current version from
- * the `schema_version` table and only executes migrations with higher IDs.
- *
- * Usage:
- *   const runner = new MigrationRunner(db);
- *   runner.run(allMigrations.filter(m => m.db === 'trajectory.db'));
- */
-import type { Migration } from './schema-definitions.js';
-import { type DbType } from './schema-definitions.js';
-import type { Db } from './db-types.js';
-export declare class MigrationRunner {
-    private readonly db;
-    constructor(db: Db);
-    /**
-     * Run all pending migrations for a given database type.
-     * @returns Array of migration names that were applied
-     */
-    runMigrations(migrations: Migration[], _dbType: DbType): string[];
-    /**
-     * Apply all schema definitions (tables, indexes, views, FTS) for a database.
-     * This is a convenience method that creates everything from the schema catalog.
-     * Used for initial setup when no migrations exist yet.
-     */
-    applySchemaCatalog(dbType: DbType): void;
-    /**
-     * Get the current migration version.
-     * Returns '000' if no version is set (fresh database).
-     */
-    getCurrentVersion(): string;
-    /**
-     * Get all available migration info for a database type.
-     */
-    getMigrationInfo(migrations: Migration[], dbType: DbType): {
-        id: string;
-        name: string;
-        applied: boolean;
-    }[];
-    /**
-     * Rollback the latest migration (if down migration is defined).
-     */
-    rollback(migrations: Migration[], dbType: DbType): string | null;
-    private ensureVersionTable;
-    private setVersion;
-}
-/**
- * Factory: create a MigrationRunner and apply schema catalog for a given database.
- * This is the main entry point for database classes.
- */
-export declare function ensureDatabaseSchema(db: Db, dbType: DbType): void;
-export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog } from './schema-definitions.js';

package/dist/core/schema/migration-runner.js

@@ -1,170 +0,0 @@
-/**
- * Migration Runner — Executes and tracks schema migrations.
- *
- * Each migration is versioned. The runner reads the current version from
- * the `schema_version` table and only executes migrations with higher IDs.
- *
- * Usage:
- *   const runner = new MigrationRunner(db);
- *   runner.run(allMigrations.filter(m => m.db === 'trajectory.db'));
- */
-import { getCatalog } from './schema-definitions.js';
-export class MigrationRunner {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    /**
-     * Run all pending migrations for a given database type.
-     * @returns Array of migration names that were applied
-     */
-    runMigrations(migrations, _dbType) {
-        // NOTE: _dbType is kept for API signature compatibility but migrations are pre-filtered by caller
-        void _dbType;
-        // Ensure schema_version table exists before anything else
-        this.ensureVersionTable();
-        const currentVersion = this.getCurrentVersion();
-        const applied = [];
-        // Filter to pending migrations (higher ID than current)
-        const pending = migrations
-            .filter(m => m.id > currentVersion)
-            .sort((a, b) => a.id.localeCompare(b.id));
-        for (const migration of pending) {
-            console.log(`[MigrationRunner] Applying ${migration.id}-${migration.name}...`);
-            try {
-                migration.up(this.db);
-                this.setVersion(migration.id);
-                applied.push(`${migration.id}-${migration.name}`);
-            }
-            catch (err) {
-                throw new Error(`Migration ${migration.id}-${migration.name} failed: ${String(err)}`, { cause: err });
-            }
-        }
-        if (applied.length > 0) {
-            console.log(`[MigrationRunner] Applied ${applied.length} migration(s): ${applied.join(', ')}`);
-        }
-        return applied;
-    }
-    /**
-     * Apply all schema definitions (tables, indexes, views, FTS) for a database.
-     * This is a convenience method that creates everything from the schema catalog.
-     * Used for initial setup when no migrations exist yet.
-     */
-    applySchemaCatalog(dbType) {
-        this.ensureVersionTable();
-        const catalog = getCatalog(dbType);
-        // Tables
-        for (const [key, table] of Object.entries(catalog.tables)) {
-            try {
-                this.db.exec(table.ddl);
-            }
-            catch (err) {
-                throw new Error(`Failed to create table ${key}: ${String(err)}`, { cause: err });
-            }
-            // Indexes
-            for (const indexDdl of table.indexes ?? []) {
-                try {
-                    this.db.exec(indexDdl);
-                }
-                catch (err) {
-                    throw new Error(`Failed to create index for ${key}: ${String(err)}`, { cause: err });
-                }
-            }
-        }
-        // Views
-        for (const [key, view] of Object.entries(catalog.views)) {
-            try {
-                this.db.exec(view.ddl);
-            }
-            catch (err) {
-                throw new Error(`Failed to create view ${key}: ${String(err)}`, { cause: err });
-            }
-        }
-        // FTS5 virtual tables
-        for (const [key, fts] of Object.entries(catalog.fts)) {
-            try {
-                this.db.exec(fts.ddl);
-            }
-            catch (err) {
-                throw new Error(`Failed to create FTS table ${key}: ${String(err)}`, { cause: err });
-            }
-        }
-    }
-    /**
-     * Get the current migration version.
-     * Returns '000' if no version is set (fresh database).
-     */
-    getCurrentVersion() {
-        try {
-            const row = this.db.get('SELECT version FROM schema_version ORDER BY version DESC LIMIT 1');
-            return row?.version ?? '000';
-        }
-        catch {
-            return '000';
-        }
-    }
-    /**
-     * Get all available migration info for a database type.
-     */
-    getMigrationInfo(migrations, dbType) {
-        const currentVersion = this.getCurrentVersion();
-        return migrations
-            .filter(m => m.db === dbType)
-            .sort((a, b) => a.id.localeCompare(b.id))
-            .map(m => ({
-            id: m.id,
-            name: m.name,
-            applied: m.id <= currentVersion,
-        }));
-    }
-    /**
-     * Rollback the latest migration (if down migration is defined).
-     */
-    rollback(migrations, dbType) {
-        const currentVersion = this.getCurrentVersion();
-        if (currentVersion === '000')
-            return null;
-        const migration = migrations.find(m => m.db === dbType && m.id === currentVersion);
-        if (!migration)
-            return null;
-        if (!migration.down) {
-            throw new Error(`Migration ${migration.id}-${migration.name} has no down migration`);
-        }
-        console.log(`[MigrationRunner] Rolling back ${migration.id}-${migration.name}...`);
-        migration.down(this.db);
-        // Set version to previous migration
-        const previousMigrations = migrations
-            .filter(m => m.db === dbType && m.id < currentVersion)
-            .sort((a, b) => b.id.localeCompare(a.id));
-        const newVersion = previousMigrations[0]?.id ?? '000';
-        this.setVersion(newVersion);
-        console.log(`[MigrationRunner] Rolled back to ${newVersion}`);
-        return migration.id;
-    }
-    // -----------------------------------------------------------------------
-    // Private helpers
-    // -----------------------------------------------------------------------
-    ensureVersionTable() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS schema_version (
-        version TEXT NOT NULL DEFAULT '000'
-      )
-    `);
-        // Ensure at least one row exists
-        const count = this.db.get('SELECT COUNT(*) as cnt FROM schema_version');
-        if (!count || count.cnt === 0) {
-            this.db.exec("INSERT INTO schema_version (version) VALUES ('000')");
-        }
-    }
-    setVersion(version) {
-        this.db.exec(`UPDATE schema_version SET version = '${version}'`);
-    }
-}
-/**
- * Factory: create a MigrationRunner and apply schema catalog for a given database.
- * This is the main entry point for database classes.
- */
-export function ensureDatabaseSchema(db, dbType) {
-    const runner = new MigrationRunner(db);
-    runner.applySchemaCatalog(dbType);
-}

package/dist/core/schema/migrations/001-init-trajectory.d.ts

@@ -1,6 +0,0 @@
-/**
- * Migration: Initialize trajectory.db tables
- * This creates all core event store tables.
- */
-import type { Migration } from '../migration-runner.js';
-export declare const migration: Migration;