principles-disciple 1.7.6 → 1.7.8

package/dist/index.js

@@ -1,3 +1,6 @@
+import * as crypto from 'crypto';
+import { classifyTask } from './core/local-worker-routing.js';
+import { completeShadowObservation, recordShadowRouting } from './core/shadow-observation-registry.js';
 import { getCommandDescription } from './i18n/commands.js';
 import { handleBeforePromptBuild } from './hooks/prompt.js';
 import { handleBeforeToolCall } from './hooks/gate.js';
@@ -11,7 +14,6 @@ import { handleInitStrategy, handleManageOkr } from './commands/strategy.js';
 import { handleBootstrapTools, handleResearchTools } from './commands/capabilities.js';
 import { handleThinkingOs } from './commands/thinking-os.js';
 import { handleEvolveTask } from './commands/evolver.js';
-import { handleTrustCommand } from './commands/trust.js';
 import { handlePainCommand } from './commands/pain.js';
 import { handleContextCommand } from './commands/context.js';
 import { handleFocusCommand } from './commands/focus.js';
@@ -20,6 +22,9 @@ import { handleEvolutionStatusCommand } from './commands/evolution-status.js';
 import { handlePrincipleRollbackCommand } from './commands/principle-rollback.js';
 import { handleExportCommand } from './commands/export.js';
 import { handleSamplesCommand } from './commands/samples.js';
+import { handleNocturnalReviewCommand } from './commands/nocturnal-review.js';
+import { handleNocturnalTrainCommand } from './commands/nocturnal-train.js';
+import { handleNocturnalRolloutCommand } from './commands/nocturnal-rollout.js';
 import { EvolutionWorkerService } from './service/evolution-worker.js';
 import { TrajectoryService } from './service/trajectory-service.js';
 import { ensureWorkspaceTemplates } from './core/init.js';
@@ -30,6 +35,23 @@ import { PathResolver } from './core/path-resolver.js';
 import { createPrinciplesConsoleRoute } from './http/principles-console-route.js';
 // Track initialization to avoid repeated calls
 let workspaceInitialized = false;
+// Map from childSessionKey → shadowObservationId
+// Used to complete shadow observations when subagent ends
+const pendingShadowObservations = new Map();
+// PD local worker profiles that are managed by the shadow routing policy
+const PD_LOCAL_PROFILES = new Set(['local-reader', 'local-editor']);
+function computeRuntimeShadowTaskFingerprint(event) {
+    const payload = {
+        childSessionKey: event.childSessionKey,
+        agentId: event.agentId,
+        label: event.label ?? '',
+        mode: event.mode,
+        threadRequested: event.threadRequested,
+        requesterChannel: event.requester?.channel ?? '',
+        requesterThreadId: event.requester?.threadId ?? '',
+    };
+    return crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 16);
+}
 const plugin = {
     name: "Principles Disciple",
     description: "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
@@ -119,13 +141,61 @@ const plugin = {
             }
         });
         // ── Hook: Subagent Loop Closure ──
-        api.on('subagent_spawning', (_event, _ctx) => {
-            // No-op for now, just to satisfy the interface expected by tests.
-            return { status: 'ok' };
+        api.on('subagent_spawning', (event, ctx) => {
+            try {
+                const workspaceDir = ctx.workspaceDir || api.resolvePath('.');
+                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', (event, ctx) => {
             try {
                 const workspaceDir = api.resolvePath('.');
+                // 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) {
@@ -223,10 +293,10 @@ const plugin = {
 | 命令 | 用途 | 使用时机 |
 |------|------|----------|
 | \`/pd-status\` | 查看进化状态 | 想了解当前 GFI 和 Pain 情况 |
-| \`/pd-trust\` | 查看信任分数 | 想知道自己的权限等级 |
 | \`/pd-focus\` | 焦点文件管理 | 查看/压缩/回滚历史版本 |
-| \`/pd-export\` | 导出分析/样本 | 导出 analytics 或纠错样本 |
+| \`/pd-export\` | 导出数据 | 导出 analytics/corrections/orpo |
 | \`/pd-samples\` | 审核纠错样本 | 查看待审核样本并批准/拒绝 |
+| \`/pd-nocturnal-review\` | 审核 nocturnal 样本 | 审核 nocturnal 训练样本并导出 ORPO |
 
 ## ⚙️ 配置管理
 | 命令 | 用途 | 使用时机 |
@@ -259,12 +329,6 @@ const plugin = {
 /pd-context status
 \`\`\`
 
-**查看信任分数：**
-\`\`\`
-/pd-trust
-\`\`\`
-
----
 🔍 输入任意命令后加 \`help\` 可查看详细帮助，如 \`/pd-context help\`
 `.trim() };
                 }
@@ -282,10 +346,10 @@ const plugin = {
 | Command | Purpose | When to Use |
 |---------|---------|-------------|
 | \`/pd-status\` | View evolution status | Check GFI and Pain status |
-| \`/pd-trust\` | View trust score | Check your permission level |
 | \`/pd-focus\` | Focus file management | View/compress/rollback history |
-| \`/pd-export\` | Export analytics/samples | Export analytics or correction samples |
+| \`/pd-export\` | Export data | Export analytics/corrections/orpo |
 | \`/pd-samples\` | Review correction samples | Review pending correction samples |
+| \`/pd-nocturnal-review\` | Review nocturnal samples | Review nocturnal training samples and export ORPO |
 
 ## ⚙️ Configuration
 | Command | Purpose | When to Use |
@@ -318,25 +382,11 @@ const plugin = {
 /pd-context status
 \`\`\`
 
-**Check trust score:**
-\`\`\`
-/pd-trust
-\`\`\`
-
----
 🔍 Add \`help\` after any command for details, e.g., \`/pd-context help\`
 `.trim() };
                 }
             }
         });
-        api.registerCommand({
-            name: "pd-trust",
-            description: getCommandDescription('pd-trust', language),
-            handler: (ctx) => {
-                const workspaceDir = api.resolvePath('.');
-                return { text: handleTrustCommand({ ...ctx, workspaceDir }) };
-            }
-        });
         api.registerCommand({
             name: "pd-status",
             description: getCommandDescription('pd-status', language),
@@ -474,6 +524,57 @@ const plugin = {
                 }
             }
         });
+        api.registerCommand({
+            name: "pd-nocturnal-review",
+            description: 'Review nocturnal dataset samples [list|show|approve|reject|set-family|stats]',
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleNocturnalReviewCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /pd-nocturnal-review failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "Nocturnal review 命令执行失败，请检查日志。" : "Nocturnal review command failed. Check logs." };
+                }
+            }
+        });
+        api.registerCommand({
+            name: "nocturnal-train",
+            description: 'Nocturnal training operations [create-experiment|show-experiment|import-result|attach-eval|show-lineage|list-experiments|list-checkpoints|stats]',
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleNocturnalTrainCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /nocturnal-train failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "Nocturnal train 命令执行失败，请检查日志。" : "Nocturnal train command failed. Check logs." };
+                }
+            }
+        });
+        api.registerCommand({
+            name: "nocturnal-rollout",
+            description: 'Nocturnal rollout and promotion [evaluate-promotion|advance-promotion|bind|enable-routing|disable-routing|rollback|status|show-promotion]',
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleNocturnalRolloutCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /nocturnal-rollout failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "Nocturnal rollout 命令执行失败，请检查日志。" : "Nocturnal rollout command failed. Check logs." };
+                }
+            }
+        });
         api.registerTool(createDeepReflectTool(api));
     }
 };

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

@@ -1,10 +1,44 @@
 import type { OpenClawPluginServiceContext, OpenClawPluginApi } from '../openclaw-sdk.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
+/**
+ * Queue V2 Schema - Supports multiple task kinds while preserving pain_diagnosis semantics.
+ *
+ * taskKind semantics:
+ * - pain_diagnosis: User-adjacent, triggers HEARTBEAT, injects into user prompts
+ * - sleep_reflection: Background-only, never injects into user prompts, no HEARTBEAT
+ *
+ * Old queue items (without taskKind) are migrated to pain_diagnosis for compatibility.
+ */
+export type TaskKind = 'pain_diagnosis' | 'sleep_reflection' | 'model_eval';
+export type TaskPriority = 'high' | 'medium' | 'low';
+export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
+export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'canceled';
+/**
+ * Recent pain context attached to sleep_reflection tasks.
+ * Carries explicit recent pain signal metadata without being a separate task kind.
+ * Used by NocturnalTargetSelector for ranking bias and context enrichment.
+ */
+export interface RecentPainContext {
+    /** Most recent unresolved pain event */
+    mostRecent: {
+        score: number;
+        source: string;
+        reason: string;
+        timestamp: string;
+    } | null;
+    /** Count of pain events in the recent window (for signal strength) */
+    recentPainCount: number;
+    /** Highest pain score in the recent window */
+    recentMaxPainScore: number;
+}
 export interface EvolutionQueueItem {
     id: string;
+    taskKind: TaskKind;
+    priority: TaskPriority;
+    source: string;
+    traceId?: string;
     task?: string;
     score: number;
-    source: string;
     reason: string;
     timestamp: string;
     enqueued_at?: string;
@@ -12,11 +46,15 @@ export interface EvolutionQueueItem {
     completed_at?: string;
     assigned_session_key?: string;
     trigger_text_preview?: string;
-    status: 'pending' | 'in_progress' | 'completed';
-    resolution?: 'marker_detected' | 'auto_completed_timeout';
+    status: QueueStatus;
+    resolution?: TaskResolution;
     session_id?: string;
     agent_id?: string;
-    traceId?: string;
+    retryCount: number;
+    maxRetries: number;
+    lastError?: string;
+    resultRef?: string;
+    recentPainContext?: RecentPainContext;
 }
 export declare const EVOLUTION_QUEUE_LOCK_SUFFIX = ".lock";
 export declare const PAIN_CANDIDATES_LOCK_SUFFIX = ".candidates.lock";