principles-disciple 1.159.0 → 1.160.0

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

package/package.json

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

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 };