principles-disciple 1.129.0 → 1.131.0

package/dist/hooks/prompt.js

@@ -3,8 +3,8 @@ import * as path from 'path';
 import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds, trackFriction, decayGfi, getGfiDecayElapsed } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { defaultContextConfig } from '../types.js';
-// local-worker-routing: removed from prompt injection per PRI-291 (MVP-Quiet)
-// classifyTask is still available for non-prompt consumers
+// local-worker-routing module and its routing helpers removed entirely per PRI-448.
+// Routing guidance is no longer injected into prompts.
 import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
 import { PathResolver } from '../core/path-resolver.js';
 import { selectPrinciplesForInjection, DEFAULT_PRINCIPLE_BUDGET } from '../core/principle-injection.js';
@@ -826,9 +826,8 @@ ${empathySilenceConstraint}
         const directiveText = renderPrinciplesToDirectives(dedupedV2, runtimeV2PrincipleIds, escapeXml);
         prependSystemContext += directiveText;
     }
-    // Routing guidance removed per PRI-291 (MVP diet).
-    // Local worker routing is MVP-Quiet per ADR-0014 §2.5.
-    // The classifyTask helper and local-worker-routing module are preserved for non-prompt consumers.
+    // Routing guidance removed per PRI-291; local-worker-routing module and its
+    // routing helpers deleted per PRI-448. No routing-related content is injected.
     // 6. Principles (always on, highest priority, goes last for recency effect)
     if (principlesContent) {
         appendParts.push(`<core_principles>\n${principlesContent}\n</core_principles>`);

package/dist/index.js

@@ -2,8 +2,6 @@ import * as path from 'path';
 import { loadFeatureFlagFromConfig } from './core/pd-config-loader.js';
 import { checkConversationAccessConfig, getPluginEntry } from './core/config-health.js';
 export { checkConversationAccessConfig, getPluginEntry } from './core/config-health.js';
-import { classifyTask } from './core/local-worker-routing.js';
-import { completeShadowObservation, recordShadowRouting } from './core/shadow-observation-registry.js';
 import { getCommandDescription } from './i18n/commands.js';
 import { WorkspaceContext } from './core/workspace-context.js';
 import { handleBeforePromptBuild } from './hooks/prompt.js';
@@ -12,7 +10,6 @@ import { handleAfterToolCall } from './hooks/pain.js';
 import { handleBeforeReset, handleBeforeCompaction, handleAfterCompaction } from './hooks/lifecycle.js';
 import { handleLlmOutput } from './hooks/llm.js';
 import * as TrajectoryCollector from './hooks/trajectory-collector.js';
-import { handleSubagentEnded } from './hooks/subagent.js';
 import { handleInitStrategy } from './commands/strategy.js';
 import { handleBootstrapTools, handleResearchTools } from './commands/capabilities.js';
 import { handleThinkingOs } from './commands/thinking-os.js';
@@ -41,15 +38,10 @@ import { migrateStaleWorkspaceGuidance } from './core/workspace-guidance-migrato
 import { SystemLogger } from './core/system-logger.js';
 import { PathResolver } from './core/path-resolver.js';
 import { resolveCommandWorkspaceDir, resolveToolHookWorkspaceDirSafe, resolveHookWorkspaceDir } from './utils/workspace-resolver.js';
-import { computeRuntimeShadowTaskFingerprint, PD_LOCAL_PROFILES } from './utils/shadow-fingerprint.js';
 import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
-import { resolveWorkspaceDirFromApi } from './core/path-resolver.js';
 import { checkSurfaceGuard, guardHook, guardService } from './core/surface-guard.js';
 // Track started workspaces — one-time init + evolution worker per workspace
 const startedWorkspaces = new Set();
-// Map from childSessionKey → shadowObservationId
-// Used to complete shadow observations when subagent ends
-const pendingShadowObservations = new Map();
 // ── Conversation Access Health Check (PRI-343) ────────────────────────────
 // Re-exported from core/config-health.ts for backward compatibility.
 // Implementation moved to avoid circular imports with trajectory-collector.ts.
@@ -334,81 +326,6 @@ const plugin = {
                 api.logger.error(`[PD] Error in llm_output: ${String(err)}`);
             }
         }));
-        // ── Hook: Subagent Loop Closure ──
-        api.on('subagent_spawning', guardHook('hook:subagent_spawning', api.logger, (event, _ctx) => {
-            try {
-                // FIX (B): Never fall back to '.' — fail-fast with ERROR log if workspaceDir cannot be resolved.
-                // For subagent hooks, we use event.agentId as the target agent for workspace resolution.
-                const workspaceDir = resolveWorkspaceDirFromApi(api, event.agentId);
-                if (!workspaceDir) {
-                    api.logger.error(`[PD] subagent_spawning: cannot resolve workspaceDir for agent "${event.agentId}" — skipping shadow routing`);
-                    return { status: 'ok' };
-                }
-                api.logger?.debug?.(`[PD] workspaceDir resolved for subagent_spawning: ${workspaceDir}`);
-                const { agentId, childSessionKey } = event;
-                // Only handle PD local worker profiles
-                if (!PD_LOCAL_PROFILES.has(agentId)) {
-                    return { status: 'ok' };
-                }
-                // Use the real runtime hook to record shadow evidence. We still consult the
-                // routing/deployment state here, but the observation itself must originate
-                // from actual subagent execution rather than an operator command path.
-                const routingInput = { targetProfile: agentId };
-                const decision = classifyTask(routingInput, workspaceDir);
-                const shouldRecordShadow = decision.activeCheckpointState === 'shadow_ready' &&
-                    !!decision.activeCheckpointId &&
-                    decision.deploymentCheck.routingEnabled &&
-                    decision.deploymentCheck.checkpointDeployable;
-                if (shouldRecordShadow) {
-                    const observation = recordShadowRouting(workspaceDir, {
-                        checkpointId: decision.activeCheckpointId,
-                        workerProfile: agentId,
-                        taskFingerprint: computeRuntimeShadowTaskFingerprint(event),
-                    });
-                    pendingShadowObservations.set(childSessionKey, observation.observationId);
-                }
-                return { status: 'ok' };
-            }
-            catch (err) {
-                api.logger.error(`[PD] Error in subagent_spawning shadow routing: ${String(err)}`);
-                return { status: 'ok' }; // Don't block spawn on shadow observation errors
-            }
-        }));
-        api.on('subagent_ended', guardHook('hook:subagent_ended', api.logger, (event, ctx) => {
-            try {
-                // FIX (B): Never fall back to '.' — fail-fast with ERROR log if workspaceDir cannot be resolved.
-                const workspaceDir = resolveWorkspaceDirFromApi(api, undefined);
-                if (!workspaceDir) {
-                    api.logger.error(`[PD] subagent_ended: cannot resolve workspaceDir — skipping shadow observation completion`);
-                    return;
-                }
-                api.logger?.debug?.(`[PD] workspaceDir resolved for subagent_ended: ${workspaceDir}`);
-                // Complete any pending shadow observation for this subagent session
-                const shadowObsId = pendingShadowObservations.get(event.targetSessionKey);
-                if (shadowObsId && workspaceDir) {
-                    try {
-                        const outcome = event.outcome === 'ok'
-                            ? 'accepted'
-                            : event.outcome === 'error'
-                                ? 'rejected'
-                                : 'escalated';
-                        completeShadowObservation(workspaceDir, {
-                            observationId: shadowObsId,
-                            outcome,
-                            failureSignals: event.outcome === 'error' ? { threwException: true, timedOut: false, invalidOutput: false, profileRejected: false, extra: {} } : undefined,
-                        });
-                        pendingShadowObservations.delete(event.targetSessionKey);
-                    }
-                    catch (err) {
-                        api.logger.error(`[PD] Failed to complete shadow observation: ${String(err)}`);
-                    }
-                }
-                handleSubagentEnded(event, { ...ctx, workspaceDir, api });
-            }
-            catch (err) {
-                api.logger.error(`[PD] Error in subagent_ended: ${String(err)}`);
-            }
-        }));
         // ── Hook: Lifecycle ──
         api.on('before_reset', guardHook('hook:before_reset', api.logger, (event, ctx) => {
             const wsResult = resolveHookWorkspaceDir(ctx, api, 'before_reset');

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

package/package.json

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

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

@@ -1,124 +0,0 @@
-/**
- * Local Worker Routing Policy — Task Classification and Routing Decisions
- * ======================================================================
- *
- * Phase: PRI-74 Routing Guidance Migration (follow-up to PRI-75 Prompt Injection SDK Migration)
- *
- * This file is a THIN ADAPTER.
- * Pure classification logic lives in @principles/core/prompt-builder/routing-guidance.ts.
- * This file handles I/O (deployment registry, promotion state) and combines
- * pure classification with deployment checks.
- *
- * ARCHITECTURE:
- *   - Pure: classifyTaskKind, buildReason, buildBlockers, keyword constants → core
- *   - I/O: getDeployment, isRoutingEnabledForProfile, isCheckpointDeployable, getPromotionState → plugin
- *
- * TASK CLASSIFICATION TAXONOMY:
- *   Pure-classification output from classifyTaskKind() in @principles/core/prompt-builder/routing-guidance.ts:
- *     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
- *     ambiguous_scope     — tasks that are unclear and need main-agent judgment
- *   Plugin layer adds I/O-bound categories via deployment checks in classifyTask():
- *     profile_mismatch    — target profile incompatible with task classification
- *     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
- *   - No enabled deployment → stay_main
- */
-import type { WorkerProfile } from './model-deployment-registry.js';
-import { type RoutingInput as CoreRoutingInput } from '@principles/core/prompt-builder';
-export type { RoutingInput } from '@principles/core/prompt-builder';
-/**
- * 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' | '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 (core pure function)
- *   2. Checks deployment availability for the target profile (plugin I/O)
- *   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: CoreRoutingInput, 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: CoreRoutingInput, 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[];

package/dist/core/local-worker-routing.js

@@ -1,216 +0,0 @@
-/**
- * Local Worker Routing Policy — Task Classification and Routing Decisions
- * ======================================================================
- *
- * Phase: PRI-74 Routing Guidance Migration (follow-up to PRI-75 Prompt Injection SDK Migration)
- *
- * This file is a THIN ADAPTER.
- * Pure classification logic lives in @principles/core/prompt-builder/routing-guidance.ts.
- * This file handles I/O (deployment registry, promotion state) and combines
- * pure classification with deployment checks.
- *
- * ARCHITECTURE:
- *   - Pure: classifyTaskKind, buildReason, buildBlockers, keyword constants → core
- *   - I/O: getDeployment, isRoutingEnabledForProfile, isCheckpointDeployable, getPromotionState → plugin
- *
- * TASK CLASSIFICATION TAXONOMY:
- *   Pure-classification output from classifyTaskKind() in @principles/core/prompt-builder/routing-guidance.ts:
- *     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
- *     ambiguous_scope     — tasks that are unclear and need main-agent judgment
- *   Plugin layer adds I/O-bound categories via deployment checks in classifyTask():
- *     profile_mismatch    — target profile incompatible with task classification
- *     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
- *   - No enabled deployment → stay_main
- */
-import { isRoutingEnabledForProfile, getDeployment, } from './model-deployment-registry.js';
-import { isCheckpointDeployable } from './model-training-registry.js';
-import { getPromotionState } from './promotion-gate.js';
-// Core pure functions — migrated to @principles/core/prompt-builder
-import { classifyTaskKind as coreClassifyTaskKind, buildReason as coreBuildReason, buildBlockers as coreBuildBlockers, } from '@principles/core/prompt-builder';
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * 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 (core pure function)
- *   2. Checks deployment availability for the target profile (plugin I/O)
- *   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 function classifyTask(input, stateDir) {
-    // --- Determine the raw task classification (delegated to core pure function) ---
-    const classification = coreClassifyTaskKind(input);
-    // --- Determine the target profile ---
-    // If input specifies a target, use it. Otherwise, pick based on classification.
-    // NOTE: When explicitly specified, we must validate profile-task compatibility below.
-    const targetProfile = input.targetProfile ??
-        (classification === 'reader_eligible'
-            ? 'local-reader'
-            : classification === 'editor_eligible'
-                ? 'local-editor'
-                : null);
-    // --- Profile-task compatibility check ---
-    // Only applies when input.targetProfile is EXPLICITLY set.
-    // When auto-derived (input.targetProfile is null), compatibility is already
-    // guaranteed by the auto-derivation logic above (reader_eligible → local-reader).
-    // This check prevents routing a reader task to an editor profile (or vice versa)
-    // when the caller explicitly requests the wrong profile.
-    const isProfileCompatible = input.targetProfile === undefined
-        ? true // Auto-derived profile is always compatible by construction
-        : targetProfile === 'local-reader'
-            ? classification === 'reader_eligible'
-            : targetProfile === 'local-editor'
-                ? classification === 'editor_eligible'
-                : false;
-    // --- Deployment availability check ---
-    let deploymentCheck = {
-        performed: false,
-        profileAvailable: false,
-        routingEnabled: false,
-        checkpointDeployable: false,
-    };
-    if (targetProfile) {
-        const deployment = getDeployment(stateDir, targetProfile);
-        const activeCheckpointId = deployment?.activeCheckpointId ?? null;
-        // Re-check deployability on every routing decision — a checkpoint may have been revoked
-        const checkpointDeployable = activeCheckpointId
-            ? isCheckpointDeployable(stateDir, activeCheckpointId)
-            : false;
-        deploymentCheck = {
-            performed: true,
-            profileAvailable: deployment !== null,
-            routingEnabled: isRoutingEnabledForProfile(stateDir, targetProfile),
-            checkpointDeployable,
-        };
-    }
-    // --- Build the decision (delegated to core pure functions) ---
-    const blockers = coreBuildBlockers(classification, input);
-    const reason = coreBuildReason(classification, input);
-    // FAIL-CLOSED: route_local only if:
-    //   1. Classification is eligible (reader_eligible or editor_eligible)
-    //   2. A target profile was identified
-    //   3. The task's natural profile is compatible with the target profile
-    //   4. Deployment is available and routing is enabled
-    const isEligibleForRouting = (classification === 'reader_eligible' || classification === 'editor_eligible') &&
-        targetProfile !== null &&
-        isProfileCompatible &&
-        deploymentCheck.routingEnabled;
-    const decision = isEligibleForRouting
-        ? 'route_local'
-        : 'stay_main';
-    // Derive the final classification — preserves the root cause of stay_main:
-    //   - profile_mismatch: task would be eligible but wrong profile requested
-    //   - deployment_unavailable: eligible and compatible but no routing enabled
-    //   - raw classification: blocked by high_entropy / risk / ambiguous
-    const isEligible = classification === 'reader_eligible' || classification === 'editor_eligible';
-    const finalClassification = isEligibleForRouting
-        ? classification
-        : isEligible && targetProfile !== null && !isProfileCompatible
-            ? 'profile_mismatch'
-            : isEligible
-                ? 'deployment_unavailable'
-                : classification;
-    // Build explainability fields specific to the stay_main reason
-    let finalReason = reason;
-    let finalBlockers = blockers;
-    if (decision === 'stay_main') {
-        if (finalClassification === 'profile_mismatch') {
-            const wanted = classification === 'reader_eligible' ? 'local-reader' : 'local-editor';
-            finalReason = `Task is ${classification} but was explicitly targeted at ${targetProfile}. ` +
-                `Routing requires "${wanted}" profile. Ensure the task intent matches the requested profile.`;
-            finalBlockers = [
-                `profile mismatch: task is ${classification} but targetProfile is ${targetProfile}`,
-                `required profile: ${wanted}`,
-            ];
-        }
-        else if (finalClassification === 'deployment_unavailable') {
-            if (!deploymentCheck.performed) {
-                finalReason = reason;
-            }
-            else if (!deploymentCheck.profileAvailable) {
-                finalReason = `Task is ${classification} but no deployment exists for ${targetProfile}. ` +
-                    `Bind a checkpoint via bindCheckpointToWorkerProfile() and enable routing.`;
-                finalBlockers = [`no deployment found for profile: ${targetProfile}`];
-            }
-            else if (!deploymentCheck.checkpointDeployable) {
-                finalReason = `Task is ${classification} but the active checkpoint has been revoked (no longer deployable). ` +
-                    `Re-bind a passing checkpoint or re-evaluate the current one.`;
-                finalBlockers = [
-                    `active checkpoint is no longer deployable: ${targetProfile}`,
-                    'revoked checkpoints must not be used for routing',
-                ];
-            }
-            else if (!deploymentCheck.routingEnabled) {
-                finalReason = `Task is ${classification} and deployment exists for ${targetProfile} but routing is not enabled. ` +
-                    `Enable routing via enableRoutingForProfile() in the deployment registry.`;
-                finalBlockers = [`routing is disabled for profile: ${targetProfile}`];
-            }
-        }
-    }
-    // --- Get active checkpoint ID and state for shadow observation integration ---
-    let activeCheckpointId = null;
-    let activeCheckpointState = null;
-    if (targetProfile && deploymentCheck.performed) {
-        const deployment = getDeployment(stateDir, targetProfile);
-        activeCheckpointId = deployment?.activeCheckpointId ?? null;
-        if (activeCheckpointId) {
-            const promotionState = getPromotionState(stateDir, activeCheckpointId);
-            if (promotionState === 'shadow_ready' || promotionState === 'promotable' || promotionState === 'candidate_only') {
-                activeCheckpointState = promotionState;
-            }
-        }
-    }
-    return {
-        decision,
-        targetProfile: decision === 'route_local' ? targetProfile : null,
-        classification: finalClassification,
-        reason: finalReason,
-        blockers: decision === 'stay_main' ? finalBlockers : [],
-        deploymentCheck,
-        activeCheckpointId,
-        activeCheckpointState: activeCheckpointState ?? undefined,
-        shadowObservationId: undefined,
-    };
-}
-/**
- * Convenience: check if a specific profile can handle a task.
- * Equivalent to calling classifyTask with targetProfile set.
- */
-export function canRouteToProfile(input, stateDir, profile) {
-    const decision = classifyTask({ ...input, targetProfile: profile }, stateDir);
-    return decision.decision === 'route_local';
-}
-// ---------------------------------------------------------------------------
-// Read-Only Query Helpers
-// ---------------------------------------------------------------------------
-/**
- * Check if any local worker routing is currently enabled for any profile.
- */
-export function isAnyLocalRoutingEnabled(stateDir) {
-    return isRoutingEnabledForProfile(stateDir, 'local-reader') ||
-        isRoutingEnabledForProfile(stateDir, 'local-editor');
-}
-/**
- * List all profiles that currently have routing enabled.
- */
-export function listEnabledProfiles(stateDir) {
-    const enabled = [];
-    if (isRoutingEnabledForProfile(stateDir, 'local-reader'))
-        enabled.push('local-reader');
-    if (isRoutingEnabledForProfile(stateDir, 'local-editor'))
-        enabled.push('local-editor');
-    return enabled;
-}