principles-disciple 1.5.4 → 1.7.0

package/dist/service/empathy-observer-manager.js

@@ -0,0 +1,147 @@
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { trackFriction } from '../core/session-tracker.js';
+const OBSERVER_SESSION_PREFIX = 'empathy_obs:';
+export class EmpathyObserverManager {
+    static instance;
+    sessionLocks = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!EmpathyObserverManager.instance) {
+            EmpathyObserverManager.instance = new EmpathyObserverManager();
+        }
+        return EmpathyObserverManager.instance;
+    }
+    shouldTrigger(api, sessionId) {
+        if (!api || !sessionId)
+            return false;
+        const enabled = api.config?.empathy_engine?.enabled !== false;
+        if (!enabled)
+            return false;
+        return !this.sessionLocks.has(sessionId);
+    }
+    async spawn(api, sessionId, userMessage) {
+        if (!api)
+            return null;
+        if (!this.shouldTrigger(api, sessionId))
+            return null;
+        if (!userMessage?.trim())
+            return null;
+        const timestamp = Date.now();
+        const sessionKey = `${OBSERVER_SESSION_PREFIX}${sessionId}:${timestamp}`;
+        this.sessionLocks.set(sessionId, sessionKey);
+        const prompt = [
+            'You are an empathy observer.',
+            'Analyze ONLY the user message and return strict JSON (no markdown):',
+            '{"damageDetected": boolean, "severity": "mild|moderate|severe", "confidence": number, "reason": string}',
+            `User message: ${JSON.stringify(userMessage.trim())}`,
+        ].join('\n');
+        try {
+            await api.runtime.subagent.run({
+                sessionKey,
+                message: prompt,
+                lane: 'subagent',
+                deliver: false,
+                idempotencyKey: `${sessionId}:${timestamp}`,
+            });
+            api.logger.info(`[PD:EmpathyObserver] Spawned observer ${sessionKey}`);
+            return sessionKey;
+        }
+        catch (error) {
+            this.sessionLocks.delete(sessionId);
+            api.logger.warn(`[PD:EmpathyObserver] Failed to spawn observer for ${sessionId}: ${String(error)}`);
+            return null;
+        }
+    }
+    async reap(api, targetSessionKey, workspaceDir) {
+        if (!api || !workspaceDir || !this.isObserverSession(targetSessionKey))
+            return;
+        const sessionId = this.extractParentSessionId(targetSessionKey);
+        const unlock = () => {
+            if (sessionId && this.sessionLocks.get(sessionId) === targetSessionKey) {
+                this.sessionLocks.delete(sessionId);
+            }
+        };
+        try {
+            const messages = await api.runtime.subagent.getSessionMessages({
+                sessionKey: targetSessionKey,
+                limit: 20,
+            });
+            const rawText = this.extractAssistantText(messages.messages, messages.assistantTexts);
+            const parsed = this.parseJsonPayload(rawText, api.logger);
+            if (parsed?.damageDetected && sessionId) {
+                const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
+                const score = this.scoreFromSeverity(parsed.severity, wctx.config);
+                trackFriction(sessionId, score, `observer_empathy_${parsed.severity || 'mild'}`, workspaceDir);
+                api.logger.info(`[PD:EmpathyObserver] Applied GFI +${score} for ${sessionId}`);
+            }
+        }
+        catch (error) {
+            api.logger.warn(`[PD:EmpathyObserver] Failed to reap ${targetSessionKey}: ${String(error)}`);
+        }
+        finally {
+            unlock();
+        }
+    }
+    isObserverSession(sessionKey) {
+        return typeof sessionKey === 'string' && sessionKey.startsWith(OBSERVER_SESSION_PREFIX);
+    }
+    extractParentSessionId(sessionKey) {
+        if (!this.isObserverSession(sessionKey))
+            return null;
+        const rest = sessionKey.slice(OBSERVER_SESSION_PREFIX.length);
+        const marker = rest.lastIndexOf(':');
+        if (marker <= 0)
+            return null;
+        return rest.slice(0, marker);
+    }
+    parseJsonPayload(rawText, logger) {
+        if (!rawText?.trim())
+            return null;
+        try {
+            return JSON.parse(rawText.trim());
+        }
+        catch {
+            const match = rawText.match(/\{[\s\S]*\}/);
+            if (!match) {
+                logger?.warn('[PD:EmpathyObserver] Observer payload is not valid JSON, skipping.');
+                return null;
+            }
+            try {
+                return JSON.parse(match[0]);
+            }
+            catch {
+                logger?.warn('[PD:EmpathyObserver] Failed to parse observer JSON payload, skipping.');
+                return null;
+            }
+        }
+    }
+    extractAssistantText(messages, assistantTexts) {
+        if (assistantTexts && assistantTexts.length > 0) {
+            return assistantTexts[assistantTexts.length - 1] || '';
+        }
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            if (msg?.role !== 'assistant')
+                continue;
+            if (typeof msg.content === 'string')
+                return msg.content;
+            if (Array.isArray(msg.content)) {
+                const txt = msg.content
+                    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+                    .map((part) => part.text)
+                    .join('\n');
+                if (txt)
+                    return txt;
+            }
+        }
+        return '';
+    }
+    scoreFromSeverity(severity, config) {
+        if (severity === 'severe')
+            return Number(config.get('empathy_engine.penalties.severe') ?? 40);
+        if (severity === 'moderate')
+            return Number(config.get('empathy_engine.penalties.moderate') ?? 25);
+        return Number(config.get('empathy_engine.penalties.mild') ?? 10);
+    }
+}
+export const empathyObserverManager = EmpathyObserverManager.getInstance();

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

@@ -1,6 +1,7 @@
 import type { OpenClawPluginServiceContext, OpenClawPluginApi } from '../openclaw-sdk.js';
 export interface EvolutionQueueItem {
     id: string;
+    task?: string;
     score: number;
     source: string;
     reason: string;
@@ -8,6 +9,15 @@ export interface EvolutionQueueItem {
     trigger_text_preview?: string;
     status: 'pending' | 'in_progress' | 'completed';
 }
+export declare function hasRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number): boolean;
+export declare function hasEquivalentPromotedRule(dictionary: {
+    getAllRules(): Record<string, {
+        type: string;
+        phrases?: string[];
+        pattern?: string;
+        status: string;
+    }>;
+}, phrase: string): boolean;
 export interface ExtendedEvolutionWorkerService {
     id: string;
     api: OpenClawPluginApi | null;

package/dist/service/evolution-worker.js

@@ -8,6 +8,101 @@ import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { initPersistence, flushAllSessions } from '../core/session-tracker.js';
 let intervalId = null;
+const PAIN_QUEUE_DEDUP_WINDOW_MS = 30 * 60 * 1000;
+// P0 fix: File lock constants and helper for queue operations (prevents TOCTOU race)
+const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
+const LOCK_MAX_RETRIES = 50;
+const LOCK_RETRY_DELAY_MS = 50;
+const LOCK_STALE_MS = 30_000;
+/**
+ * Acquire an exclusive file lock for the given resource.
+ * Returns a release function. Uses 'wx' flag for atomic exclusive create.
+ * Detects stale locks by checking PID and mtime.
+ */
+function acquireQueueLock(lockPath, logger) {
+    let retries = 0;
+    while (retries < LOCK_MAX_RETRIES) {
+        try {
+            const fd = fs.openSync(lockPath, 'wx');
+            fs.writeSync(fd, `${process.pid}\n${Date.now()}`);
+            fs.closeSync(fd);
+            return () => {
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch { /* ignore */ }
+            };
+        }
+        catch (err) {
+            if (err.code === 'EEXIST') {
+                // Check if lock is stale
+                try {
+                    const stat = fs.statSync(lockPath);
+                    const content = fs.readFileSync(lockPath, 'utf8').trim();
+                    const pid = parseInt(content.split('\n')[0] || '0', 10);
+                    let isStale = false;
+                    if (pid > 0) {
+                        try {
+                            process.kill(pid, 0);
+                        }
+                        catch (e) {
+                            if (e.code === 'ESRCH')
+                                isStale = true;
+                        }
+                        if (!isStale && Date.now() - stat.mtimeMs > LOCK_STALE_MS)
+                            isStale = true;
+                    }
+                    else if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                        isStale = true;
+                    }
+                    if (isStale) {
+                        fs.unlinkSync(lockPath);
+                        retries++;
+                        const start = Date.now();
+                        while (Date.now() - start < LOCK_RETRY_DELAY_MS) { /* spin */ }
+                        continue;
+                    }
+                }
+                catch { /* stat/read failed, treat as busy */ }
+                retries++;
+                const start = Date.now();
+                while (Date.now() - start < LOCK_RETRY_DELAY_MS) { /* spin */ }
+                continue;
+            }
+            throw err;
+        }
+    }
+    logger?.warn?.(`[PD:EvolutionWorker] Failed to acquire lock after ${LOCK_MAX_RETRIES} retries: ${lockPath}`);
+    return null;
+}
+function normalizePainDedupKey(source, preview) {
+    return `${source.trim().toLowerCase()}::${preview.trim().toLowerCase()}`;
+}
+export function hasRecentDuplicateTask(queue, source, preview, now) {
+    const key = normalizePainDedupKey(source, preview);
+    return queue.some((task) => {
+        if (task.status === 'completed')
+            return false;
+        const taskTime = new Date(task.timestamp).getTime();
+        if (!Number.isFinite(taskTime) || (now - taskTime) > PAIN_QUEUE_DEDUP_WINDOW_MS)
+            return false;
+        return normalizePainDedupKey(task.source, task.trigger_text_preview || '') === key;
+    });
+}
+export function hasEquivalentPromotedRule(dictionary, phrase) {
+    const normalizedPhrase = phrase.trim().toLowerCase();
+    return Object.values(dictionary.getAllRules()).some((rule) => {
+        if (rule.status !== 'active')
+            return false;
+        if (rule.type === 'exact_match' && Array.isArray(rule.phrases)) {
+            return rule.phrases.some((candidate) => candidate.trim().toLowerCase() === normalizedPhrase);
+        }
+        if (rule.type === 'regex' && typeof rule.pattern === 'string') {
+            return rule.pattern.trim().toLowerCase() === normalizedPhrase;
+        }
+        return false;
+    });
+}
 function checkPainFlag(wctx, logger) {
     try {
         const painFlagPath = wctx.resolve('PAIN_FLAG');
@@ -37,28 +132,43 @@ function checkPainFlag(wctx, logger) {
         if (logger)
             logger.info(`[PD:EvolutionWorker] Detected pain flag (score: ${score}, source: ${source}). Enqueueing evolution task.`);
         const queuePath = wctx.resolve('EVOLUTION_QUEUE');
-        let queue = [];
-        if (fs.existsSync(queuePath)) {
-            try {
-                queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        const lockPath = queuePath + EVOLUTION_QUEUE_LOCK_SUFFIX;
+        const releaseLock = acquireQueueLock(lockPath, logger);
+        if (!releaseLock)
+            return; // Could not acquire lock
+        try {
+            let queue = [];
+            if (fs.existsSync(queuePath)) {
+                try {
+                    queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+                }
+                catch (e) {
+                    if (logger)
+                        logger.error(`[PD:EvolutionWorker] Failed to parse evolution queue: ${String(e)}`);
+                }
             }
-            catch (e) {
-                if (logger)
-                    logger.error(`[PD:EvolutionWorker] Failed to parse evolution queue: ${String(e)}`);
+            const now = Date.now();
+            if (hasRecentDuplicateTask(queue, source, preview, now)) {
+                logger?.info?.(`[PD:EvolutionWorker] Duplicate pain task skipped for source=${source} preview=${preview || 'N/A'}`);
+                fs.appendFileSync(painFlagPath, `\nstatus: queued\n`, 'utf8');
+                return;
             }
+            const taskId = createHash('md5').update(`${source}:${score}:${preview}`).digest('hex').substring(0, 8);
+            queue.push({
+                id: taskId,
+                score,
+                source,
+                reason,
+                trigger_text_preview: preview,
+                timestamp: new Date(now).toISOString(),
+                status: 'pending'
+            });
+            fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+            fs.appendFileSync(painFlagPath, '\nstatus: queued\n', 'utf8');
+        }
+        finally {
+            releaseLock();
         }
-        const taskId = createHash('md5').update(`${source}:${score}:${new Date().toISOString()}`).digest('hex').substring(0, 8);
-        queue.push({
-            id: taskId,
-            score,
-            source,
-            reason,
-            trigger_text_preview: preview,
-            timestamp: new Date().toISOString(),
-            status: 'pending'
-        });
-        fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
-        fs.appendFileSync(painFlagPath, '\nstatus: queued\n', 'utf8');
     }
     catch (err) {
         if (logger)
@@ -66,11 +176,23 @@ function checkPainFlag(wctx, logger) {
     }
 }
 function processEvolutionQueue(wctx, logger, eventLog) {
+    const queuePath = wctx.resolve('EVOLUTION_QUEUE');
+    if (!fs.existsSync(queuePath))
+        return;
+    const lockPath = queuePath + EVOLUTION_QUEUE_LOCK_SUFFIX;
+    const releaseLock = acquireQueueLock(lockPath, logger);
+    if (!releaseLock)
+        return; // Could not acquire lock
     try {
-        const queuePath = wctx.resolve('EVOLUTION_QUEUE');
-        if (!fs.existsSync(queuePath))
+        let queue = [];
+        try {
+            queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        }
+        catch (e) {
+            if (logger)
+                logger.error(`[PD:EvolutionWorker] Failed to parse evolution queue: ${String(e)}`);
             return;
-        const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        }
         let queueChanged = false;
         const config = wctx.config;
         const timeout = config.get('intervals.task_timeout_ms') || (30 * 60 * 1000);
@@ -89,13 +211,15 @@ function processEvolutionQueue(wctx, logger, eventLog) {
         if (pendingTasks.length > 0) {
             const directivePath = wctx.resolve('EVOLUTION_DIRECTIVE');
             const highestScoreTask = pendingTasks.sort((a, b) => b.score - a.score)[0];
+            const taskDescription = `Diagnose systemic pain [ID: ${highestScoreTask.id}]. Source: ${highestScoreTask.source}. Reason: ${highestScoreTask.reason}. ` +
+                `Trigger text: "${highestScoreTask.trigger_text_preview || 'N/A'}"`;
             const directive = {
                 active: true,
-                task: `Diagnose systemic pain [ID: ${highestScoreTask.id}]. Source: ${highestScoreTask.source}. Reason: ${highestScoreTask.reason}. ` +
-                    `Trigger text: "${highestScoreTask.trigger_text_preview || 'N/A'}"`,
+                task: taskDescription,
                 timestamp: new Date().toISOString()
             };
             fs.writeFileSync(directivePath, JSON.stringify(directive, null, 2), 'utf8');
+            highestScoreTask.task = taskDescription;
             highestScoreTask.status = 'in_progress';
             queueChanged = true;
             if (eventLog) {
@@ -114,6 +238,9 @@ function processEvolutionQueue(wctx, logger, eventLog) {
         if (logger)
             logger.warn(`[PD:EvolutionWorker] Error processing evolution queue: ${String(err)}`);
     }
+    finally {
+        releaseLock();
+    }
 }
 async function processDetectionQueue(wctx, api, eventLog) {
     const logger = api.logger;
@@ -213,6 +340,11 @@ function processPromotion(wctx, logger, eventLog) {
                 if (commonPhrases.length > 0) {
                     const phrase = commonPhrases[0];
                     const ruleId = `P_PROMOTED_${fingerprint.toUpperCase()}`;
+                    if (hasEquivalentPromotedRule(dictionary, phrase)) {
+                        cand.status = 'duplicate';
+                        logger?.info?.(`[PD:EvolutionWorker] Skipping duplicate promoted rule for candidate ${fingerprint}: ${phrase}`);
+                        continue;
+                    }
                     if (logger)
                         logger.info(`[PD:EvolutionWorker] Promoting candidate ${fingerprint} to formal rule: ${ruleId}`);
                     SystemLogger.log(wctx.workspaceDir, 'RULE_PROMOTED', `Candidate ${fingerprint} promoted to rule ${ruleId}`);

package/dist/service/trajectory-service.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginService } from '../openclaw-sdk.js';
+export declare const TrajectoryService: OpenClawPluginService;

package/dist/service/trajectory-service.js

@@ -0,0 +1,15 @@
+import { TrajectoryRegistry } from '../core/trajectory.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+export const TrajectoryService = {
+    id: 'principles-disciple-trajectory',
+    start(ctx) {
+        if (!ctx.workspaceDir)
+            return;
+        WorkspaceContext.fromHookContext(ctx).trajectory;
+    },
+    stop(ctx) {
+        if (!ctx.workspaceDir)
+            return;
+        TrajectoryRegistry.dispose(ctx.workspaceDir);
+    },
+};

package/dist/tools/agent-spawn.d.ts

@@ -6,22 +6,43 @@
  */
 import type { OpenClawPluginApi } from '../openclaw-sdk.js';
 /**
- * Agent Spawn Tool definition
+ * Create Agent Spawn Tool
+ *
+ * Uses factory pattern to capture `api` in closure, following OpenClaw plugin SDK conventions.
+ * The execute signature must be: async (_toolCallId: string, rawParams: Record<string, unknown>)
  */
-export declare const agentSpawnTool: {
+export declare function createAgentSpawnTool(api: OpenClawPluginApi): {
     name: string;
     description: string;
     parameters: import("@sinclair/typebox").TObject<{
         agentType: import("@sinclair/typebox").TString;
         task: import("@sinclair/typebox").TString;
+        runInBackground: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     }>;
     /**
      * Execution logic for the agent spawn tool
+     *
+     * OpenClaw tool execute signature:
+     * - First parameter: _toolCallId (string) - the tool call ID
+     * - Second parameter: rawParams (Record<string, unknown>) - the actual parameters
+     * - Third parameter (optional): signal (AbortSignal) - for cancellation
      */
-    execute(params: {
-        agentType: string;
-        task: string;
-    }, api: OpenClawPluginApi, _workspaceDir?: string): Promise<string>;
+    execute(_toolCallId: string, rawParams: Record<string, unknown>): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+};
+export declare const agentSpawnTool: {
+    name: string;
+    description: string;
+    parameters: import("@sinclair/typebox").TObject<{
+        agentType: import("@sinclair/typebox").TString;
+        task: import("@sinclair/typebox").TString;
+        runInBackground: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>;
+    execute: () => never;
 };
 /**
  * Batch spawn multiple agents in sequence