@haaaiawd/second-nature 0.1.39 → 0.1.41

package/runtime/dream/dream-scheduler.js

@@ -1,131 +1,131 @@
-/**
- * Dream Scheduler
- *
- * Core logic: trigger Dream runs via cron schedule, evidence threshold, or manual
- * request. Uses DreamRunLock to prevent concurrent runs on the same workspace/input
- * window. Operator timeout is enforced via options in the engine call.
- *
- * - Cron: simplified — checks if a scheduled window is due (last run + interval).
- * - Evidence threshold: triggers when evidence count exceeds threshold since last run.
- * - Manual: always allowed if no active lock.
- * - Lock: in-memory or port-backed; released after run completes or times out.
- * Test coverage: tests/integration/dream/t7-1-2-dream-scheduler.test.ts
- */
-import { runDream } from "./dream-engine.js";
-const DEFAULT_LOCK_TTL_MS = 35 * 60 * 1000; // 35 min (covers 30 min operator timeout + buffer)
-// In-memory lock fallback when no lockPort is provided
-export function memoryLockPort() {
-    const locks = new Map();
-    return {
-        async acquireLock(input) {
-            const key = input.windowKey;
-            const existing = locks.get(key);
-            if (existing && existing.expiresAt > Date.now()) {
-                return { acquired: false, existingRunId: existing.runId };
-            }
-            locks.set(key, {
-                runId: input.runId,
-                expiresAt: Date.now() + input.ttlMs,
-            });
-            return { acquired: true };
-        },
-        async releaseLock(input) {
-            const key = input.windowKey;
-            const existing = locks.get(key);
-            if (existing && existing.runId === input.runId) {
-                locks.delete(key);
-            }
-        },
-    };
-}
-export async function scheduleDream(input) {
-    const lock = input.lockPort ?? memoryLockPort();
-    const windowKey = input.windowKey ?? "dream_lock:default";
-    // Acquire lock
-    const lockResult = await lock.acquireLock({
-        runId: input.runId,
-        windowKey,
-        ttlMs: DEFAULT_LOCK_TTL_MS,
-    });
-    if (!lockResult.acquired) {
-        const reason = input.triggerKind === "quiet_completion"
-            ? "skip:lock_held"
-            : `lock_held_by:${lockResult.existingRunId ?? "unknown"}`;
-        return {
-            runId: input.runId,
-            status: "skipped",
-            reason,
-        };
-    }
-    // Run Dream asynchronously; do not await so heartbeat is not blocked
-    runDream({
-        runId: input.runId,
-        traceId: input.traceId,
-        triggerKind: input.triggerKind,
-        statePort: input.statePort,
-        modelPort: input.modelPort,
-        modelAssistPort: input.modelAssistPort,
-        tracePort: input.tracePort,
-        budgetPort: input.budgetPort,
-        options: input.options,
-    })
-        .then(async (result) => {
-        await lock.releaseLock({ runId: input.runId, windowKey });
-        return result;
-    })
-        .catch(async (err) => {
-        console.error("[dream-scheduler] runDream failed:", err);
-        await lock.releaseLock({ runId: input.runId, windowKey });
-    });
-    return {
-        runId: input.runId,
-        status: "started",
-    };
-}
-function isHourInWindow(hour, start, end) {
-    if (start < end) {
-        return hour >= start && hour < end;
-    }
-    return hour >= start || hour < end;
-}
-export function shouldTrigger(policy) {
-    switch (policy.type) {
-        case "cron": {
-            if (!policy.lastRunAt) {
-                return { shouldRun: true, reason: "first_run" };
-            }
-            const last = new Date(policy.lastRunAt).getTime();
-            const next = last + policy.intervalHours * 60 * 60 * 1000;
-            if (Date.now() >= next) {
-                return { shouldRun: true, reason: "cron_due" };
-            }
-            return {
-                shouldRun: false,
-                reason: `next_run_at:${new Date(next).toISOString()}`,
-            };
-        }
-        case "evidence_threshold": {
-            const delta = policy.currentEvidenceCount - policy.lastRunEvidenceCount;
-            if (delta >= policy.threshold) {
-                return {
-                    shouldRun: true,
-                    reason: `threshold_reached:${delta}/${policy.threshold}`,
-                };
-            }
-            return {
-                shouldRun: false,
-                reason: `below_threshold:${delta}/${policy.threshold}`,
-            };
-        }
-        case "manual": {
-            return { shouldRun: true, reason: "manual_trigger" };
-        }
-        case "quiet_completion": {
-            const hour = new Date(policy.quietCompletedAt).getUTCHours();
-            if (isHourInWindow(hour, policy.windowStartHour, policy.windowEndHour)) {
-                return { shouldRun: true, reason: "quiet_completion_in_window" };
-            }
-            return { shouldRun: false, reason: "skip:out_of_window" };
-        }
-    }
-}
+/**
+ * Dream Scheduler
+ *
+ * Core logic: trigger Dream runs via cron schedule, evidence threshold, or manual
+ * request. Uses DreamRunLock to prevent concurrent runs on the same workspace/input
+ * window. Operator timeout is enforced via options in the engine call.
+ *
+ * - Cron: simplified — checks if a scheduled window is due (last run + interval).
+ * - Evidence threshold: triggers when evidence count exceeds threshold since last run.
+ * - Manual: always allowed if no active lock.
+ * - Lock: in-memory or port-backed; released after run completes or times out.
+ * Test coverage: tests/integration/dream/t7-1-2-dream-scheduler.test.ts
+ */
+import { runDream } from "./dream-engine.js";
+const DEFAULT_LOCK_TTL_MS = 35 * 60 * 1000; // 35 min (covers 30 min operator timeout + buffer)
+// In-memory lock fallback when no lockPort is provided
+export function memoryLockPort() {
+    const locks = new Map();
+    return {
+        async acquireLock(input) {
+            const key = input.windowKey;
+            const existing = locks.get(key);
+            if (existing && existing.expiresAt > Date.now()) {
+                return { acquired: false, existingRunId: existing.runId };
+            }
+            locks.set(key, {
+                runId: input.runId,
+                expiresAt: Date.now() + input.ttlMs,
+            });
+            return { acquired: true };
+        },
+        async releaseLock(input) {
+            const key = input.windowKey;
+            const existing = locks.get(key);
+            if (existing && existing.runId === input.runId) {
+                locks.delete(key);
+            }
+        },
+    };
+}
+export async function scheduleDream(input) {
+    const lock = input.lockPort ?? memoryLockPort();
+    const windowKey = input.windowKey ?? "dream_lock:default";
+    // Acquire lock
+    const lockResult = await lock.acquireLock({
+        runId: input.runId,
+        windowKey,
+        ttlMs: DEFAULT_LOCK_TTL_MS,
+    });
+    if (!lockResult.acquired) {
+        const reason = input.triggerKind === "quiet_completion"
+            ? "skip:lock_held"
+            : `lock_held_by:${lockResult.existingRunId ?? "unknown"}`;
+        return {
+            runId: input.runId,
+            status: "skipped",
+            reason,
+        };
+    }
+    // Run Dream asynchronously; do not await so heartbeat is not blocked
+    runDream({
+        runId: input.runId,
+        traceId: input.traceId,
+        triggerKind: input.triggerKind,
+        statePort: input.statePort,
+        modelPort: input.modelPort,
+        modelAssistPort: input.modelAssistPort,
+        tracePort: input.tracePort,
+        budgetPort: input.budgetPort,
+        options: input.options,
+    })
+        .then(async (result) => {
+        await lock.releaseLock({ runId: input.runId, windowKey });
+        return result;
+    })
+        .catch(async (err) => {
+        console.error("[dream-scheduler] runDream failed:", err);
+        await lock.releaseLock({ runId: input.runId, windowKey });
+    });
+    return {
+        runId: input.runId,
+        status: "started",
+    };
+}
+function isHourInWindow(hour, start, end) {
+    if (start < end) {
+        return hour >= start && hour < end;
+    }
+    return hour >= start || hour < end;
+}
+export function shouldTrigger(policy) {
+    switch (policy.type) {
+        case "cron": {
+            if (!policy.lastRunAt) {
+                return { shouldRun: true, reason: "first_run" };
+            }
+            const last = new Date(policy.lastRunAt).getTime();
+            const next = last + policy.intervalHours * 60 * 60 * 1000;
+            if (Date.now() >= next) {
+                return { shouldRun: true, reason: "cron_due" };
+            }
+            return {
+                shouldRun: false,
+                reason: `next_run_at:${new Date(next).toISOString()}`,
+            };
+        }
+        case "evidence_threshold": {
+            const delta = policy.currentEvidenceCount - policy.lastRunEvidenceCount;
+            if (delta >= policy.threshold) {
+                return {
+                    shouldRun: true,
+                    reason: `threshold_reached:${delta}/${policy.threshold}`,
+                };
+            }
+            return {
+                shouldRun: false,
+                reason: `below_threshold:${delta}/${policy.threshold}`,
+            };
+        }
+        case "manual": {
+            return { shouldRun: true, reason: "manual_trigger" };
+        }
+        case "quiet_completion": {
+            const hour = new Date(policy.quietCompletedAt).getUTCHours();
+            if (isHourInWindow(hour, policy.windowStartHour, policy.windowEndHour)) {
+                return { shouldRun: true, reason: "quiet_completion_in_window" };
+            }
+            return { shouldRun: false, reason: "skip:out_of_window" };
+        }
+    }
+}

package/runtime/dream/index.d.ts

@@ -1,16 +1,16 @@
-/**
- * Dream System public API.
- */
-export * from "./types.js";
-export { consolidateMemory } from "./memory-consolidator.js";
-export { sampleDreamInput } from "./sampler.js";
-export { redactDreamInput, redactBundle } from "./redaction-gate.js";
-export { validateDreamOutput } from "./output-validator.js";
-export { runDream } from "./dream-engine.js";
-export { scheduleDream, shouldTrigger, memoryLockPort } from "./dream-scheduler.js";
-export type { SchedulerInput, DreamRunLockPort, ScheduleResult, CronPolicy, EvidenceThresholdPolicy, ManualPolicy, QuietCompletionPolicy, TriggerPolicy } from "./dream-scheduler.js";
-export { extractInsights } from "./insight-extractor.js";
-export { draftNarrativeFromDream } from "./narrative-update-proposal.js";
-export { draftRelationshipFromDream } from "./relationship-update-proposal.js";
-export { createDreamInputLoader } from "./dream-input-loader.js";
-export type { DreamInputLoaderOptions } from "./dream-input-loader.js";
+/**
+ * Dream System public API.
+ */
+export * from "./types.js";
+export { consolidateMemory } from "./memory-consolidator.js";
+export { sampleDreamInput } from "./sampler.js";
+export { redactDreamInput, redactBundle } from "./redaction-gate.js";
+export { validateDreamOutput } from "./output-validator.js";
+export { runDream } from "./dream-engine.js";
+export { scheduleDream, shouldTrigger, memoryLockPort } from "./dream-scheduler.js";
+export type { SchedulerInput, DreamRunLockPort, ScheduleResult, CronPolicy, EvidenceThresholdPolicy, ManualPolicy, QuietCompletionPolicy, TriggerPolicy } from "./dream-scheduler.js";
+export { extractInsights } from "./insight-extractor.js";
+export { draftNarrativeFromDream } from "./narrative-update-proposal.js";
+export { draftRelationshipFromDream } from "./relationship-update-proposal.js";
+export { createDreamInputLoader } from "./dream-input-loader.js";
+export type { DreamInputLoaderOptions } from "./dream-input-loader.js";

package/runtime/dream/index.js

@@ -1,14 +1,14 @@
-/**
- * Dream System public API.
- */
-export * from "./types.js";
-export { consolidateMemory } from "./memory-consolidator.js";
-export { sampleDreamInput } from "./sampler.js";
-export { redactDreamInput, redactBundle } from "./redaction-gate.js";
-export { validateDreamOutput } from "./output-validator.js";
-export { runDream } from "./dream-engine.js";
-export { scheduleDream, shouldTrigger, memoryLockPort } from "./dream-scheduler.js";
-export { extractInsights } from "./insight-extractor.js";
-export { draftNarrativeFromDream } from "./narrative-update-proposal.js";
-export { draftRelationshipFromDream } from "./relationship-update-proposal.js";
-export { createDreamInputLoader } from "./dream-input-loader.js";
+/**
+ * Dream System public API.
+ */
+export * from "./types.js";
+export { consolidateMemory } from "./memory-consolidator.js";
+export { sampleDreamInput } from "./sampler.js";
+export { redactDreamInput, redactBundle } from "./redaction-gate.js";
+export { validateDreamOutput } from "./output-validator.js";
+export { runDream } from "./dream-engine.js";
+export { scheduleDream, shouldTrigger, memoryLockPort } from "./dream-scheduler.js";
+export { extractInsights } from "./insight-extractor.js";
+export { draftNarrativeFromDream } from "./narrative-update-proposal.js";
+export { draftRelationshipFromDream } from "./relationship-update-proposal.js";
+export { createDreamInputLoader } from "./dream-input-loader.js";

package/runtime/dream/insight-extractor.d.ts

@@ -1,32 +1,32 @@
-/**
- * Insight Extractor
- *
- * Core logic: extract source-grounded insight candidates from sampled evidence.
- * Rules-based (no LLM required) using keyword patterns, frequency counts, and
- * temporal clustering. Each insight carries type, summary, sourceRefs, and confidence.
- *
- * - Pattern: recurring themes across multiple evidence entries.
- * - Learning: new skills or behaviors observed over time.
- * - Observation: one-off notable events.
- * - Conflict: contradictory claims or repeated failures.
- * Test coverage: tests/unit/dream/t7-1-3-insight-extraction.test.ts
- */
-import type { DreamInsight } from "./types.js";
-export interface ExtractInsightsInput {
-    evidenceSummaries: Array<{
-        id: string;
-        summary: string;
-        createdAt: string;
-        kind?: string;
-    }>;
-    chronicleSummaries: Array<{
-        id: string;
-        summary: string;
-        createdAt: string;
-    }>;
-    redacted?: boolean;
-}
-export declare function extractInsights(input: ExtractInsightsInput): {
-    insights: DreamInsight[];
-    unsupportedClaims: string[];
-};
+/**
+ * Insight Extractor
+ *
+ * Core logic: extract source-grounded insight candidates from sampled evidence.
+ * Rules-based (no LLM required) using keyword patterns, frequency counts, and
+ * temporal clustering. Each insight carries type, summary, sourceRefs, and confidence.
+ *
+ * - Pattern: recurring themes across multiple evidence entries.
+ * - Learning: new skills or behaviors observed over time.
+ * - Observation: one-off notable events.
+ * - Conflict: contradictory claims or repeated failures.
+ * Test coverage: tests/unit/dream/t7-1-3-insight-extraction.test.ts
+ */
+import type { DreamInsight } from "./types.js";
+export interface ExtractInsightsInput {
+    evidenceSummaries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+        kind?: string;
+    }>;
+    chronicleSummaries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+    }>;
+    redacted?: boolean;
+}
+export declare function extractInsights(input: ExtractInsightsInput): {
+    insights: DreamInsight[];
+    unsupportedClaims: string[];
+};