principles-disciple 1.5.4

package/dist/core/trust-engine.js

@@ -0,0 +1,284 @@
+/**
+ * Trust Engine V2.1 - Recalibrated for Action Classification
+ * Differentiates between Exploratory (safe) and Constructive (risky) actions.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { EventLogService } from './event-log.js';
+import { resolvePdPath } from './paths.js';
+import { ConfigService } from './config-service.js';
+export const EXPLORATORY_TOOLS = [
+    // 文件读取
+    'read', 'read_file', 'read_many_files', 'image_read',
+    // 搜索和列表
+    'search_file_content', 'grep', 'grep_search', 'list_directory', 'ls', 'glob',
+    // Web
+    'web_fetch', 'web_search',
+    // 用户交互
+    'ask_user', 'ask_user_question',
+    // LSP
+    'lsp_hover', 'lsp_goto_definition', 'lsp_find_references',
+    // 内存和状态
+    'memory_recall', 'save_memory', 'todo_read', 'todo_write',
+    // 状态查询
+    'pd-status', 'trust', 'report',
+];
+export const CONSTRUCTIVE_TOOLS = [
+    'write', 'write_file', 'edit', 'edit_file', 'replace', 'apply_patch',
+    'insert', 'patch', 'delete_file', 'move_file', 'run_shell_command',
+    'pd_spawn_agent', 'sessions_spawn', 'evolve-task', 'init-strategy'
+];
+export class TrustEngine {
+    scorecard;
+    workspaceDir;
+    stateDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        this.stateDir = resolvePdPath(workspaceDir, 'STATE_DIR');
+        this.scorecard = this.loadScorecard();
+        const scorecardPath = resolvePdPath(this.workspaceDir, 'AGENT_SCORECARD');
+        if (!fs.existsSync(scorecardPath)) {
+            this.saveScorecard();
+        }
+    }
+    get config() {
+        return ConfigService.get(this.stateDir);
+    }
+    get trustSettings() {
+        const settings = this.config.get('trust');
+        return settings || {
+            stages: { stage_1_observer: 30, stage_2_editor: 60, stage_3_developer: 80 },
+            cold_start: { initial_trust: 85, grace_failures: 5, cold_start_period_ms: 86400000 },
+            penalties: { tool_failure_base: -2, risky_failure_base: -10, gate_bypass_attempt: -5, failure_streak_multiplier: -2, max_penalty: -20 },
+            rewards: { success_base: 2, subagent_success: 5, tool_success_reward: 0.2, streak_bonus_threshold: 3, streak_bonus: 5, recovery_boost: 5, max_reward: 15 },
+            limits: { stage_2_max_lines: 50, stage_3_max_lines: 300 }
+        };
+    }
+    loadScorecard() {
+        const scorecardPath = resolvePdPath(this.workspaceDir, 'AGENT_SCORECARD');
+        const settings = this.trustSettings;
+        if (fs.existsSync(scorecardPath)) {
+            try {
+                const raw = fs.readFileSync(scorecardPath, 'utf8');
+                const data = JSON.parse(raw);
+                if (data.score !== undefined && data.trust_score === undefined)
+                    data.trust_score = data.score;
+                if (!data.history)
+                    data.history = [];
+                if (data.exploratory_failure_streak === undefined)
+                    data.exploratory_failure_streak = 0;
+                return data;
+            }
+            catch (e) {
+                console.error(`[PD:TrustEngine] FATAL: Failed to parse scorecard at ${scorecardPath}. Resetting.`);
+            }
+        }
+        const now = new Date();
+        const coldStartEnd = new Date(now.getTime() + settings.cold_start.cold_start_period_ms);
+        return {
+            trust_score: settings.cold_start.initial_trust,
+            success_streak: 0,
+            failure_streak: 0,
+            exploratory_failure_streak: 0,
+            grace_failures_remaining: settings.cold_start.grace_failures,
+            last_updated: now.toISOString(),
+            cold_start_end: coldStartEnd.toISOString(),
+            first_activity_at: now.toISOString(),
+            history: []
+        };
+    }
+    saveScorecard() {
+        const scorecardPath = resolvePdPath(this.workspaceDir, 'AGENT_SCORECARD');
+        try {
+            const dir = path.dirname(scorecardPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(scorecardPath, JSON.stringify(this.scorecard, null, 2), 'utf8');
+        }
+        catch (e) {
+            console.error(`[PD:TrustEngine] Failed to save scorecard: ${String(e)}`);
+        }
+    }
+    getScore() { return this.scorecard.trust_score; }
+    getScorecard() { return this.scorecard; }
+    getStage() {
+        const score = this.scorecard.trust_score;
+        const stages = this.trustSettings.stages;
+        if (score < stages.stage_1_observer)
+            return 1;
+        if (score < stages.stage_2_editor)
+            return 2;
+        if (score < stages.stage_3_developer)
+            return 3;
+        return 4;
+    }
+    isColdStart() {
+        if (!this.scorecard.cold_start_end)
+            return false;
+        return new Date() < new Date(this.scorecard.cold_start_end);
+    }
+    recordSuccess(reason, context, isSubagent = false) {
+        const settings = this.trustSettings;
+        const rewards = settings.rewards;
+        const toolName = context?.toolName;
+        // 1. Check if this is an exploratory tool success
+        const isExploratory = toolName && EXPLORATORY_TOOLS.includes(toolName);
+        if (reason === 'tool_success' && isExploratory) {
+            // Exploratory tools don't grant trust points, but they:
+            // 1. Reset the exploratory failure streak
+            // 2. Prove the agent isn't stuck (no delta, no success_streak increment)
+            this.scorecard.exploratory_failure_streak = 0;
+            this.updateScore(0, `Exploratory Success: ${toolName}`, 'info', context);
+            return;
+        }
+        let delta = rewards.success_base;
+        if (isSubagent) {
+            delta = rewards.subagent_success;
+        }
+        else if (reason === 'tool_success') {
+            delta = rewards.tool_success_reward ?? 0.2;
+        }
+        else if (reason === 'plan_ready') {
+            delta = 5; // Strategic reward
+        }
+        this.scorecard.success_streak++;
+        this.scorecard.failure_streak = 0; // Reset failure streak on constructive success
+        this.scorecard.exploratory_failure_streak = 0;
+        if (this.scorecard.success_streak >= rewards.streak_bonus_threshold) {
+            delta += rewards.streak_bonus;
+        }
+        if (this.scorecard.trust_score < settings.stages.stage_1_observer) {
+            delta += rewards.recovery_boost;
+        }
+        this.updateScore(delta, reason, 'success', context);
+    }
+    recordFailure(type, context) {
+        const settings = this.trustSettings;
+        const penalties = settings.penalties;
+        const toolName = context?.toolName;
+        // 1. Classification: Is this an exploratory failure?
+        const isExploratory = toolName && EXPLORATORY_TOOLS.includes(toolName);
+        // 2. Cold start grace (only for non-risky actions)
+        if (type !== 'risky' && this.isColdStart() && (this.scorecard.grace_failures_remaining || 0) > 0) {
+            this.scorecard.grace_failures_remaining = (this.scorecard.grace_failures_remaining || 0) - 1;
+            this.updateScore(0, `Grace Failure consumed (${toolName || type})`, 'failure', context);
+            return;
+        }
+        if (isExploratory) {
+            // Exploratory failures are minor and don't trigger streak multipliers
+            this.scorecard.exploratory_failure_streak++;
+            this.updateScore(-1, `Exploratory Failure: ${toolName}`, 'failure', context);
+            return;
+        }
+        // 3. Constructive Failure (Risky or failed writes)
+        let delta = 0;
+        switch (type) {
+            case 'tool':
+                delta = penalties.tool_failure_base;
+                break;
+            case 'risky':
+                delta = penalties.risky_failure_base;
+                break;
+            case 'bypass':
+                delta = penalties.gate_bypass_attempt;
+                break;
+        }
+        this.scorecard.failure_streak++;
+        this.scorecard.success_streak = 0;
+        // Safety cap: streak multiplier only applies up to 5 consecutive failures
+        // to prevent "death spiral" from cascading errors
+        const effectiveStreak = Math.min(this.scorecard.failure_streak, 5);
+        if (effectiveStreak > 1) {
+            delta += (effectiveStreak - 1) * penalties.failure_streak_multiplier;
+        }
+        if (delta < penalties.max_penalty)
+            delta = penalties.max_penalty;
+        this.updateScore(delta, `Failure: ${toolName || type}`, 'failure', context);
+    }
+    updateScore(delta, reason, type, context) {
+        const oldScore = this.scorecard.trust_score;
+        this.scorecard.trust_score += delta;
+        if (this.scorecard.trust_score < 0)
+            this.scorecard.trust_score = 0;
+        if (this.scorecard.trust_score > 100)
+            this.scorecard.trust_score = 100;
+        this.scorecard.last_updated = new Date().toISOString();
+        if (!this.scorecard.history)
+            this.scorecard.history = [];
+        this.scorecard.history.push({ type, delta, reason, timestamp: new Date().toISOString() });
+        if (context?.sessionId) {
+            const eventLog = EventLogService.get(this.stateDir);
+            eventLog.recordTrustChange(context.sessionId, { previousScore: oldScore, newScore: this.scorecard.trust_score, delta, reason });
+        }
+        const limit = this.trustSettings.history_limit || 50;
+        if (this.scorecard.history.length > limit) {
+            this.scorecard.history.shift();
+        }
+        this.saveScorecard();
+    }
+    resetTrust(newScore) {
+        const settings = this.trustSettings;
+        const now = new Date();
+        const coldStartEnd = new Date(now.getTime() + settings.cold_start.cold_start_period_ms);
+        this.scorecard.trust_score = newScore ?? settings.cold_start.initial_trust;
+        this.scorecard.success_streak = 0;
+        this.scorecard.failure_streak = 0;
+        this.scorecard.exploratory_failure_streak = 0;
+        this.scorecard.grace_failures_remaining = settings.cold_start.grace_failures;
+        this.scorecard.last_updated = now.toISOString();
+        this.scorecard.first_activity_at = now.toISOString();
+        this.scorecard.cold_start_end = coldStartEnd.toISOString();
+        this.scorecard.history.push({ type: 'success', delta: 0, reason: 'Manual trust reset (Spiritual Cleanse)', timestamp: now.toISOString() });
+        this.saveScorecard();
+    }
+    getStatusSummary() {
+        const scorecard = this.scorecard;
+        const successRate = this.calculateSuccessRate(scorecard);
+        return {
+            stage: this.getStage(),
+            successRate,
+            isInColdStart: this.isColdStart(),
+            graceRemaining: scorecard.grace_failures_remaining ?? 0,
+            currentStreak: {
+                type: scorecard.success_streak > scorecard.failure_streak ? 'success' : 'failure',
+                count: Math.max(scorecard.success_streak, scorecard.failure_streak)
+            }
+        };
+    }
+    calculateSuccessRate(scorecard) {
+        if (!scorecard.history || scorecard.history.length === 0)
+            return 100;
+        const recent = scorecard.history.slice(-20);
+        const successes = recent.filter(h => h.type === 'success').length;
+        return Math.round((successes / recent.length) * 100);
+    }
+}
+export function recordSuccess(workspaceDir, reason, context, isSubagent = false) {
+    new TrustEngine(workspaceDir).recordSuccess(reason, context, isSubagent);
+}
+export function recordFailure(type, workspaceDir, ctx) {
+    new TrustEngine(workspaceDir).recordFailure(type, ctx);
+}
+export function getAgentScorecard(workspaceDir) {
+    return new TrustEngine(workspaceDir).getScorecard();
+}
+export function getTrustStats(scorecard) {
+    const dummy = new TrustEngine(process.cwd());
+    const successRate = dummy.calculateSuccessRate(scorecard);
+    const stages = { stage_1_observer: 30, stage_2_editor: 60, stage_3_developer: 80 };
+    let stage = scorecard.trust_score < stages.stage_1_observer ? 1 :
+        scorecard.trust_score < stages.stage_2_editor ? 2 :
+            scorecard.trust_score < stages.stage_3_developer ? 3 : 4;
+    return {
+        stage, successRate,
+        isInColdStart: scorecard.cold_start_end ? new Date() < new Date(scorecard.cold_start_end) : false,
+        graceRemaining: scorecard.grace_failures_remaining ?? 0,
+        currentStreak: {
+            type: (scorecard.success_streak || 0) > (scorecard.failure_streak || 0) ? 'success' : 'failure',
+            count: Math.max(scorecard.success_streak || 0, scorecard.failure_streak || 0)
+        }
+    };
+}
+export function getTrustStatus(workspaceDir) {
+    return new TrustEngine(workspaceDir).getStatusSummary();
+}

package/dist/core/workspace-context.d.ts

@@ -0,0 +1,64 @@
+import { PD_FILES } from './paths.js';
+import { PainConfig } from './config.js';
+import { EventLog } from './event-log.js';
+import { PainDictionary } from './dictionary.js';
+import { TrustEngine } from './trust-engine.js';
+import { HygieneTracker } from './hygiene/tracker.js';
+/**
+ * WorkspaceContext - Centralized management of workspace-specific paths and services.
+ * Implements a cached singleton pattern per workspace directory.
+ */
+export declare class WorkspaceContext {
+    private static instances;
+    private static pathResolver;
+    readonly workspaceDir: string;
+    readonly stateDir: string;
+    private _config?;
+    private _eventLog?;
+    private _dictionary?;
+    private _trust?;
+    private _hygiene?;
+    private constructor();
+    /**
+     * Governance configuration for this workspace.
+     */
+    get config(): PainConfig;
+    /**
+     * Event logging service for this workspace.
+     */
+    get eventLog(): EventLog;
+    /**
+     * Pain dictionary service for this workspace.
+     */
+    get dictionary(): PainDictionary;
+    /**
+     * Trust engine service bound to this workspace.
+     */
+    get trust(): TrustEngine;
+    /**
+     * Hygiene tracking service for this workspace.
+     */
+    get hygiene(): HygieneTracker;
+    /**
+     * Creates or retrieves a WorkspaceContext instance from an OpenClaw hook context.
+     * Uses PathResolver to handle path normalization and fallback logic.
+     * @throws Error if workspaceDir is missing and no fallback available.
+     */
+    static fromHookContext(ctx: any): WorkspaceContext;
+    /**
+     * Resolves a PD file path within the workspace.
+     */
+    resolve(fileKey: keyof typeof PD_FILES): string;
+    /**
+     * Resets internal caches for services and paths.
+     */
+    invalidate(): void;
+    /**
+     * Removes a workspace from the cache.
+     */
+    static dispose(workspaceDir: string): void;
+    /**
+     * Clears the instance cache (primarily for testing).
+     */
+    static clearCache(): void;
+}

package/dist/core/workspace-context.js

@@ -0,0 +1,134 @@
+import { resolvePdPath } from './paths.js';
+import { PathResolver } from './path-resolver.js';
+import { ConfigService } from './config-service.js';
+import { EventLogService } from './event-log.js';
+import { DictionaryService } from './dictionary-service.js';
+import { TrustEngine } from './trust-engine.js';
+import { HygieneTracker } from './hygiene/tracker.js';
+/**
+ * WorkspaceContext - Centralized management of workspace-specific paths and services.
+ * Implements a cached singleton pattern per workspace directory.
+ */
+export class WorkspaceContext {
+    static instances = new Map();
+    static pathResolver = new PathResolver();
+    workspaceDir;
+    stateDir;
+    _config;
+    _eventLog;
+    _dictionary;
+    _trust;
+    _hygiene;
+    constructor(workspaceDir, stateDir) {
+        this.workspaceDir = workspaceDir;
+        this.stateDir = stateDir;
+    }
+    /**
+     * Governance configuration for this workspace.
+     */
+    get config() {
+        if (!this._config) {
+            this._config = ConfigService.get(this.stateDir);
+        }
+        return this._config;
+    }
+    /**
+     * Event logging service for this workspace.
+     */
+    get eventLog() {
+        if (!this._eventLog) {
+            this._eventLog = EventLogService.get(this.stateDir);
+        }
+        return this._eventLog;
+    }
+    /**
+     * Pain dictionary service for this workspace.
+     */
+    get dictionary() {
+        if (!this._dictionary) {
+            this._dictionary = DictionaryService.get(this.stateDir);
+        }
+        return this._dictionary;
+    }
+    /**
+     * Trust engine service bound to this workspace.
+     */
+    get trust() {
+        if (!this._trust) {
+            this._trust = new TrustEngine(this.workspaceDir);
+        }
+        return this._trust;
+    }
+    /**
+     * Hygiene tracking service for this workspace.
+     */
+    get hygiene() {
+        if (!this._hygiene) {
+            this._hygiene = new HygieneTracker(this.stateDir);
+        }
+        return this._hygiene;
+    }
+    /**
+     * Creates or retrieves a WorkspaceContext instance from an OpenClaw hook context.
+     * Uses PathResolver to handle path normalization and fallback logic.
+     * @throws Error if workspaceDir is missing and no fallback available.
+     */
+    static fromHookContext(ctx) {
+        let workspaceDir = ctx.workspaceDir;
+        if (!workspaceDir) {
+            console.warn('[PD:WorkspaceContext] workspaceDir not provided in context, using PathResolver fallback');
+            workspaceDir = this.pathResolver.getWorkspaceDir();
+            console.log(`[PD:WorkspaceContext] Resolved workspaceDir to: ${workspaceDir}`);
+        }
+        else {
+            const normalized = this.pathResolver.normalizeWorkspacePath(workspaceDir);
+            if (normalized !== workspaceDir) {
+                console.log(`[PD:WorkspaceContext] Normalized workspaceDir: ${workspaceDir} -> ${normalized}`);
+                workspaceDir = normalized;
+            }
+        }
+        const existing = this.instances.get(workspaceDir);
+        if (existing)
+            return existing;
+        let stateDir = ctx.stateDir;
+        if (!stateDir) {
+            stateDir = resolvePdPath(workspaceDir, 'STATE_DIR');
+            console.log(`[PD:WorkspaceContext] Computed stateDir: ${stateDir}`);
+        }
+        const instance = new WorkspaceContext(workspaceDir, stateDir);
+        this.instances.set(workspaceDir, instance);
+        console.log(`[PD:WorkspaceContext] Created new context for workspace: ${workspaceDir}`);
+        return instance;
+    }
+    /**
+     * Resolves a PD file path within the workspace.
+     */
+    resolve(fileKey) {
+        return resolvePdPath(this.workspaceDir, fileKey);
+    }
+    /**
+     * Resets internal caches for services and paths.
+     */
+    invalidate() {
+        this._config = undefined;
+        this._eventLog = undefined;
+        this._dictionary = undefined;
+        this._trust = undefined;
+    }
+    /**
+     * Removes a workspace from the cache.
+     */
+    static dispose(workspaceDir) {
+        const instance = this.instances.get(workspaceDir);
+        if (instance) {
+            instance.invalidate();
+            this.instances.delete(workspaceDir);
+        }
+    }
+    /**
+     * Clears the instance cache (primarily for testing).
+     */
+    static clearCache() {
+        this.instances.clear();
+    }
+}

package/dist/hooks/gate.d.ts

@@ -0,0 +1,6 @@
+import type { PluginHookBeforeToolCallEvent, PluginHookToolContext, PluginHookBeforeToolCallResult } from '../openclaw-sdk.js';
+export declare function handleBeforeToolCall(event: PluginHookBeforeToolCallEvent, ctx: PluginHookToolContext & {
+    workspaceDir?: string;
+    pluginConfig?: Record<string, unknown>;
+    logger?: any;
+}): PluginHookBeforeToolCallResult | void;