@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/events/event_loop.js

@@ -1,140 +1,141 @@
-import * as path from "node:path";
-import crypto from "node:crypto";
-import { startFileWatcher } from "./file_watcher.js";
-import { processEvent } from "./processor.js";
-import { DEFAULT_EVENT_COOLDOWN_MS, DEFAULT_EVENT_DEDUP_BUCKET_MS, DEFAULT_EVENT_MAX_RETRY, DEFAULT_EVENT_RETRY_BACKOFF_MS, DEFAULT_MQ_RETRY_MS, ENV_FLAGS, envFlag, envInt, envStr, } from "./constants.js";
-import { toPosixPath, resolveRelativePosix } from "../path-utils.js";
-import { getVibeDir, getPmRunsDir, getEngineRunsDir, getLegacyRunsDir } from "../paths.js";
-import { appendEventLog } from "./logger.js";
-import { DedupCooldown } from "./dedup_cooldown.js";
-import { refreshNavAndState } from "./nav_refresh.js";
-import { createMQ } from "./mq.js";
-import { createNatsClient } from "./mq_nats.js";
-import { createRedisClient } from "./mq_redis.js";
-const SELF_COMPONENT = "kernel";
+import { logger } from '../../shared/logger.js';
+import * as path from 'node:path';
+import crypto from 'node:crypto';
+import { startFileWatcher } from '../../kernel/file_watcher.js';
+import { processEvent } from './processor.js';
+import { DEFAULT_EVENT_COOLDOWN_MS, DEFAULT_EVENT_DEDUP_BUCKET_MS, DEFAULT_EVENT_MAX_RETRY, DEFAULT_EVENT_RETRY_BACKOFF_MS, DEFAULT_MQ_RETRY_MS, ENV_FLAGS, envFlag, envInt, envStr, } from './constants.js';
+import { toPosixPath, resolveRelativePosix } from '../path-utils.js';
+import { getVibeDir, getPmRunsDir, getEngineRunsDir, getLegacyRunsDir, } from '../../kernel/paths.js';
+import { appendEventLog } from './logger.js';
+import { refreshNavAndState } from './nav_refresh.js';
+import { createMQ } from './mq.js';
+import { createNatsClient } from './mq_nats.js';
+import { createRedisClient } from './mq_redis.js';
+import { getOrCreateDedupCooldown } from './dedup_registry.js';
+const SELF_COMPONENT = 'kernel';
 function randomId() {
     return crypto.randomUUID();
 }
 export function classifyEventType(filePath) {
     const p = toPosixPath(filePath.toLowerCase());
-    const segments = p.split("/").filter(Boolean);
-    const filename = segments[segments.length - 1] ?? "";
+    const segments = p.split('/').filter(Boolean);
+    const filename = segments[segments.length - 1] ?? '';
     const has = (seg) => segments.includes(seg);
-    if (has("results"))
-        return { type: "artifact.result_written", reason: "file_change" };
-    if (has("mapping"))
-        return { type: "artifact.mapping_written", reason: "file_change" };
-    if (has("airlock") && filename === "redaction_report.json") {
-        return { type: "artifact.airlock_report_written", reason: "file_change" };
+    if (has('results'))
+        return { type: 'artifact.result_written', reason: 'file_change' };
+    if (has('mapping'))
+        return { type: 'artifact.mapping_written', reason: 'file_change' };
+    if (has('airlock') && filename === 'redaction_report.json') {
+        return { type: 'artifact.airlock_report_written', reason: 'file_change' };
     }
-    if (has("airlock") && filename === "safe_context.txt") {
-        return { type: "artifact.airlock_safe_context_written", reason: "file_change" };
+    if (has('airlock') && filename === 'safe_context.txt') {
+        return { type: 'artifact.airlock_safe_context_written', reason: 'file_change' };
     }
-    if (has("airlock") && filename === "input_fingerprint.json") {
-        return { type: "artifact.airlock_fingerprint_written", reason: "file_change" };
+    if (has('airlock') && filename === 'input_fingerprint.json') {
+        return { type: 'artifact.airlock_fingerprint_written', reason: 'file_change' };
     }
-    if (has("chunks") && filename === "chunk_manifest.v1.json") {
-        return { type: "artifact.chunk_manifest_written", reason: "file_change" };
+    if (has('chunks') && filename === 'chunk_manifest.v1.json') {
+        return { type: 'artifact.chunk_manifest_written', reason: 'file_change' };
     }
-    if (has("chunks") && filename === "chunk_summary.md") {
-        return { type: "artifact.chunk_summary_written", reason: "file_change" };
+    if (has('chunks') && filename === 'chunk_summary.md') {
+        return { type: 'artifact.chunk_summary_written', reason: 'file_change' };
     }
-    if (has("chunks") && filename.startsWith("chk_") && filename.endsWith(".json")) {
-        return { type: "artifact.chunk_written", reason: "file_change" };
+    if (has('chunks') && filename.startsWith('chk_') && filename.endsWith('.json')) {
+        return { type: 'artifact.chunk_written', reason: 'file_change' };
     }
-    if (has("handoff") && (filename.includes("work_order") || filename.includes("clinic_bridge"))) {
-        return { type: "artifact.work_order_updated", reason: "file_change" };
+    if (has('handoff') && (filename.includes('work_order') || filename.includes('clinic_bridge'))) {
+        return { type: 'artifact.work_order_updated', reason: 'file_change' };
     }
-    if (has("intent"))
-        return { type: "artifact.intent_generated", reason: "file_change" };
-    if (has("spec") || has("05_spec") || filename === "atomic_specs.json") {
-        return { type: "artifact.spec_generated", reason: "file_change" };
+    if (has('intent'))
+        return { type: 'artifact.intent_generated', reason: 'file_change' };
+    if (has('spec') || has('05_spec') || filename === 'atomic_specs.json') {
+        return { type: 'artifact.spec_generated', reason: 'file_change' };
     }
-    if (has("plan") || has("10_plan") || filename === "plan.json") {
-        return { type: "artifact.plan_updated", reason: "file_change" };
+    if (has('plan') || has('10_plan') || filename === 'plan.json') {
+        return { type: 'artifact.plan_updated', reason: 'file_change' };
     }
-    if (filename.includes("work_order"))
-        return { type: "artifact.work_order_updated", reason: "file_change" };
-    return { type: "artifact.file_changed", reason: "file_change" };
+    if (filename.includes('work_order'))
+        return { type: 'artifact.work_order_updated', reason: 'file_change' };
+    return { type: 'artifact.file_changed', reason: 'file_change' };
 }
 export function detectRunId(workspaceRoot, filePath) {
-    const segments = toPosixPath(path.resolve(filePath)).split("/");
+    const segments = toPosixPath(path.resolve(filePath)).split('/');
     const root = toPosixPath(path.resolve(workspaceRoot));
     const rel = toPosixPath(path.relative(root, path.resolve(filePath)));
     // .vibe/runs/<run_id>
-    const vibeIdx = rel.split("/").indexOf(".vibe");
+    const vibeIdx = rel.split('/').indexOf('.vibe');
     if (vibeIdx >= 0) {
-        const parts = rel.split("/");
-        const runIdx = parts.indexOf("runs");
+        const parts = rel.split('/');
+        const runIdx = parts.indexOf('runs');
         if (runIdx >= 0 && parts[runIdx + 1])
             return parts[runIdx + 1];
     }
     // engines/spec_high/runs/<run_id>
-    if (rel.includes("engines/spec_high/runs")) {
-        const parts = rel.split("/");
-        const runIdx = parts.indexOf("runs");
+    if (rel.includes('engines/spec_high/runs')) {
+        const parts = rel.split('/');
+        const runIdx = parts.indexOf('runs');
         if (runIdx >= 0 && parts[runIdx + 1])
             return parts[runIdx + 1];
     }
     // legacy runs/<run_id>
-    const parts = rel.split("/");
-    const runIdx = parts.indexOf("runs");
+    const parts = rel.split('/');
+    const runIdx = parts.indexOf('runs');
     if (runIdx >= 0 && parts[runIdx + 1])
         return parts[runIdx + 1];
-    return "unknown";
+    return 'unknown';
 }
 function buildEventRecord(workspaceRoot, filePath) {
     const { type, reason } = classifyEventType(filePath);
     const runId = detectRunId(workspaceRoot, filePath);
     const rel = resolveRelativePosix(workspaceRoot, path.resolve(filePath));
     return {
-        schema_version: "event.v1",
+        schema_version: 'event.v1',
         event_id: randomId(),
         ts: new Date().toISOString(),
         run_id: runId,
         type,
         reason,
-        source: { actor: "system", component: SELF_COMPONENT, host: path.basename(workspaceRoot) },
+        source: { actor: 'system', component: SELF_COMPONENT, host: path.basename(workspaceRoot) },
         refs: { paths: [rel] },
         dedup: { bucket_ms: envInt(ENV_FLAGS.EVENT_DEDUP_BUCKET_MS, DEFAULT_EVENT_DEDUP_BUCKET_MS) },
         note: `file=${rel}`,
     };
 }
 function getLogPath(workspaceRoot, runId) {
-    if (runId && runId !== "unknown") {
-        return path.join(getVibeDir(workspaceRoot), "runs", runId, "events.jsonl");
+    if (runId && runId !== 'unknown') {
+        return path.join(getVibeDir(workspaceRoot), 'runs', runId, 'events.jsonl');
     }
-    return path.join(getVibeDir(workspaceRoot), "logs", "events.global.jsonl");
+    return path.join(getVibeDir(workspaceRoot), 'logs', 'events.global.jsonl');
 }
 export function startEventLoop(workspaceRoot) {
     const enableWatcher = envFlag(ENV_FLAGS.ENABLE_FILE_WATCHER) ||
         process.env[ENV_FLAGS.ENABLE_FILE_WATCHER] === undefined; // default ON
     const enableEventBus = envFlag(ENV_FLAGS.ENABLE_EVENT_BUS);
     const enableGlobalEvents = envFlag(ENV_FLAGS.ENABLE_GLOBAL_EVENTS);
-    const mqProvider = (process.env[ENV_FLAGS.MQ_PROVIDER] ?? "none").toLowerCase();
-    const mqUrl = envStr(ENV_FLAGS.MQ_URL, "");
+    const mqProvider = (process.env[ENV_FLAGS.MQ_PROVIDER] ?? 'none').toLowerCase();
+    const mqUrl = envStr(ENV_FLAGS.MQ_URL, '');
     let mqClient = null;
     let mqRetryTimer = null;
     // Initialize optional MQ
-    if (enableEventBus && mqProvider !== "none") {
+    if (enableEventBus && mqProvider !== 'none') {
         const retryMs = envInt(ENV_FLAGS.MQ_RETRY_MS, DEFAULT_MQ_RETRY_MS);
         const initMq = async () => {
             try {
-                if (mqProvider === "nats") {
-                    mqClient = await createNatsClient({ servers: mqUrl || "nats://127.0.0.1:4222" });
+                if (mqProvider === 'nats') {
+                    mqClient = await createNatsClient({ servers: mqUrl || 'nats://127.0.0.1:4222' });
                 }
-                else if (mqProvider === "redis") {
-                    mqClient = await createRedisClient(mqUrl || "redis://127.0.0.1:6379");
+                else if (mqProvider === 'redis') {
+                    mqClient = await createRedisClient(mqUrl || 'redis://127.0.0.1:6379');
                 }
                 else {
-                    mqClient = createMQ("none");
+                    mqClient = createMQ('none');
                 }
                 if (!mqClient) {
-                    throw new Error("MQ client unavailable");
+                    throw new Error('MQ client unavailable');
                 }
             }
             catch (e) {
-                console.error(`[event_loop] MQ init failed: ${e instanceof Error ? e.message : String(e)}`);
+                logger.error(`[event_loop] MQ init failed: ${e instanceof Error ? e.message : String(e)}`);
                 if (!mqRetryTimer) {
                     mqRetryTimer = setTimeout(() => {
                         mqRetryTimer = null;
@@ -153,35 +154,39 @@ export function startEventLoop(workspaceRoot) {
             },
         };
     }
-    const paths = [getPmRunsDir(workspaceRoot), getEngineRunsDir(workspaceRoot), getLegacyRunsDir(workspaceRoot)];
-    const dedup = new DedupCooldown(envInt(ENV_FLAGS.EVENT_DEDUP_BUCKET_MS, DEFAULT_EVENT_DEDUP_BUCKET_MS), envInt(ENV_FLAGS.EVENT_COOLDOWN_MS, DEFAULT_EVENT_COOLDOWN_MS));
+    const paths = [
+        getPmRunsDir(workspaceRoot),
+        getEngineRunsDir(workspaceRoot),
+        getLegacyRunsDir(workspaceRoot),
+    ];
+    const dedup = getOrCreateDedupCooldown(`event_loop:${path.resolve(workspaceRoot)}`, envInt(ENV_FLAGS.EVENT_DEDUP_BUCKET_MS, DEFAULT_EVENT_DEDUP_BUCKET_MS), envInt(ENV_FLAGS.EVENT_COOLDOWN_MS, DEFAULT_EVENT_COOLDOWN_MS));
     const watcher = startFileWatcher(paths, {
         cwd: workspaceRoot,
         ignore: (fullPath) => {
             const p = toPosixPath(fullPath);
             // ignore self-written/control files
-            if (p.includes("/run_state.v1.json"))
+            if (p.includes('/run_state.v1.json'))
                 return true;
-            if (p.endsWith("/events.jsonl"))
+            if (p.endsWith('/events.jsonl'))
                 return true;
-            if (p.includes("/observer/heartbeat.json"))
+            if (p.includes('/observer/heartbeat.json'))
                 return true;
-            if (p.endsWith("/nav.json"))
+            if (p.endsWith('/nav.json'))
                 return true;
             return false;
         },
         onEvent: (type, changedPath) => {
-            if (type === "unlink")
+            if (type === 'unlink')
                 return; // ignore deletes for now
             const ev = buildEventRecord(workspaceRoot, changedPath);
-            if (ev.run_id === "unknown" && !enableGlobalEvents) {
+            if (ev.run_id === 'unknown' && !enableGlobalEvents) {
                 return;
             }
             const logPath = getLogPath(workspaceRoot, ev.run_id);
             // Self paths: run_state/nav writes by kernel should not re-trigger
             const selfPaths = new Set([
-                resolveRelativePosix(workspaceRoot, path.join(getVibeDir(workspaceRoot), "runs", ev.run_id, "run_state.v1.json")),
-                resolveRelativePosix(workspaceRoot, path.join(getVibeDir(workspaceRoot), "runs", ev.run_id, "nav.json")),
+                resolveRelativePosix(workspaceRoot, path.join(getVibeDir(workspaceRoot), 'runs', ev.run_id, 'run_state.v1.json')),
+                resolveRelativePosix(workspaceRoot, path.join(getVibeDir(workspaceRoot), 'runs', ev.run_id, 'nav.json')),
             ]);
             processEvent(ev, {
                 logPath,
@@ -189,37 +194,37 @@ export function startEventLoop(workspaceRoot) {
                 selfComponent: SELF_COMPONENT,
                 selfPaths,
                 workspaceRoot,
-                allowUnknownRun: ev.run_id === "unknown" && enableGlobalEvents,
+                allowUnknownRun: ev.run_id === 'unknown' && enableGlobalEvents,
                 maxRetry: envInt(ENV_FLAGS.EVENT_MAX_RETRY, DEFAULT_EVENT_MAX_RETRY),
                 retryBackoffMs: envInt(ENV_FLAGS.EVENT_RETRY_BACKOFF_MS, DEFAULT_EVENT_RETRY_BACKOFF_MS),
                 onHandle: async () => {
-                    if (ev.run_id === "unknown")
+                    if (ev.run_id === 'unknown')
                         return;
                     const res = await refreshNavAndState(workspaceRoot, ev.run_id);
                     const navSignal = {
-                        schema_version: "event.v1",
+                        schema_version: 'event.v1',
                         event_id: randomId(),
                         ts: new Date().toISOString(),
                         run_id: ev.run_id,
-                        type: "signal.nav_updated",
-                        reason: "nav_refreshed",
-                        source: { actor: "system", component: SELF_COMPONENT },
+                        type: 'signal.nav_updated',
+                        reason: 'nav_refreshed',
+                        source: { actor: 'system', component: SELF_COMPONENT },
                         refs: { paths: [res.run_state_path, res.nav_path] },
                         note: `actions=${res.actions_count}`,
                     };
                     appendEventLog(getLogPath(workspaceRoot, ev.run_id), {
-                        status: "handled",
+                        status: 'handled',
                         event: navSignal,
                         ts: new Date().toISOString(),
-                        message: "nav refreshed",
+                        message: 'nav refreshed',
                     });
                     if (mqClient) {
                         await mqClient.publish(navSignal);
                     }
                 },
-            }).catch((err) => {
+            }).catch(err => {
                 appendEventLog(logPath, {
-                    status: "failed_parse",
+                    status: 'failed_parse',
                     event: ev,
                     ts: new Date().toISOString(),
                     message: err instanceof Error ? err.message : String(err),
@@ -242,7 +247,7 @@ export function startEventLoop(workspaceRoot) {
                 await mqClient.close();
         },
         status() {
-            return { watching: true, paths: paths.map((p) => path.resolve(p)) };
+            return { watching: true, paths: paths.map(p => path.resolve(p)) };
         },
     };
 }

package/build/mcp/events/index.d.ts

@@ -1,11 +1,10 @@
-export * from "./constants.js";
-export * from "./types.js";
-export * from "./dedup_cooldown.js";
-export * from "./logger.js";
-export * from "./processor.js";
-export * from "./file_watcher.js";
-export * from "./event_loop.js";
-export * from "./nav_refresh.js";
-export * from "./mq.js";
-export * from "./emitter.js";
-export * from "./replay.js";
+export * from './constants.js';
+export * from './types.js';
+export * from './dedup_cooldown.js';
+export * from './logger.js';
+export * from './processor.js';
+export * from './event_loop.js';
+export * from './nav_refresh.js';
+export * from './mq.js';
+export * from './emitter.js';
+export * from './replay.js';

package/build/mcp/events/index.js

@@ -1,11 +1,10 @@
-export * from "./constants.js";
-export * from "./types.js";
-export * from "./dedup_cooldown.js";
-export * from "./logger.js";
-export * from "./processor.js";
-export * from "./file_watcher.js";
-export * from "./event_loop.js";
-export * from "./nav_refresh.js";
-export * from "./mq.js";
-export * from "./emitter.js";
-export * from "./replay.js";
+export * from './constants.js';
+export * from './types.js';
+export * from './dedup_cooldown.js';
+export * from './logger.js';
+export * from './processor.js';
+export * from './event_loop.js';
+export * from './nav_refresh.js';
+export * from './mq.js';
+export * from './emitter.js';
+export * from './replay.js';

package/build/mcp/events/mq.d.ts

@@ -5,6 +5,7 @@ export interface MQClient {
     close(): Promise<void>;
 }
 /**
- * Stub factory for MQ client (optional). Real MQ to be wired later.
+ * Stub factory for MQ client. Returns NoopMQ for all providers.
+ * DEFERRED: wire real nats/redis when event streaming is needed.
  */
 export declare function createMQ(provider: MQProvider): MQClient;

package/build/mcp/events/mq.js

@@ -7,13 +7,13 @@ class NoopMQ {
     }
 }
 /**
- * Stub factory for MQ client (optional). Real MQ to be wired later.
+ * Stub factory for MQ client. Returns NoopMQ for all providers.
+ * DEFERRED: wire real nats/redis when event streaming is needed.
  */
 export function createMQ(provider) {
     switch (provider) {
         case "nats":
         case "redis":
-            // TODO: implement real providers
             return new NoopMQ();
         case "none":
         default:

package/build/mcp/events/mq_nats.js

@@ -1,9 +1,10 @@
+import { logger } from "../../shared/logger.js";
 export async function createNatsClient(_opts) {
     try {
         const nats = await import("nats");
         const sc = nats.StringCodec();
         const conn = await nats.connect(_opts);
-        const subject = _opts.name ?? "vibe.events";
+        const subject = typeof _opts.name === "string" ? _opts.name : "vibe.events";
         return {
             async publish(ev) {
                 conn.publish(subject, sc.encode(JSON.stringify(ev)));
@@ -14,7 +15,7 @@ export async function createNatsClient(_opts) {
         };
     }
     catch (e) {
-        console.error(`[mq_nats] NATS client unavailable: ${e instanceof Error ? e.message : String(e)}`);
+        logger.error(`[mq_nats] NATS client unavailable: ${e instanceof Error ? e.message : String(e)}`);
         return null;
     }
 }

package/build/mcp/events/mq_redis.js

@@ -1,3 +1,4 @@
+import { logger } from "../../shared/logger.js";
 export async function createRedisClient(url) {
     try {
         const { createClient } = await import("redis");
@@ -14,7 +15,7 @@ export async function createRedisClient(url) {
         };
     }
     catch (e) {
-        console.error(`[mq_redis] Redis client unavailable: ${e instanceof Error ? e.message : String(e)}`);
+        logger.error(`[mq_redis] Redis client unavailable: ${e instanceof Error ? e.message : String(e)}`);
         return null;
     }
 }

package/build/mcp/events/nav_refresh.js

@@ -1,10 +1,10 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { collectFacts } from "../tools/vibe_pm/facts/index.js";
-import { readScorecard } from "../tools/vibe_pm/scorecard/index.js";
-import { resolveNextActions } from "../tools/vibe_pm/navigation/index.js";
-import { getPmRunDir, getVibeDir } from "../paths.js";
-import { resolveRelativePosix } from "../path-utils.js";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { collectFacts } from '../tools/vibe_pm/facts/index.js';
+import { readScorecard } from '../tools/vibe_pm/scorecard/index.js';
+import { resolveNextActions } from '../tools/vibe_pm/navigation/index.js';
+import { getPmRunDir, getVibeDir } from '../../kernel/paths.js';
+import { resolveRelativePosix } from '../path-utils.js';
 /**
  * Minimal nav/run_state refresh for event loop.
  * - Reads facts + scorecard (best-effort)
@@ -15,15 +15,15 @@ import { resolveRelativePosix } from "../path-utils.js";
 export async function refreshNavAndState(workspaceRoot, runId) {
     const runDir = getPmRunDir(workspaceRoot, runId);
     fs.mkdirSync(runDir, { recursive: true });
-    const runStatePath = path.join(getVibeDir(workspaceRoot), "runs", runId, "run_state.v1.json");
-    const navPath = path.join(getVibeDir(workspaceRoot), "runs", runId, "nav.json");
+    const runStatePath = path.join(getVibeDir(workspaceRoot), 'runs', runId, 'run_state.v1.json');
+    const navPath = path.join(getVibeDir(workspaceRoot), 'runs', runId, 'nav.json');
     fs.mkdirSync(path.dirname(runStatePath), { recursive: true });
     // Load existing run_state to derive phase if available
-    let phase = "INTAKE";
+    let phase = 'INTAKE';
     try {
         if (fs.existsSync(runStatePath)) {
-            const raw = JSON.parse(fs.readFileSync(runStatePath, "utf-8"));
-            if (typeof raw?.phase === "string")
+            const raw = JSON.parse(fs.readFileSync(runStatePath, 'utf-8'));
+            if (typeof raw?.phase === 'string')
                 phase = raw.phase;
         }
     }
@@ -34,7 +34,7 @@ export async function refreshNavAndState(workspaceRoot, runId) {
     const scorecard = await readScorecard(workspaceRoot, runId);
     const actions = resolveNextActions(facts, scorecard, phase, false);
     const navData = {
-        schema_version: "nav.v1",
+        schema_version: 'nav.v1',
         run_id: runId,
         phase,
         generated_at: new Date().toISOString(),
@@ -45,10 +45,10 @@ export async function refreshNavAndState(workspaceRoot, runId) {
     // Ensure run_state exists minimally
     if (!fs.existsSync(runStatePath)) {
         const runState = {
-            schema_version: "run_state.v1",
+            schema_version: 'run_state.v1',
             run_id: runId,
             phase,
-            mode: "balanced",
+            mode: 'balanced',
             created_at: new Date().toISOString(),
             decisions_made: facts.ask_queue_count ? 0 : 0,
             decisions_pending: facts.ask_queue_count ?? 0,

package/build/mcp/events/processor.d.ts

@@ -1,5 +1,5 @@
-import { DedupCooldown } from "./dedup_cooldown.js";
-import type { EventRecord, EventStatus } from "./types.js";
+import { DedupCooldown } from './dedup_cooldown.js';
+import type { EventRecord, EventStatus } from './types.js';
 export interface ProcessEventOpts {
     logPath: string;
     dedup?: DedupCooldown;

package/build/mcp/events/processor.js

@@ -1,43 +1,70 @@
-import { stat } from "node:fs/promises";
-import path from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
-import { DedupCooldown } from "./dedup_cooldown.js";
-import { DEFAULT_EVENT_COOLDOWN_MS, DEFAULT_EVENT_DEDUP_BUCKET_MS, DEFAULT_EVENT_MAX_RETRY, DEFAULT_EVENT_RETRY_BACKOFF_MS, } from "./constants.js";
-import { appendEventLog } from "./logger.js";
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { DEFAULT_EVENT_COOLDOWN_MS, DEFAULT_EVENT_DEDUP_BUCKET_MS, DEFAULT_EVENT_MAX_RETRY, DEFAULT_EVENT_RETRY_BACKOFF_MS, } from './constants.js';
+import { appendEventLog } from './logger.js';
+import { getOrCreateDedupCooldown } from './dedup_registry.js';
 /**
  * Process a single event with dedup, cooldown, self-trigger guard, read-after-write.
  */
 export async function processEvent(ev, opts) {
     const now = Date.now();
-    const dedup = opts.dedup ?? new DedupCooldown(opts.dedupBucketMs ?? DEFAULT_EVENT_DEDUP_BUCKET_MS, opts.cooldownMs ?? DEFAULT_EVENT_COOLDOWN_MS);
+    const bucketMs = opts.dedupBucketMs ?? DEFAULT_EVENT_DEDUP_BUCKET_MS;
+    const cooldownMs = opts.cooldownMs ?? DEFAULT_EVENT_COOLDOWN_MS;
+    const dedup = opts.dedup ?? getOrCreateDedupCooldown(`processor:${opts.logPath}`, bucketMs, cooldownMs);
     const logPath = opts.logPath;
     // basic schema checks
     const firstPath = ev.refs?.paths?.[0];
     if (!firstPath) {
-        appendEventLog(logPath, { status: "failed_schema", event: ev, ts: new Date().toISOString(), message: "refs.paths empty" });
-        return "failed_schema";
+        appendEventLog(logPath, {
+            status: 'failed_schema',
+            event: ev,
+            ts: new Date().toISOString(),
+            message: 'refs.paths empty',
+        });
+        return 'failed_schema';
     }
-    if (!ev.run_id || ev.run_id === "unknown") {
+    if (!ev.run_id || ev.run_id === 'unknown') {
         if (!opts.allowUnknownRun) {
-            appendEventLog(logPath, { status: "failed_schema", event: ev, ts: new Date().toISOString(), message: "run_id unknown" });
-            return "failed_schema";
+            appendEventLog(logPath, {
+                status: 'failed_schema',
+                event: ev,
+                ts: new Date().toISOString(),
+                message: 'run_id unknown',
+            });
+            return 'failed_schema';
         }
     }
     // dedup / cooldown
     const skip = dedup.shouldSkip(ev, now);
-    if (skip === "dedup") {
-        appendEventLog(logPath, { status: "skipped_dedup", event: ev, ts: new Date().toISOString(), message: "duplicate" });
-        return "skipped_dedup";
+    if (skip === 'dedup') {
+        appendEventLog(logPath, {
+            status: 'skipped_dedup',
+            event: ev,
+            ts: new Date().toISOString(),
+            message: 'duplicate',
+        });
+        return 'skipped_dedup';
     }
-    if (skip === "cooldown") {
-        appendEventLog(logPath, { status: "skipped_cooldown", event: ev, ts: new Date().toISOString(), message: "cooldown" });
-        return "skipped_cooldown";
+    if (skip === 'cooldown') {
+        appendEventLog(logPath, {
+            status: 'skipped_cooldown',
+            event: ev,
+            ts: new Date().toISOString(),
+            message: 'cooldown',
+        });
+        return 'skipped_cooldown';
     }
     // self-trigger guard
     if (opts.selfComponent && ev.source.component === opts.selfComponent) {
         if (opts.selfPaths?.has(firstPath)) {
-            appendEventLog(logPath, { status: "skipped_self_trigger", event: ev, ts: new Date().toISOString(), message: "self-trigger" });
-            return "skipped_self_trigger";
+            appendEventLog(logPath, {
+                status: 'skipped_self_trigger',
+                event: ev,
+                ts: new Date().toISOString(),
+                message: 'self-trigger',
+            });
+            return 'skipped_self_trigger';
         }
     }
     // read-after-write
@@ -63,14 +90,19 @@ export async function processEvent(ev, opts) {
         }
     }
     if (!ok) {
-        appendEventLog(logPath, { status: "failed_read_after_write", event: ev, ts: new Date().toISOString(), message: "refs.paths missing after retries" });
-        return "failed_read_after_write";
+        appendEventLog(logPath, {
+            status: 'failed_read_after_write',
+            event: ev,
+            ts: new Date().toISOString(),
+            message: 'refs.paths missing after retries',
+        });
+        return 'failed_read_after_write';
     }
     // handle
     if (opts.onHandle) {
         await opts.onHandle(ev);
     }
     dedup.markProcessed(ev, now);
-    appendEventLog(logPath, { status: "handled", event: ev, ts: new Date().toISOString() });
-    return "handled";
+    appendEventLog(logPath, { status: 'handled', event: ev, ts: new Date().toISOString() });
+    return 'handled';
 }