principles-disciple 1.8.1 → 1.8.2

package/dist/core/hygiene/tracker.d.ts

@@ -1,22 +0,0 @@
-import { HygieneStats, PersistenceAction } from '../../types/hygiene-types.js';
-import { PluginLogger } from '../../openclaw-sdk.js';
-/**
- * HygieneTracker - Tracks agent behavior regarding workspace organization and persistence.
- */
-export declare class HygieneTracker {
-    private readonly statsFile;
-    private currentStats;
-    private readonly logger?;
-    constructor(stateDir: string, logger?: PluginLogger);
-    private loadStats;
-    private saveStats;
-    /**
-     * Records a persistence action (writing to memory or plan).
-     */
-    recordPersistence(action: PersistenceAction): void;
-    /**
-     * Records a grooming action (cleaning up the workspace).
-     */
-    recordGrooming(): void;
-    getStats(): HygieneStats;
-}

package/dist/core/hygiene/tracker.js

@@ -1,106 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { createEmptyHygieneStats } from '../../types/hygiene-types.js';
-/**
- * HygieneTracker - Tracks agent behavior regarding workspace organization and persistence.
- */
-export class HygieneTracker {
-    statsFile;
-    currentStats;
-    logger;
-    constructor(stateDir, logger) {
-        this.statsFile = path.join(stateDir, 'hygiene-stats.json');
-        this.logger = logger;
-        // Ensure state directory exists
-        if (!fs.existsSync(stateDir)) {
-            try {
-                fs.mkdirSync(stateDir, { recursive: true });
-            }
-            catch (e) {
-                this.logger?.error(`[PD] Failed to create state directory ${stateDir}: ${String(e)}`);
-            }
-        }
-        this.currentStats = this.loadStats();
-    }
-    loadStats() {
-        const today = new Date().toISOString().split('T')[0];
-        if (fs.existsSync(this.statsFile)) {
-            try {
-                const content = fs.readFileSync(this.statsFile, 'utf-8');
-                if (content.trim()) {
-                    const allStats = JSON.parse(content);
-                    if (allStats[today]) {
-                        return allStats[today];
-                    }
-                }
-            }
-            catch (e) {
-                this.logger?.error(`[PD] Failed to load/parse hygiene-stats.json: ${String(e)}`);
-                // If file is corrupted, we might want to back it up and start fresh
-                try {
-                    const backupPath = `${this.statsFile}.bak`;
-                    fs.renameSync(this.statsFile, backupPath);
-                    this.logger?.warn(`[PD] Corrupted hygiene stats backed up to ${backupPath}`);
-                }
-                catch (_renameErr) { }
-            }
-        }
-        return createEmptyHygieneStats(today);
-    }
-    saveStats() {
-        let allStats = {};
-        // Check if we need to rotate date (reset currentStats if date changed)
-        const today = new Date().toISOString().split('T')[0];
-        if (this.currentStats.date !== today) {
-            this.currentStats = createEmptyHygieneStats(today);
-        }
-        if (fs.existsSync(this.statsFile)) {
-            try {
-                const content = fs.readFileSync(this.statsFile, 'utf-8');
-                if (content.trim()) {
-                    allStats = JSON.parse(content);
-                }
-            }
-            catch (e) {
-                this.logger?.error(`[PD] Failed to parse hygiene-stats.json for saving: ${String(e)}`);
-            }
-        }
-        allStats[this.currentStats.date] = this.currentStats;
-        try {
-            // Use a temporary file for atomic write if possible, or simple write
-            fs.writeFileSync(this.statsFile, JSON.stringify(allStats, null, 2), 'utf-8');
-        }
-        catch (e) {
-            this.logger?.error(`[PD] Failed to write hygiene-stats.json: ${String(e)}`);
-        }
-    }
-    /**
-     * Records a persistence action (writing to memory or plan).
-     */
-    recordPersistence(action) {
-        this.currentStats.persistenceCount++;
-        this.currentStats.lastPersistenceTime = action.ts;
-        this.currentStats.totalCharsPersisted += action.contentLength;
-        const fileName = path.basename(action.path);
-        this.currentStats.persistenceByFile[fileName] = (this.currentStats.persistenceByFile[fileName] || 0) + 1;
-        this.saveStats();
-        this.logger?.info(`[PD] Hygiene: Persisted state to ${fileName} (${action.contentLength} chars)`);
-    }
-    /**
-     * Records a grooming action (cleaning up the workspace).
-     */
-    recordGrooming() {
-        this.currentStats.groomingExecutedCount++;
-        this.currentStats.lastGroomingTime = new Date().toISOString();
-        this.saveStats();
-        this.logger?.info(`[PD] Hygiene: Workspace grooming executed.`);
-    }
-    getStats() {
-        // Check for date change on every get
-        const today = new Date().toISOString().split('T')[0];
-        if (this.currentStats.date !== today) {
-            this.currentStats = createEmptyHygieneStats(today);
-        }
-        return this.currentStats;
-    }
-}

package/dist/core/init.d.ts

@@ -1,12 +0,0 @@
-import type { OpenClawPluginApi, PluginLogger } from '../openclaw-sdk.js';
-/**
- * Ensures that the workspace has the necessary template files for Principles Disciple.
- * This function flattens 'core' templates to the root so OpenClaw can find them.
- */
-export declare function ensureWorkspaceTemplates(api: OpenClawPluginApi, workspaceDir: string, language?: string): void;
-/**
- * Ensures that the state directory has the necessary files (like pain_dictionary.json).
- */
-export declare function ensureStateTemplates(ctx: {
-    logger: PluginLogger;
-}, stateDir: string, language?: string): void;

package/dist/core/local-worker-routing.d.ts

@@ -1,175 +0,0 @@
-/**
- * Local Worker Routing Policy — Task Classification and Routing Decisions
- * ======================================================================
- *
- * PURPOSE: Provide an explainable, testable policy that decides whether a given
- * task can be delegated to a local-worker profile (local-reader or local-editor)
- * or must stay on the main agent.
- *
- * ARCHITECTURE:
- *   - This module is POLICY ONLY — it makes routing decisions but does NOT execute them
- *   - The main agent (or a delegation hook in a future phase) is responsible for
- *     actually routing the task based on the RoutingDecision returned here
- *   - All decisions are deterministic and based on structured input fields
- *   - No model inference, no learning, no dynamic adaptation
- *
- * TASK CLASSIFICATION TAXONOMY:
- *   reader_eligible      — clearly suitable for local-reader
- *   editor_eligible     — clearly suitable for local-editor
- *   high_entropy_disallowed — high-complexity tasks that must stay on main agent
- *   risk_disallowed     — tasks with destructive or high-risk signals
- *   ambiguous_scope     — tasks that are unclear and need main-agent judgment
- *   deployment_unavailable — no enabled deployment exists for the target profile
- *
- * FAIL-CLOSED PRINCIPLE:
- *   - When in doubt → stay_main
- *   - Unclear intent → stay_main
- *   - High complexity → stay_main
- *   - Any risk signal → stay_main
- *   - No enabled deployment → stay_main
- *
- * DESIGN CONSTRAINTS:
- *   - No actual task execution
- *   - No automatic learning or route optimization
- *   - No Trinity or adaptive threshold logic
- *   - Routing decisions are fully explainable (return `reason` + `blockers[]`)
- */
-import type { WorkerProfile } from './model-deployment-registry.js';
-/**
- * The input contract for a routing decision.
- * All fields are optional — the classifier handles missing data gracefully
- * by treating it as ambiguous (stay_main).
- */
-export interface RoutingInput {
-    /**
-     * A short label or name for the task intent.
-     * E.g., "read_file", "edit_config", "debug_memory_leak", "design_system"
-     */
-    taskIntent?: string;
-    /**
-     * Natural-language description of the task.
-     * The classifier examines this for keywords indicating complexity/risk.
-     */
-    taskDescription?: string;
-    /**
-     * Specific tools requested or implied by the task.
-     * These are examined for risk signals (e.g., bash, rm, git push).
-     */
-    requestedTools?: string[];
-    /**
-     * Specific files involved or targeted.
-     * Examined for risk-path indicators (e.g., .git/, node_modules, production configs).
-     */
-    requestedFiles?: string[];
-    /**
-     * Shape of expected output.
-     * E.g., "json", "markdown", "one_line", "full_report"
-     */
-    expectedOutputShape?: string;
-    /**
-     * Explicit risk signals detected in the task.
-     * E.g., ["destructive", "production", "irreversible", "large_scale"]
-     * Any non-empty riskSignals → automatic stay_main.
-     */
-    riskSignals?: string[];
-    /**
-     * Complexity hints for the task.
-     * E.g., ["multi_step", "cross_file", "ambiguous", "requires_planning"]
-     */
-    complexityHints?: string[];
-    /**
-     * Target worker profile for routing consideration.
-     * If omitted, both profiles are evaluated and the best match is returned.
-     */
-    targetProfile?: WorkerProfile;
-}
-/**
- * The result of a routing classification decision.
- * Always includes a `reason` and a `blockers` list for full explainability.
- */
-export interface RoutingDecision {
-    /**
-     * The routing verdict.
-     * - `route_local` — the task may be delegated to `targetProfile`
-     * - `stay_main` — the task must remain on the main agent
-     */
-    decision: 'route_local' | 'stay_main';
-    /**
-     * Which profile the task should be routed to (if decision === 'route_local').
-     * Null if decision === 'stay_main'.
-     */
-    targetProfile: WorkerProfile | null;
-    /**
-     * The task classification category that led to this decision.
-     */
-    classification: 'reader_eligible' | 'editor_eligible' | 'high_entropy_disallowed' | 'risk_disallowed' | 'ambiguous_scope' | 'profile_mismatch' | 'deployment_unavailable';
-    /**
-     * Human-readable explanation of the routing decision.
-     * Must be specific enough that a developer can understand why a task was accepted/rejected.
-     */
-    reason: string;
-    /**
-     * List of specific reasons that blocked routing (if decision === 'stay_main').
-     * Empty if decision === 'route_local'.
-     */
-    blockers: string[];
-    /**
-     * Whether a deployment check was performed and whether it passed.
-     * Useful for diagnostics when deployment_unavailable is the classification.
-     */
-    deploymentCheck: {
-        performed: boolean;
-        profileAvailable: boolean;
-        routingEnabled: boolean;
-        /** Whether the active checkpoint is currently marked as deployable in the training registry. */
-        checkpointDeployable: boolean;
-    };
-    /**
-     * The active checkpoint ID that would be used for routing (if decision === 'route_local').
-     * This is the checkpoint from the deployment registry.
-     * Null if decision === 'stay_main' or if no checkpoint is active.
-     *
-     * USE FOR SHADOW OBSERVATIONS:
-     * When routing in shadow mode (checkpoint is in shadow_ready state),
-     * the caller should record a shadow observation using this checkpoint ID.
-     */
-    activeCheckpointId: string | null;
-    /**
-     * The promotion state of the active checkpoint.
-     * Indicates whether this is a regular deployment or a shadow rollout.
-     * Useful for determining whether to record shadow observations.
-     */
-    activeCheckpointState?: 'promotable' | 'shadow_ready' | 'candidate_only';
-    /**
-     * Deprecated: runtime shadow observations are now recorded from real
-     * subagent lifecycle hooks instead of from classifyTask().
-     */
-    shadowObservationId?: string;
-}
-/**
- * Classify a task and produce a routing decision.
- *
- * This is the main entry point for routing policy evaluation.
- * It:
- *   1. Classifies the task kind based on keywords and heuristics
- *   2. Checks deployment availability for the target profile
- *   3. Returns a fully explainable RoutingDecision
- *
- * @param input - The routing input describing the task
- * @param stateDir - Workspace state directory (for deployment registry lookup)
- * @returns RoutingDecision with classification, reason, blockers, and routing verdict
- */
-export declare function classifyTask(input: RoutingInput, stateDir: string): RoutingDecision;
-/**
- * Convenience: check if a specific profile can handle a task.
- * Equivalent to calling classifyTask with targetProfile set.
- */
-export declare function canRouteToProfile(input: RoutingInput, stateDir: string, profile: WorkerProfile): boolean;
-/**
- * Check if any local worker routing is currently enabled for any profile.
- */
-export declare function isAnyLocalRoutingEnabled(stateDir: string): boolean;
-/**
- * List all profiles that currently have routing enabled.
- */
-export declare function listEnabledProfiles(stateDir: string): WorkerProfile[];