create-principles-disciple 1.86.0 → 1.87.0

package/plugin/dist/hooks/triage-adapter.js

@@ -20,69 +20,15 @@
 import { evaluateTriage, } from '@principles/core/runtime-v2';
 // ── Source Kind Resolution ───────────────────────────────────────────────────
 /**
- * Map after_tool_call hook context to SourceKind.
+ * Map RawObservation to SourceKind.
  *
- * Classifies based on:
- * - toolName: 'pain' or 'skill:pain' → agent_on_owner_request
- * - failureSource: 'dispatch_error' vs 'tool_failure'
- * - isRisky + score: only used for rulehost_block upgrade, not for kind resolution
- */
-export function resolveSourceKindFromToolFailure(toolName, failureSource, provenance) {
-    // Manual pain via agent tool call
-    if (toolName === 'pain' || toolName === 'skill:pain') {
-        return provenance === 'openclaw_context_bound' ? 'agent_on_owner_request' : 'owner_reported';
-    }
-    // Dispatch errors (tool not found, unknown tool)
-    if (failureSource === 'dispatch_error') {
-        return 'dispatch_error';
-    }
-    // Regular tool failure
-    return 'tool_failure';
-}
-/**
- * Map empathy/semantic detection context to SourceKind.
+ * This is the unified entry point for source-kind classification.
+ * It replaces the scattered resolveSourceKindFrom* functions.
  *
- * Classifies based on detection source prefix:
- * - 'llm_paralysis' → llm_paralysis
- * - 'llm_*' (detection rule) → semantic
- * - 'user_empathy' or empathy keyword match → empathy_inferred
- * - GFI threshold crossed → gfi_threshold
- */
-export function resolveSourceKindFromLlmDetection(detectionSource, isGfiTriggered) {
-    if (isGfiTriggered)
-        return 'gfi_threshold';
-    if (detectionSource === 'llm_paralysis')
-        return 'llm_paralysis';
-    if (detectionSource.startsWith('llm_'))
-        return 'semantic';
-    if (detectionSource === 'user_empathy')
-        return 'empathy_inferred';
-    return 'unknown';
-}
-/**
- * Map gate-block context to SourceKind.
- */
-export function resolveSourceKindFromGateBlock() {
-    return 'rulehost_block';
-}
-/**
- * Map /pd-pain command to SourceKind.
- */
-export function resolveSourceKindFromCommand() {
-    return 'owner_reported';
-}
-/**
- * Map provider/rate-limit failure to SourceKind.
- */
-export function resolveSourceKindFromProvider(isRateLimit) {
-    return isRateLimit ? 'rate_limit' : 'provider_failure';
-}
-/**
- * Map subagent error to SourceKind.
+ * PRI-360 S1: All source-kind resolution now goes through this single entry point.
  */
-export function resolveSourceKindFromSubagent() {
-    return 'subagent_error';
-}
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation } from './raw-observation-adapter.js';
+// All callers should use resolveSourceKind with RawObservation.
 // ── Triage Evaluation ───────────────────────────────────────────────────────
 /**
  * Evaluate evidence triage for a given source kind and context.
@@ -102,7 +48,32 @@ export function evaluateEvidenceTriage(sourceKind, score, options) {
         isUnsafeHighConfidence: options?.isUnsafeHighConfidence,
         provenance: options?.provenance,
     };
-    return evaluateTriage(input);
+    let result = evaluateTriage(input);
+    // PEAT-B1 upgrade logic: risky high-score overrides evidence_only
+    // Matches PainDiagnosticGate.risky_high_score: isRisky && score >= 70 → admit
+    if (result.decision === 'evidence_only' &&
+        options?.isRisky === true &&
+        score >= 70) {
+        result = {
+            ...result,
+            decision: 'admit',
+            reason: 'Risky high-score operation overrides evidence-only decision. Immediate diagnosis required.',
+            nextAction: 'create_diagnostic_task',
+        };
+    }
+    // PEAT-B1 upgrade logic: repeated failures override evidence_only
+    // Threshold: 4 consecutive failures (matches PainDiagnosticGate.repeatedFailure)
+    if (result.decision === 'evidence_only' &&
+        options?.consecutiveErrors !== undefined &&
+        options.consecutiveErrors >= 4) {
+        result = {
+            ...result,
+            decision: 'admit',
+            reason: 'Repeated failures override evidence-only decision. Pattern suggests systemic issue requiring diagnosis.',
+            nextAction: 'create_diagnostic_task',
+        };
+    }
+    return result;
 }
 // ── High-Confidence Unsafe Action Detection ──────────────────────────────────
 /**

package/plugin/dist/hooks/trigger-cooldown-tracker.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Trigger Cooldown Tracker — PRI-363
+ *
+ * Manages cooldown state for trigger controller decisions.
+ *
+ * This is a plugin-layer concern because:
+ * - Core (trigger-controller) is stateless and pure
+ * - Cooldown state needs to persist across tool calls
+ * - The map is scoped to the plugin's lifecycle
+ *
+ * EP-05: Loop State Freshness — each check reads fresh state from the map.
+ * ERR-001: No `as` casts on map access.
+ * ERR-002: Every rejected decision includes reason + nextAction.
+ */
+/**
+ * Check whether cooldown is currently active for a given episode.
+ */
+export declare function isCooldownActive(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMap: ReadonlyMap<string, number>): boolean;
+/**
+ * Mark an episode as diagnosed (set cooldown timestamp).
+ */
+export declare function markEpisodeAsDiagnosed(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMap: Map<string, number>): void;
+/**
+ * Clear all cooldown state (for tests).
+ */
+export declare function clearCooldownState(cooldownMap: Map<string, number>): void;
+/**
+ * Get the cooldown timestamp for a given episode (for tests).
+ */
+export declare function getCooldownTimestamp(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMap: ReadonlyMap<string, number>): number | undefined;

package/plugin/dist/hooks/trigger-cooldown-tracker.js

@@ -0,0 +1,55 @@
+/**
+ * Trigger Cooldown Tracker — PRI-363
+ *
+ * Manages cooldown state for trigger controller decisions.
+ *
+ * This is a plugin-layer concern because:
+ * - Core (trigger-controller) is stateless and pure
+ * - Cooldown state needs to persist across tool calls
+ * - The map is scoped to the plugin's lifecycle
+ *
+ * EP-05: Loop State Freshness — each check reads fresh state from the map.
+ * ERR-001: No `as` casts on map access.
+ * ERR-002: Every rejected decision includes reason + nextAction.
+ */
+const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000; // 15 minutes
+/**
+ * Episode key format: sessionId:source:errorHash
+ */
+function buildEpisodeKey(source, sessionId, errorHash) {
+    const sid = sessionId || 'unknown';
+    const hash = errorHash || 'no-hash';
+    return `${sid}:${source}:${hash}`;
+}
+/**
+ * Check whether cooldown is currently active for a given episode.
+ */
+export function isCooldownActive(source, sessionId, errorHash, cooldownMap) {
+    const episodeKey = buildEpisodeKey(source, sessionId, errorHash);
+    const lastDiagnosedAt = cooldownMap.get(episodeKey);
+    if (lastDiagnosedAt === undefined) {
+        return false;
+    }
+    const now = Date.now();
+    return now - lastDiagnosedAt < DEFAULT_COOLDOWN_MS;
+}
+/**
+ * Mark an episode as diagnosed (set cooldown timestamp).
+ */
+export function markEpisodeAsDiagnosed(source, sessionId, errorHash, cooldownMap) {
+    const episodeKey = buildEpisodeKey(source, sessionId, errorHash);
+    cooldownMap.set(episodeKey, Date.now());
+}
+/**
+ * Clear all cooldown state (for tests).
+ */
+export function clearCooldownState(cooldownMap) {
+    cooldownMap.clear();
+}
+/**
+ * Get the cooldown timestamp for a given episode (for tests).
+ */
+export function getCooldownTimestamp(source, sessionId, errorHash, cooldownMap) {
+    const episodeKey = buildEpisodeKey(source, sessionId, errorHash);
+    return cooldownMap.get(episodeKey);
+}

package/plugin/dist/index.d.ts

@@ -1,4 +1,6 @@
 import type { OpenClawPluginApi } from './openclaw-sdk.js';
+export { checkConversationAccessConfig, getPluginEntry } from './core/config-health.js';
+export type { ConversationAccessCheckResult } from './core/config-health.js';
 declare function isRecord(value: unknown): value is Record<string, unknown>;
 /**
  * PRI-305/PRI-307: Load feature flag from .pd/config.yaml instead of .pd/feature-flags.yaml.
@@ -29,6 +31,15 @@ export declare function shouldStartCorrectionObserver(workspaceDir: string, logg
     info?: (msg: string) => void;
     warn?: (msg: string) => void;
 }): CorrectionObserverGateResult;
+export interface InternalizationAutoConsumerGateResult {
+    shouldStart: boolean;
+    flagSource: string;
+    disabledInfo: string | null;
+}
+export declare function shouldStartInternalizationAutoConsumer(workspaceDir: string, logger: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+}): InternalizationAutoConsumerGateResult;
 declare const plugin: {
     name: string;
     description: string;

package/plugin/dist/index.js

@@ -1,5 +1,7 @@
 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';
@@ -9,8 +11,8 @@ import { handleBeforeToolCall } from './hooks/gate.js';
 import { handleAfterToolCall } from './hooks/pain.js';
 import { handleBeforeReset, handleBeforeCompaction, handleAfterCompaction } from './hooks/lifecycle.js';
 import { handleLlmOutput } from './hooks/llm.js';
-import { handleSubagentEnded } from './hooks/subagent.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';
@@ -29,6 +31,7 @@ import { handleSamplesCommand } from './commands/samples.js';
 import { handleWorkflowDebugCommand } from './commands/workflow-debug.js';
 import { EvolutionWorkerService } from './service/evolution-worker.js';
 import { CorrectionObserverService } from './service/correction-observer-service.js';
+import { InternalizationAutoConsumerService } from './service/internalization-auto-consumer-service.js';
 import { TrajectoryService } from './service/trajectory-service.js';
 import { PDTaskService } from './core/pd-task-service.js';
 import { CentralSyncService } from './service/central-sync-service.js';
@@ -47,6 +50,9 @@ 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.
 // ── Feature Flag Loader (plugin I/O boundary) ─────────────────────────────
 // Reads workspace feature-flags.yaml and checks a specific flag.
 // Returns the flag definition with effective enabled state.
@@ -88,6 +94,20 @@ export function shouldStartCorrectionObserver(workspaceDir, logger) {
     });
     return { shouldStart: false, flagSource: flag.source, disabledInfo };
 }
+export function shouldStartInternalizationAutoConsumer(workspaceDir, logger) {
+    const flag = loadFeatureFlagFromWorkspace(workspaceDir, 'internalization_auto_consumer', logger);
+    if (flag.enabled) {
+        return { shouldStart: true, flagSource: flag.source, disabledInfo: null };
+    }
+    const disabledInfo = JSON.stringify({
+        reason: 'internalization_auto_consumer_disabled',
+        nextAction: `pd runtime internalization run-once --workspace "${workspaceDir}" --runner dreamer --runtime config --json`,
+        featureFlag: 'internalization_auto_consumer',
+        boundedContext: 'internalization_auto_consumer',
+        flagSource: flag.source,
+    });
+    return { shouldStart: false, flagSource: flag.source, disabledInfo };
+}
 const plugin = {
     name: "Principles Disciple",
     description: "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
@@ -107,6 +127,16 @@ const plugin = {
             else {
                 api.logger.info(`[PD:health] Tool hook workspaceDir OK: "${toolWorkspaceDir}"`);
             }
+            // PRI-343: Check allowConversationAccess — warn if llm_output/trajectory hooks blocked
+            const accessCheck = checkConversationAccessConfig(getPluginEntry(api.config, api.id));
+            if (!accessCheck.authorized) {
+                api.logger.error(`[PD:health] conversation hooks (llm_output / trajectory) will be BLOCKED by OpenClaw.\n` +
+                    `  reason: ${accessCheck.reason}\n` +
+                    `  nextAction: ${accessCheck.nextAction}`);
+            }
+            else {
+                api.logger.info(`[PD:health] conversation hooks (allowConversationAccess) OK`);
+            }
         }, 1000);
         healthCheckTimer.unref(); // Don't keep process alive for health check
         // ── MVP Surface Guard (PRI-289): Verify surface classification ──
@@ -177,6 +207,23 @@ const plugin = {
                         api.logger.info(`[PD] CorrectionObserver NOT started for workspace: ${workspaceDir}. ${corrGate.disabledInfo}`);
                         SystemLogger.log(workspaceDir, 'CORRECTION_OBSERVER_DISABLED', corrGate.disabledInfo ?? '');
                     }
+                    // ── Start InternalizationAutoConsumer for THIS workspace ──
+                    // PRI-381: Bounded auto-consumer for dreamer ready tasks.
+                    // Default ON for dogfood; kill switch via features.internalization_auto_consumer.enabled=false.
+                    const autoConsGate = shouldStartInternalizationAutoConsumer(workspaceDir, api.logger);
+                    if (autoConsGate.shouldStart) {
+                        InternalizationAutoConsumerService.start({
+                            config: api.config,
+                            workspaceDir,
+                            stateDir: path.join(workspaceDir, '.state'),
+                            logger: api.logger,
+                        });
+                        api.logger.info(`[PD] InternalizationAutoConsumer started for workspace: ${workspaceDir} (flag source: ${autoConsGate.flagSource})`);
+                    }
+                    else {
+                        api.logger.info(`[PD] InternalizationAutoConsumer NOT started for workspace: ${workspaceDir}. ${autoConsGate.disabledInfo}`);
+                        SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_DISABLED', autoConsGate.disabledInfo ?? '');
+                    }
                 }
                 const result = await handleBeforePromptBuild(event, { ...ctx, api: api, workspaceDir });
                 // Record success
@@ -287,32 +334,6 @@ const plugin = {
                 api.logger.error(`[PD] Error in llm_output: ${String(err)}`);
             }
         }));
-        // ── Hook: Trajectory Collection (Behavior Evolution Phase 0) ──
-        // Note: after_tool_call and llm_output are safe to collect
-        api.on('after_tool_call', guardHook('hook:after_tool_call.trajectory', api.logger, (event, ctx) => {
-            try {
-                const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'trajectory.after_tool_call');
-                if (!workspaceDir)
-                    return;
-                TrajectoryCollector.handleAfterToolCall(event, { ...ctx, workspaceDir });
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Reason: catch binding intentionally unused
-            }
-            catch (_err) {
-                // Non-critical: don't log, just skip
-            }
-        }));
-        api.on('llm_output', guardHook('hook:llm_output.trajectory', api.logger, (event, ctx) => {
-            try {
-                const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'trajectory.llm_output');
-                if (!workspaceDir)
-                    return;
-                TrajectoryCollector.handleLlmOutput(event, { ...ctx, workspaceDir });
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Reason: catch binding intentionally unused
-            }
-            catch (_err) {
-                // Non-critical: don't log, just skip
-            }
-        }));
         // ── Hook: Subagent Loop Closure ──
         api.on('subagent_spawning', guardHook('hook:subagent_spawning', api.logger, (event, _ctx) => {
             try {
@@ -428,6 +449,28 @@ const plugin = {
             }
             return handleAfterCompaction(event, { ...ctx, workspaceDir: wsResult.workspaceDir });
         }));
+        // ── Hook: Before Message Write (PRI-346) ──
+        // Fallback trajectory collection when llm_output is blocked by
+        // missing allowConversationAccess. Not in CONVERSATION_HOOK_NAMES
+        // so OpenClaw always delivers it.
+        api.on('before_message_write', guardHook('hook:before_message_write', api.logger, (event, ctx) => {
+            const wsResult = resolveHookWorkspaceDir(ctx, api, 'before_message_write');
+            if (!wsResult.ok) {
+                api.logger.warn(`[PD:before_message_write] workspaceDir resolution failed: ${wsResult.reason}`);
+                return;
+            }
+            try {
+                TrajectoryCollector.handleBeforeMessageWrite(event, {
+                    ...ctx,
+                    workspaceDir: wsResult.workspaceDir,
+                    pluginConfig: getPluginEntry(api.config, api.id),
+                });
+            }
+            catch (err) {
+                // Non-critical: don't surface to user
+                api.logger.warn(`[PD:before_message_write] error: ${String(err)}`);
+            }
+        }));
         // ── Service Registration (surface-guarded) ──
         // PRI-294: EvolutionWorker service registration removed — it starts via
         // before_prompt_build hook gate, not via api.registerService. The surface
@@ -446,6 +489,9 @@ const plugin = {
             const guardedCentralSync = guardService('service:central-sync', CentralSyncService, api.logger);
             if (guardedCentralSync)
                 api.registerService(guardedCentralSync);
+            const guardedAutoConsumer = guardService('service:internalization-auto-consumer', InternalizationAutoConsumerService, api.logger);
+            if (guardedAutoConsumer)
+                api.registerService(guardedAutoConsumer);
         }
         catch (err) {
             api.logger.error(`[PD] Failed to register services: ${String(err)}`);

package/plugin/dist/openclaw-sdk.d.ts

@@ -64,6 +64,7 @@ export interface OpenClawPluginService {
     stop?: (ctx: OpenClawPluginServiceContext) => void | Promise<void>;
 }
 export interface OpenClawPluginApi {
+    id: string;
     rootDir?: string;
     pluginConfig?: Record<string, unknown>;
     logger: PluginLogger;

package/plugin/dist/service/evolution-worker.d.ts

@@ -22,7 +22,7 @@ export type { WatchdogResult };
  * Queue V2 Schema - Supports background evolution task kinds.
  *
  * Pain diagnosis is Runtime v2 only: after_tool_call / pd pain record ->
- * PainSignalBridge -> DiagnosticianRunner. EvolutionWorker does not read
+ * PainSignalBridge -> SplitDiagnosticianRunner. EvolutionWorker does not read
  * .pain_flag or process pain_diagnosis queue items.
  */
 /** @deprecated Use PDTaskStatus from '@principles/core/runtime-v2'. M2 migration will replace this. */

package/plugin/dist/service/internalization-auto-consumer-service.d.ts

@@ -0,0 +1,8 @@
+import type { OpenClawPluginServiceContext, PluginLogger } from '../openclaw-sdk.js';
+export interface InternalizationAutoConsumerServiceShape {
+    id: string;
+    start: (ctx: OpenClawPluginServiceContext) => void;
+    stop?: (ctx: OpenClawPluginServiceContext) => void;
+}
+export declare function runConsumerCycle(workspaceDir: string, logger: PluginLogger): Promise<void>;
+export declare const InternalizationAutoConsumerService: InternalizationAutoConsumerServiceShape;