principles-disciple 1.6.0 → 1.7.1

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

@@ -17,6 +17,8 @@ export interface TrustScorecard {
         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: string[];
@@ -29,6 +31,7 @@ export declare class TrustEngine {
     private get config();
     private get trustSettings();
     private loadScorecard;
+    private applyLegacyFreezeMetadata;
     private saveScorecard;
     getScore(): number;
     getScorecard(): TrustScorecard;
@@ -43,7 +46,9 @@ export declare class TrustEngine {
         sessionId?: string;
         api?: any;
         toolName?: string;
+        error?: string;
     }): void;
+    private touchScorecard;
     private updateScore;
     resetTrust(newScore?: number): void;
     getStatusSummary(): {
@@ -67,6 +72,7 @@ export declare function recordFailure(type: 'tool' | 'risky' | 'bypass', workspa
     sessionId?: string;
     api?: any;
     toolName?: string;
+    error?: string;
 }): void;
 export declare function getAgentScorecard(workspaceDir: string): TrustScorecard;
 export declare function getTrustStats(scorecard: TrustScorecard): {

package/dist/core/trust-engine.js

@@ -7,6 +7,7 @@ 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';
 export const EXPLORATORY_TOOLS = [
     // 文件读取
     'read', 'read_file', 'read_many_files', 'image_read',
@@ -26,8 +27,9 @@ export const EXPLORATORY_TOOLS = [
 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'
+    'pd_run_worker', 'sessions_spawn', 'evolve-task', 'init-strategy'
 ];
+const LEGACY_TRUST_REWARD_POLICY = 'frozen_all_positive';
 export class TrustEngine {
     scorecard;
     workspaceDir;
@@ -49,7 +51,8 @@ export class TrustEngine {
         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 },
+            // 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 }
         };
@@ -67,6 +70,7 @@ export class TrustEngine {
                     data.history = [];
                 if (data.exploratory_failure_streak === undefined)
                     data.exploratory_failure_streak = 0;
+                this.applyLegacyFreezeMetadata(data);
                 return data;
             }
             catch (e) {
@@ -75,7 +79,7 @@ export class TrustEngine {
         }
         const now = new Date();
         const coldStartEnd = new Date(now.getTime() + settings.cold_start.cold_start_period_ms);
-        return {
+        const scorecard = {
             trust_score: settings.cold_start.initial_trust,
             success_streak: 0,
             failure_streak: 0,
@@ -86,6 +90,12 @@ export class TrustEngine {
             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');
@@ -118,39 +128,19 @@ export class TrustEngine {
         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);
+            this.touchScorecard();
             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++;
+        // 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;
-        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);
+        this.touchScorecard();
     }
     recordFailure(type, context) {
         const settings = this.trustSettings;
@@ -170,6 +160,13 @@ export class TrustEngine {
             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) {
@@ -195,11 +192,18 @@ export class TrustEngine {
             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;
-        if (this.scorecard.trust_score < 0)
-            this.scorecard.trust_score = 0;
+        // 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();
@@ -210,6 +214,22 @@ export class TrustEngine {
             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();
@@ -229,6 +249,7 @@ export class TrustEngine {
         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() {

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

@@ -4,6 +4,8 @@ import { EventLog } from './event-log.js';
 import { PainDictionary } from './dictionary.js';
 import { TrustEngine } from './trust-engine.js';
 import { HygieneTracker } from './hygiene/tracker.js';
+import { EvolutionReducerImpl } from './evolution-reducer.js';
+import { TrajectoryDatabase } from './trajectory.js';
 /**
  * WorkspaceContext - Centralized management of workspace-specific paths and services.
  * Implements a cached singleton pattern per workspace directory.
@@ -18,6 +20,8 @@ export declare class WorkspaceContext {
     private _dictionary?;
     private _trust?;
     private _hygiene?;
+    private _evolutionReducer?;
+    private _trajectory?;
     private constructor();
     /**
      * Governance configuration for this workspace.
@@ -39,6 +43,15 @@ export declare class WorkspaceContext {
      * Hygiene tracking service for this workspace.
      */
     get hygiene(): HygieneTracker;
+    /**
+     * Evolution reducer singleton for this workspace.
+     */
+    get evolutionReducer(): EvolutionReducerImpl;
+    /**
+     * Trajectory database for analytics and sample curation.
+     */
+    get trajectory(): TrajectoryDatabase;
+    private getTrajectoryOptions;
     /**
      * Creates or retrieves a WorkspaceContext instance from an OpenClaw hook context.
      * Uses PathResolver to handle path normalization and fallback logic.

package/dist/core/workspace-context.js

@@ -5,6 +5,8 @@ import { EventLogService } from './event-log.js';
 import { DictionaryService } from './dictionary-service.js';
 import { TrustEngine } from './trust-engine.js';
 import { HygieneTracker } from './hygiene/tracker.js';
+import { EvolutionReducerImpl } from './evolution-reducer.js';
+import { TrajectoryRegistry } from './trajectory.js';
 /**
  * WorkspaceContext - Centralized management of workspace-specific paths and services.
  * Implements a cached singleton pattern per workspace directory.
@@ -19,6 +21,8 @@ export class WorkspaceContext {
     _dictionary;
     _trust;
     _hygiene;
+    _evolutionReducer;
+    _trajectory;
     constructor(workspaceDir, stateDir) {
         this.workspaceDir = workspaceDir;
         this.stateDir = stateDir;
@@ -68,22 +72,53 @@ export class WorkspaceContext {
         }
         return this._hygiene;
     }
+    /**
+     * Evolution reducer singleton for this workspace.
+     */
+    get evolutionReducer() {
+        if (!this._evolutionReducer) {
+            this._evolutionReducer = new EvolutionReducerImpl({ workspaceDir: this.workspaceDir });
+        }
+        return this._evolutionReducer;
+    }
+    /**
+     * Trajectory database for analytics and sample curation.
+     */
+    get trajectory() {
+        if (!this._trajectory) {
+            this._trajectory = TrajectoryRegistry.get(this.workspaceDir, this.getTrajectoryOptions());
+        }
+        return this._trajectory;
+    }
+    getTrajectoryOptions() {
+        const inlineThreshold = Number(this.config.get('trajectory.blob_inline_threshold_bytes'));
+        const busyTimeoutMs = Number(this.config.get('trajectory.busy_timeout_ms'));
+        const orphanBlobGraceDays = Number(this.config.get('trajectory.orphan_blob_grace_days'));
+        return {
+            blobInlineThresholdBytes: Number.isFinite(inlineThreshold) && inlineThreshold > 0 ? inlineThreshold : undefined,
+            busyTimeoutMs: Number.isFinite(busyTimeoutMs) && busyTimeoutMs >= 0 ? busyTimeoutMs : undefined,
+            orphanBlobGraceDays: Number.isFinite(orphanBlobGraceDays) && orphanBlobGraceDays >= 0 ? orphanBlobGraceDays : undefined,
+        };
+    }
     /**
      * 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) {
+        const logger = ctx.logger;
+        const log = (msg) => logger?.info?.(msg) ?? console.log(msg);
+        const logWarn = (msg) => logger?.warn?.(msg) ?? console.warn(msg);
         let workspaceDir = ctx.workspaceDir;
         if (!workspaceDir) {
-            console.warn('[PD:WorkspaceContext] workspaceDir not provided in context, using PathResolver fallback');
+            logWarn('[PD:WorkspaceContext] workspaceDir not provided in context, using PathResolver fallback');
             workspaceDir = this.pathResolver.getWorkspaceDir();
-            console.log(`[PD:WorkspaceContext] Resolved workspaceDir to: ${workspaceDir}`);
+            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}`);
+                log(`[PD:WorkspaceContext] Normalized workspaceDir: ${workspaceDir} -> ${normalized}`);
                 workspaceDir = normalized;
             }
         }
@@ -93,11 +128,11 @@ export class WorkspaceContext {
         let stateDir = ctx.stateDir;
         if (!stateDir) {
             stateDir = resolvePdPath(workspaceDir, 'STATE_DIR');
-            console.log(`[PD:WorkspaceContext] Computed stateDir: ${stateDir}`);
+            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}`);
+        log(`[PD:WorkspaceContext] Created new context for workspace: ${workspaceDir}`);
         return instance;
     }
     /**
@@ -114,21 +149,29 @@ export class WorkspaceContext {
         this._eventLog = undefined;
         this._dictionary = undefined;
         this._trust = undefined;
+        this._evolutionReducer = undefined;
+        this._trajectory = undefined;
     }
     /**
      * Removes a workspace from the cache.
      */
     static dispose(workspaceDir) {
-        const instance = this.instances.get(workspaceDir);
+        const normalized = this.pathResolver.normalizeWorkspacePath(workspaceDir);
+        const instance = this.instances.get(normalized);
         if (instance) {
             instance.invalidate();
-            this.instances.delete(workspaceDir);
+            this.instances.delete(normalized);
         }
+        TrajectoryRegistry.dispose(normalized);
     }
     /**
      * Clears the instance cache (primarily for testing).
      */
     static clearCache() {
+        for (const instance of this.instances.values()) {
+            instance.invalidate();
+        }
         this.instances.clear();
+        TrajectoryRegistry.clear();
     }
 }