principles-disciple 1.7.5 → 1.7.8

package/templates/langs/zh/skills/pd-mentor/SKILL.md

@@ -32,7 +32,7 @@ disable-model-invocation: true
 | `/pd-thinking` | 管理思维模型与候选方案 | 元认知管理 |
 | `/pd-evolve` | 执行完整进化循环 | 问题修复 |
 | `/pd-daily` | 配置并发送进化日报 | 日常查看 |
-| `/pd-trust` | 查看信任积分与安全等级 | 权限查询 |
+| `/pd-evolution-status` | 查看EP等级与安全状态 | 状态查询 |
 | `/pd-status` | 查看系统状态（GFI和痛苦词典） | 健康检查 |
 | `/pd-grooming` | 工作区数字大扫除 | 熵减维护 |
 | `/pd-help` | 获取交互式命令引导 | 本技能 |
@@ -72,7 +72,7 @@ disable-model-invocation: true
 
 **推荐流程**:
 1. `/pd-daily` - 发送今日进化日报
-2. `/pd-trust` - 查看当前信任积分
+2. `/pd-evolution-status` - 查看当前信任积分
 3. `/pd-okr` - 检查 OKR 对齐情况
 
 **话术**: "日报在手，进化我有。让我帮你回顾今天的成果。"
@@ -95,7 +95,7 @@ disable-model-invocation: true
 **触发条件**: 用户说"权限不够"、"被拦截了"、"安全等级"
 
 **推荐流程**:
-1. `/pd-trust` - 查看信任积分和安全等级
+1. `/pd-evolution-status` - 查看信任积分和安全等级
 2. 解释当前等级的能力边界
 
 **话术**: "信任是挣来的，不是给的。让我帮你了解当前的安全等级。"
@@ -207,8 +207,8 @@ disable-model-invocation: true
 **Q: 什么是 GFI（摩擦指数）？**
 A: GFI (Global Friction Index) 衡量系统的"痛苦程度"，分值范围 0-100。值越高表示摩擦越大，需要关注。
 
-**Q: 信任积分如何计算？**
-A: 基于成功操作累积积分，失败操作扣分。达到阈值后自动升级安全等级，解锁更多权限。
+**Q: EP (进化积分) 如何计算？**
+A: EP (Evolution Points) 通过成功完成任务和问题修复累积。失败会扣除EP但有保护机制。达到阈值后自动升级EP等级，解锁更多权限（更大的代码修改限额）。
 
 **Q: Pain Signal 是什么？**
 A: Pain Signal 是系统检测到的问题信号，存储在 `.state/.pain_flag` 中。触发后系统会启动进化循环。

package/templates/pain_settings.json

@@ -103,12 +103,6 @@
       "large_change_block": 50
     },
     "large_change_lines": 50,
-    "trust_stage_multipliers": {
-      "1": 0.5,
-      "2": 0.75,
-      "3": 1.0,
-      "4": 1.5
-    },
     "bash_safe_patterns": [
       "^(ls|dir|pwd|which|where|echo|env|cat|type|head|tail|less|more)\\b",
       "^git\\s+(status|log|diff|branch|show|remote)\\b",

package/dist/commands/trust.d.ts

@@ -1,4 +0,0 @@
-import type { PluginHookAgentContext } from '../openclaw-sdk.js';
-export declare function handleTrustCommand(ctx: PluginHookAgentContext & {
-    workspaceDir?: string;
-}): string;

package/dist/commands/trust.js

@@ -1,78 +0,0 @@
-import { WorkspaceContext } from '../core/workspace-context.js';
-function createProgressBar(value, max, length = 12) {
-    const safeValue = Math.max(0, Math.min(max, value));
-    const filledLength = Math.round((safeValue / max) * length);
-    const emptyLength = Math.max(0, length - filledLength);
-    return `[${'#'.repeat(filledLength)}${'-'.repeat(emptyLength)}]`;
-}
-function formatStageTitle(stage, isZh) {
-    const titles = isZh
-        ? ['Observer', 'Editor', 'Developer', 'Architect']
-        : ['Observer', 'Editor', 'Developer', 'Architect'];
-    return titles[Math.max(0, Math.min(3, stage - 1))] ?? 'Unknown';
-}
-export function handleTrustCommand(ctx) {
-    const { workspaceDir } = ctx;
-    if (!workspaceDir)
-        return 'Error: Workspace directory not found.';
-    const wctx = WorkspaceContext.fromHookContext(ctx);
-    const trustEngine = wctx.trust;
-    const trustScore = trustEngine.getScore();
-    const stage = trustEngine.getStage();
-    const isZh = wctx.config.get('language') === 'zh';
-    const scorecard = trustEngine.getScorecard();
-    const hygiene = wctx.hygiene.getStats();
-    const trustBar = createProgressBar(trustScore, 100);
-    const hygieneScore = Math.min(100, hygiene.persistenceCount * 10);
-    const hygieneBar = createProgressBar(hygieneScore, 100);
-    const rewardPolicy = scorecard.reward_policy ?? 'frozen_all_positive';
-    const lastUpdated = scorecard.last_updated ?? '--';
-    if (isZh) {
-        return [
-            'Principles Disciple - Legacy Trust',
-            '=================================',
-            '',
-            `- Legacy Trust: ${trustBar} ${trustScore}/100`,
-            `- Stage: ${stage} (${formatStageTitle(stage, true)})`,
-            `- Status: legacy/frozen`,
-            `- Reward Policy: ${rewardPolicy}`,
-            `- Last Updated: ${lastUpdated}`,
-            '',
-            '说明',
-            '- 这是兼容旧控制面的 legacy trust 视图，不再代表新的长期能力模型。',
-            '- `tool_success` 与 `subagent_success` 不再自动提升 trust。',
-            '- 当前观察窗口内，trust 主要保留为兼容读数与 gate 兼容输入。',
-            '',
-            '认知卫生',
-            `- Persistence: ${hygieneBar} ${hygiene.persistenceCount} actions today`,
-            `- Total Chars Persisted: ${hygiene.totalCharsPersisted}`,
-            `- Workspace Grooming: ${hygiene.groomingExecutedCount > 0 ? 'done' : 'pending'}`,
-            '',
-            '下一步',
-            '- 在进入 Phase 3 capability shadow 之前，先看 production observation 数据是否稳定。',
-        ].join('\n');
-    }
-    return [
-        'Principles Disciple - Legacy Trust',
-        '=================================',
-        '',
-        `- Legacy Trust: ${trustBar} ${trustScore}/100`,
-        `- Stage: ${stage} (${formatStageTitle(stage, false)})`,
-        '- Status: legacy/frozen',
-        `- Reward Policy: ${rewardPolicy}`,
-        `- Last Updated: ${lastUpdated}`,
-        '',
-        'Notes',
-        '- This is a compatibility view of legacy trust, not the future long-term capability model.',
-        '- `tool_success` and `subagent_success` no longer raise trust automatically.',
-        '- During the current observation window, trust remains mainly for compatibility reads and gate compatibility.',
-        '',
-        'Cognitive Hygiene',
-        `- Persistence: ${hygieneBar} ${hygiene.persistenceCount} actions today`,
-        `- Total Chars Persisted: ${hygiene.totalCharsPersisted}`,
-        `- Workspace Grooming: ${hygiene.groomingExecutedCount > 0 ? 'done' : 'pending'}`,
-        '',
-        'Next',
-        '- Do not move into Phase 3 capability shadow until production observation data is stable.',
-    ].join('\n');
-}

package/dist/core/trust-engine.d.ts

@@ -1,96 +0,0 @@
-/**
- * Trust Engine V2.1 - Recalibrated for Action Classification
- * Differentiates between Exploratory (safe) and Constructive (risky) actions.
- */
-export interface TrustScorecard {
-    trust_score: number;
-    success_streak: number;
-    failure_streak: number;
-    exploratory_failure_streak: number;
-    grace_failures_remaining?: number;
-    last_updated: string;
-    cold_start_end?: string;
-    first_activity_at?: string;
-    history: Array<{
-        type: 'success' | 'failure' | 'penalty' | 'info';
-        delta: number;
-        reason: string;
-        timestamp: string;
-    }>;
-    frozen?: boolean;
-    reward_policy?: 'frozen_all_positive' | 'frozen_atomic_positive_keep_plan_ready';
-}
-export type TrustStage = 1 | 2 | 3 | 4;
-export declare const EXPLORATORY_TOOLS: Set<string>;
-export declare class TrustEngine {
-    private scorecard;
-    private workspaceDir;
-    private stateDir;
-    constructor(workspaceDir: string);
-    private get config();
-    private get trustSettings();
-    private loadScorecard;
-    private applyLegacyFreezeMetadata;
-    private saveScorecard;
-    getScore(): number;
-    getScorecard(): TrustScorecard;
-    getStage(): TrustStage;
-    isColdStart(): boolean;
-    recordSuccess(reason: string, context?: {
-        sessionId?: string;
-        api?: any;
-        toolName?: string;
-    }, isSubagent?: boolean): void;
-    recordFailure(type: 'tool' | 'risky' | 'bypass', context: {
-        sessionId?: string;
-        api?: any;
-        toolName?: string;
-        error?: string;
-    }): void;
-    private touchScorecard;
-    private updateScore;
-    resetTrust(newScore?: number): void;
-    getStatusSummary(): {
-        stage: TrustStage;
-        successRate: number;
-        isInColdStart: boolean;
-        graceRemaining: number;
-        currentStreak: {
-            type: string;
-            count: number;
-        };
-    };
-    private calculateSuccessRate;
-}
-export declare function recordSuccess(workspaceDir: string, reason: string, context?: {
-    sessionId?: string;
-    api?: any;
-    toolName?: string;
-}, isSubagent?: boolean): void;
-export declare function recordFailure(type: 'tool' | 'risky' | 'bypass', workspaceDir: string, ctx: {
-    sessionId?: string;
-    api?: any;
-    toolName?: string;
-    error?: string;
-}): void;
-export declare function getAgentScorecard(workspaceDir: string): TrustScorecard;
-export declare function getTrustStats(scorecard: TrustScorecard): {
-    stage: TrustStage;
-    successRate: any;
-    isInColdStart: boolean;
-    graceRemaining: number;
-    currentStreak: {
-        type: string;
-        count: number;
-    };
-};
-export declare function getTrustStatus(workspaceDir: string): {
-    stage: TrustStage;
-    successRate: number;
-    isInColdStart: boolean;
-    graceRemaining: number;
-    currentStreak: {
-        type: string;
-        count: number;
-    };
-};

package/dist/core/trust-engine.js

@@ -1,286 +0,0 @@
-/**
- * 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';
-import { TrajectoryRegistry } from './trajectory.js';
-import { EXPLORATORY_TOOLS as SHARED_EXPLORATORY_TOOLS } from '../constants/tools.js';
-export const EXPLORATORY_TOOLS = new Set(SHARED_EXPLORATORY_TOOLS);
-const LEGACY_TRUST_REWARD_POLICY = 'frozen_all_positive';
-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 },
-            // BUGFIX #84: Reduced penalties to prevent Trust collapse
-            penalties: { tool_failure_base: -1, risky_failure_base: -5, gate_bypass_attempt: -3, failure_streak_multiplier: -1, max_penalty: -10 },
-            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;
-                this.applyLegacyFreezeMetadata(data);
-                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);
-        const scorecard = {
-            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: []
-        };
-        this.applyLegacyFreezeMetadata(scorecard);
-        return scorecard;
-    }
-    applyLegacyFreezeMetadata(scorecard) {
-        scorecard.frozen = true;
-        scorecard.reward_policy = LEGACY_TRUST_REWARD_POLICY;
-    }
-    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 toolName = context?.toolName;
-        // 1. Check if this is an exploratory tool success
-        const isExploratory = toolName ? EXPLORATORY_TOOLS.has(toolName) : false;
-        if (reason === 'tool_success' && isExploratory) {
-            this.scorecard.exploratory_failure_streak = 0;
-            this.touchScorecard();
-            return;
-        }
-        // Phase 1 freeze: do not let atomic successes inflate legacy trust.
-        this.scorecard.success_streak = 0;
-        this.scorecard.failure_streak = 0; // Reset failure streak on constructive success
-        this.scorecard.exploratory_failure_streak = 0;
-        this.touchScorecard();
-    }
-    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.has(toolName) : false;
-        // 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;
-        }
-        // BUGFIX #84: sessions_send timeout should not be penalized
-        // Communication timeouts are not agent failures - the message may have been delivered
-        const errorStr = String(context?.error || '');
-        if (toolName === 'sessions_send' && (errorStr.includes('timeout') || errorStr === 'timeout')) {
-            this.updateScore(0, `Communication timeout (sessions_send): ignored`, 'info', 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);
-    }
-    touchScorecard() {
-        this.applyLegacyFreezeMetadata(this.scorecard);
-        this.scorecard.last_updated = new Date().toISOString();
-        this.saveScorecard();
-    }
-    updateScore(delta, reason, type, context) {
-        const oldScore = this.scorecard.trust_score;
-        this.applyLegacyFreezeMetadata(this.scorecard);
-        this.scorecard.trust_score += delta;
-        // Floor score: never drop below 30 (prevents Trust collapse from cascades)
-        if (this.scorecard.trust_score < 30)
-            this.scorecard.trust_score = 30;
-        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 });
-        }
-        if (context?.sessionId) {
-            try {
-                TrajectoryRegistry.use(this.workspaceDir, (trajectory) => {
-                    trajectory.recordTrustChange({
-                        sessionId: context.sessionId,
-                        previousScore: oldScore,
-                        newScore: this.scorecard.trust_score,
-                        delta,
-                        reason,
-                    });
-                });
-            }
-            catch {
-                // Do not block trust updates if trajectory storage is unavailable.
-            }
-        }
-        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.applyLegacyFreezeMetadata(this.scorecard);
-        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();
-}