principles-disciple 1.6.0 → 1.7.0

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);
@@ -116,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;
@@ -215,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