principles-disciple 1.158.0 → 1.160.0

package/dist/hooks/gate.js

@@ -17,7 +17,7 @@ import { AGENT_TOOLS, BASH_TOOLS_SET, WRITE_TOOLS } from '../constants/tools.js'
 import { getSession, hasRecentThinking } from '../core/session-tracker.js';
 import { getEvolutionEngine } from '../core/evolution-engine.js';
 import { EventLogService } from '../core/event-log.js';
-import { estimateLineChanges } from '../core/risk-calculator.js';
+import { estimateLineChanges } from '@principles/core/runtime-v2';
 export function handleBeforeToolCall(event, ctx) {
     const logger = ctx.logger || console;
     // 1. Identify tool type

package/dist/index.js

@@ -38,7 +38,7 @@ import { SystemLogger } from './core/system-logger.js';
 import { PathResolver } from './core/path-resolver.js';
 import { resolveCommandWorkspaceDir, resolveToolHookWorkspaceDirSafe, resolveHookWorkspaceDir } from './utils/workspace-resolver.js';
 import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
-import { checkSurfaceGuard, guardHook, guardService } from './core/surface-guard.js';
+import { checkSurfaceGuard, guardHook, guardService } from '@principles/core/runtime-v2';
 // Track started workspaces — one-time init + evolution worker per workspace
 const startedWorkspaces = new Set();
 // ── Conversation Access Health Check (PRI-343) ────────────────────────────

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

package/package.json

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

package/dist/core/risk-calculator.d.ts

@@ -1,22 +0,0 @@
-export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-export interface FileModification {
-    toolName: string;
-    params: Record<string, unknown>;
-}
-export declare function estimateLineChanges(modification: FileModification): number;
-export declare function assessRiskLevel(filePath: string, modification: FileModification, riskPaths: string[]): RiskLevel;
-/**
- * Get the total line count of a target file.
- * @param absoluteFilePath - Absolute path to the file
- * @returns File line count, or null if file doesn't exist or can't be read
- */
-export declare function getTargetFileLineCount(absoluteFilePath: string): number | null;
-/**
- * Calculate the effective line limit based on percentage of target file.
- * @param targetLineCount - Total lines in target file
- * @param percentage - Allowed percentage (0-100)
- * @param minLines - Absolute minimum threshold
- * @param maxLines - Optional upper bound to prevent misconfiguration
- * @returns Maximum allowed lines (at least minLines, at most maxLines if provided)
- */
-export declare function calculatePercentageThreshold(targetLineCount: number, percentage: number, minLines: number, maxLines?: number): number;

package/dist/core/risk-calculator.js

@@ -1,88 +0,0 @@
-/* global NodeJS */
-import * as fs from 'fs';
-import { isRisky } from '../utils/io.js';
-export function estimateLineChanges(modification) {
-    const { toolName, params } = modification;
-    if (toolName === 'write_file' || toolName === 'write') {
-        const content = params.content || '';
-        return content.split('\n').length;
-    }
-    if (toolName === 'replace' || toolName === 'edit') {
-        const newContent = params.new_string || params.newText || '';
-        return newContent.split('\n').length;
-    }
-    if (toolName === 'apply_patch' || toolName === 'patch') {
-        const patch = params.patch || '';
-        // Rough estimate for patch files
-        return patch.split('\n').filter((l) => l.startsWith('+') || l.startsWith('-')).length;
-    }
-    if (toolName === 'delete_file') {
-        // Deleting a file is considered a significant change, but we don't know the size. 
-        // We'll treat it as a medium-to-large size change.
-        return 50;
-    }
-    return 0;
-}
-export function assessRiskLevel(filePath, modification, riskPaths) {
-    const isRiskPath = isRisky(filePath, riskPaths);
-    const estimatedLines = estimateLineChanges(modification);
-    if (isRiskPath) {
-        if (estimatedLines > 100)
-            return 'CRITICAL';
-        return 'HIGH';
-    }
-    else {
-        if (estimatedLines > 100)
-            return 'HIGH';
-        if (estimatedLines > 10)
-            return 'MEDIUM';
-        return 'LOW';
-    }
-}
-/**
- * Get the total line count of a target file.
- * @param absoluteFilePath - Absolute path to the file
- * @returns File line count, or null if file doesn't exist or can't be read
- */
-export function getTargetFileLineCount(absoluteFilePath) {
-    try {
-        if (!fs.existsSync(absoluteFilePath)) {
-            return null; // File genuinely doesn't exist
-        }
-        const stats = fs.statSync(absoluteFilePath);
-        if (!stats.isFile()) {
-            return null; // Not a regular file (directory, device, etc.)
-        }
-        const content = fs.readFileSync(absoluteFilePath, 'utf-8');
-        return content.split('\n').length;
-    }
-    catch (e) {
-        // Log error before falling back to null - this is intentional for security gates
-        const error = e instanceof Error ? e : new Error(String(e));
-        const errorCode = e.code;
-        console.error(`[PD:RISK_CALC] Failed to read file for line count: ${absoluteFilePath}`, {
-            code: errorCode,
-            message: error.message,
-        });
-        return null;
-    }
-}
-/**
- * Calculate the effective line limit based on percentage of target file.
- * @param targetLineCount - Total lines in target file
- * @param percentage - Allowed percentage (0-100)
- * @param minLines - Absolute minimum threshold
- * @param maxLines - Optional upper bound to prevent misconfiguration
- * @returns Maximum allowed lines (at least minLines, at most maxLines if provided)
- */
-export function calculatePercentageThreshold(targetLineCount, percentage, minLines, maxLines) {
-    // Clamp percentage to valid range [0, 100]
-    const clampedPercentage = Math.max(0, Math.min(100, percentage));
-    const calculated = Math.round(targetLineCount * (clampedPercentage / 100));
-    let effectiveLimit = Math.max(calculated, minLines);
-    // Apply optional upper bound
-    if (maxLines !== undefined && maxLines > 0) {
-        effectiveLimit = Math.min(effectiveLimit, maxLines);
-    }
-    return effectiveLimit;
-}

package/dist/core/surface-guard.d.ts

@@ -1,31 +0,0 @@
-import { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory, type PluginSurfaceEntry, type MvpCategory } from '@principles/core/runtime-v2';
-import type { OpenClawPluginService } from '../openclaw-sdk.js';
-export interface SurfaceGuardResult {
-    passed: boolean;
-    enabledCoreSurfaces: string[];
-    disabledNonCoreSurfaces: string[];
-    violations: string[];
-    warnings: string[];
-}
-type LoggerLike = {
-    info?: (msg: string) => void;
-    debug?: (msg: string) => void;
-};
-/**
- * Reset the per-process surface-guard skip log bookkeeping. Intended for tests
- * that need to assert on the first-fire log without cross-test pollution.
- * Not part of the production API surface; do not call from runtime code.
- */
-export declare function __resetSurfaceGuardSkipLogStateForTests(): void;
-export declare function checkSurfaceGuard(): SurfaceGuardResult;
-export declare function getSurfaceIdForHook(hookEvent: string, label?: string): string;
-export declare function getSurfaceIdForService(serviceName: string): string;
-export declare function isSurfaceEnabled(surfaceId: string, overrides?: Record<string, boolean>): {
-    enabled: boolean;
-    reason?: string;
-};
-export type HookHandler<E, C, R> = (event: E, ctx: C) => R | Promise<R>;
-export declare function guardHook<E, C, R>(surfaceId: string, logger: LoggerLike | undefined, handler: HookHandler<E, C, R>): HookHandler<E, C, R>;
-export declare function guardService<T extends OpenClawPluginService>(surfaceId: string, service: T, logger?: LoggerLike): T | null;
-export { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory };
-export type { PluginSurfaceEntry, MvpCategory };

package/dist/core/surface-guard.js

@@ -1,131 +0,0 @@
-import { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory, } from '@principles/core/runtime-v2';
-// Surface-level once-only log state (PRI-298).
-// The first time a quiet/non-core surface guard actually fires in this
-// process, the disabled reason is emitted once. Subsequent fires for the
-// same surfaceId are still observable (the no-op handler preserves
-// behaviour) but no longer flood the log. Fresh processes start with an
-// empty set, so each plugin load gets one observable skip per surface.
-//
-// The Set is only updated when the log was actually emitted, so passing
-// `undefined` for the logger on a quiet first fire does NOT consume the
-// one-shot slot — a later registration that supplies a logger still gets
-// the first-fire reason (PRI-298 / ERR-002).
-const loggedSkipSurfaces = new Set();
-/**
- * Emit the disabled-reason log line for `surfaceId` at most once per
- * process. Returns true if the log was emitted, false if it was suppressed
- * (already logged, or no logger available). Only marks the surface as
- * logged when the log was actually written, so a missing logger on first
- * call does not consume the one-shot slot.
- */
-function logSkipOnce(surfaceId, logger, message) {
-    if (loggedSkipSurfaces.has(surfaceId)) {
-        return false;
-    }
-    if (!logger?.info) {
-        return false;
-    }
-    loggedSkipSurfaces.add(surfaceId);
-    logger.info(message);
-    return true;
-}
-/**
- * Reset the per-process surface-guard skip log bookkeeping. Intended for tests
- * that need to assert on the first-fire log without cross-test pollution.
- * Not part of the production API surface; do not call from runtime code.
- */
-export function __resetSurfaceGuardSkipLogStateForTests() {
-    loggedSkipSurfaces.clear();
-}
-export function checkSurfaceGuard() {
-    const validation = validateSurfaceRegistry(PLUGIN_SURFACE_REGISTRY);
-    const violations = [];
-    const warnings = [...validation.warnings];
-    const coreSurfaces = getSurfacesByCategory(PLUGIN_SURFACE_REGISTRY, 'core');
-    const enabledCore = coreSurfaces.filter(s => s.enabledByDefault);
-    const nonCoreEnabled = PLUGIN_SURFACE_REGISTRY.filter(s => s.category !== 'core' && s.enabledByDefault);
-    if (nonCoreEnabled.length > 0) {
-        for (const surface of nonCoreEnabled) {
-            violations.push(`non-core surface '${surface.id}' (${surface.category}) is enabledByDefault=true — must be false per ADR-0014`);
-        }
-    }
-    if (!validation.valid) {
-        violations.push(...validation.errors);
-    }
-    return {
-        passed: violations.length === 0,
-        enabledCoreSurfaces: enabledCore.map(s => s.id),
-        disabledNonCoreSurfaces: PLUGIN_SURFACE_REGISTRY
-            .filter(s => s.category !== 'core' && !s.enabledByDefault)
-            .map(s => s.id),
-        violations,
-        warnings,
-    };
-}
-export function getSurfaceIdForHook(hookEvent, label) {
-    if (label) {
-        return `hook:${hookEvent}.${label}`;
-    }
-    return `hook:${hookEvent}`;
-}
-export function getSurfaceIdForService(serviceName) {
-    return `service:${serviceName}`;
-}
-export function isSurfaceEnabled(surfaceId, overrides = {}) {
-    const entry = PLUGIN_SURFACE_REGISTRY.find(s => s.id === surfaceId);
-    if (!entry) {
-        return {
-            enabled: false,
-            reason: `surface '${surfaceId}' not found in registry — classify before enabling (PRI-289)`,
-        };
-    }
-    if (Object.hasOwn(overrides, surfaceId)) {
-        const override = overrides[surfaceId];
-        if (typeof override !== 'boolean') {
-            return { enabled: entry.enabledByDefault, reason: `override for '${surfaceId}' is not boolean, using default` };
-        }
-        if (entry.category === 'gone') {
-            return { enabled: false, reason: `surface '${surfaceId}' is gone and cannot be re-enabled` };
-        }
-        if (entry.category === 'core' && !override) {
-            return { enabled: true, reason: `surface '${surfaceId}' is core and cannot be disabled` };
-        }
-        return { enabled: override };
-    }
-    if (!entry.enabledByDefault && entry.disabledReason) {
-        return { enabled: false, reason: entry.disabledReason };
-    }
-    return { enabled: entry.enabledByDefault };
-}
-export function guardHook(surfaceId, logger, handler) {
-    const check = isSurfaceEnabled(surfaceId);
-    if (check.enabled) {
-        return handler;
-    }
-    const reason = check.reason ?? 'surface not enabled';
-    // Log on the first ACTUAL no-op invocation, not at construction time
-    // (PRI-298). Construction-time logging would emit a `SKIP` line at
-    // plugin startup for every registered quiet hook, regardless of
-    // whether the hook ever fires — which is exactly the startup log
-    // noise this change is meant to prevent. The one-shot is consumed only
-    // when the log was actually written, so `undefined` logger on first
-    // call does not eat the slot.
-    return (_event, _ctx) => {
-        logSkipOnce(surfaceId, logger, `[PD:surface-guard] SKIP ${surfaceId}: ${reason}`);
-        return undefined;
-    };
-}
-export function guardService(surfaceId, service, logger) {
-    const check = isSurfaceEnabled(surfaceId);
-    if (check.enabled) {
-        return service;
-    }
-    const reason = check.reason ?? 'surface not enabled';
-    // guardService is called once per service during plugin registration,
-    // so the once-only check fires on the registration call itself. The
-    // shared helper makes the consumption rule identical to guardHook:
-    // a missing logger on first call does not consume the one-shot.
-    logSkipOnce(surfaceId, logger, `[PD:surface-guard] SKIP service ${surfaceId}: ${reason}`);
-    return null;
-}
-export { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory };