@teamvibe/poller 0.1.63 → 0.1.65

package/dist/event-queue.d.ts

@@ -1,5 +1,6 @@
 export type ErrorCategory = 'sqs' | 'brain' | 'auth' | 'session' | 'slack' | 'maintenance';
 export type ErrorSeverity = 'warn' | 'error';
+export declare function emitEvent(eventType: string, channelId: string, metadata?: Record<string, unknown>): void;
 export declare function flush(): Promise<void>;
 export declare function startEventQueue(): void;
 export declare function stopEventQueue(): void;

package/dist/event-queue.js

@@ -10,16 +10,22 @@ let isFlushing = false;
 function dedupKey(channelId, category, message) {
     return `${channelId}:${category}:${message}`;
 }
+function isErrorEvent(event) {
+    return event.eventType === 'poller.error';
+}
 function enqueue(event) {
-    // Dedup: collapse identical category+message within window
-    const key = dedupKey(event.channelId, event.metadata.category, event.metadata.message);
-    const now = Date.now();
-    const windowStart = new Date(now - DEDUP_WINDOW_MS).toISOString();
-    const existing = queue.find((e) => dedupKey(e.channelId, e.metadata.category, e.metadata.message) === key &&
-        e.timestamp >= windowStart);
-    if (existing) {
-        existing.metadata.count += 1;
-        return;
+    // Dedup only applies to error events
+    if (isErrorEvent(event)) {
+        const key = dedupKey(event.channelId, event.metadata.category, event.metadata.message);
+        const now = Date.now();
+        const windowStart = new Date(now - DEDUP_WINDOW_MS).toISOString();
+        const existing = queue.find((e) => isErrorEvent(e) &&
+            dedupKey(e.channelId, e.metadata.category, e.metadata.message) === key &&
+            e.timestamp >= windowStart);
+        if (existing && isErrorEvent(existing)) {
+            existing.metadata.count += 1;
+            return;
+        }
     }
     if (queue.length >= MAX_QUEUE_SIZE) {
         queue.shift(); // Drop oldest
@@ -47,6 +53,17 @@ async function flushOne(event) {
         return false;
     }
 }
+export function emitEvent(eventType, channelId, metadata) {
+    if (!config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN) {
+        return;
+    }
+    enqueue({
+        eventType,
+        channelId,
+        metadata,
+        timestamp: new Date().toISOString(),
+    });
+}
 export async function flush() {
     if (queue.length === 0 || isFlushing)
         return;

package/dist/maintenance-reporter.js

@@ -26,6 +26,7 @@ export async function postMaintenanceReports(brainPath, channelId) {
             return;
         logger.info(`[MaintenanceReporter] Found ${jsonFiles.length} JSON report(s) in ${reportsDir}`);
         const postedFiles = [];
+        const removedFiles = [];
         for (const file of jsonFiles) {
             const filePath = join(reportsDir, file);
             try {
@@ -35,6 +36,7 @@ export async function postMaintenanceReports(brainPath, channelId) {
                     logger.warn(`[MaintenanceReporter] Removing invalid report ${file}: missing operationType`);
                     emitError('maintenance', `Removing invalid report ${file}: missing operationType`, { severity: 'warn' });
                     await unlink(filePath).catch(() => { });
+                    removedFiles.push(`reports/${file}`);
                     continue;
                 }
                 const eventType = OPERATION_TO_EVENT_TYPE[report.operationType];
@@ -42,6 +44,7 @@ export async function postMaintenanceReports(brainPath, channelId) {
                     logger.warn(`[MaintenanceReporter] Removing report ${file}: unknown operationType "${report.operationType}"`);
                     emitError('maintenance', `Removing report ${file}: unknown operationType "${report.operationType}"`, { severity: 'warn' });
                     await unlink(filePath).catch(() => { });
+                    removedFiles.push(`reports/${file}`);
                     continue;
                 }
                 const payload = {
@@ -73,12 +76,13 @@ export async function postMaintenanceReports(brainPath, channelId) {
                 emitError('maintenance', `Error processing report ${file}: ${err instanceof Error ? err.message : String(err)}`, { severity: 'warn', channelId });
             }
         }
-        // Remove posted JSON reports from git so they don't resurrect on next pull
-        if (postedFiles.length > 0) {
+        // Remove posted/invalid JSON reports from git so they don't resurrect on next pull
+        const allRemovedFromGit = [...postedFiles, ...removedFiles];
+        if (allRemovedFromGit.length > 0) {
             try {
-                await execFileAsync('git', ['rm', '--cached', '--ignore-unmatch', ...postedFiles], { cwd: brainPath });
-                await execFileAsync('git', ['commit', '-m', 'chore: remove posted maintenance reports'], { cwd: brainPath });
-                logger.info(`[MaintenanceReporter] Committed removal of ${postedFiles.length} posted report(s) from git`);
+                await execFileAsync('git', ['rm', '--cached', '--ignore-unmatch', ...allRemovedFromGit], { cwd: brainPath });
+                await execFileAsync('git', ['commit', '-m', 'chore: remove processed maintenance reports'], { cwd: brainPath });
+                logger.info(`[MaintenanceReporter] Committed removal of ${allRemovedFromGit.length} report(s) from git`);
             }
             catch (err) {
                 logger.debug(`[MaintenanceReporter] Could not git-rm reports (may not be a git repo): ${err instanceof Error ? err.message : err}`);

package/dist/poller.js

@@ -8,7 +8,7 @@ import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } fr
 import { postMaintenanceReports } from './maintenance-reporter.js';
 import { initAuth, stopRefresh } from './auth-provider.js';
 import { registerBrain, startHeartbeatLoop, stopHeartbeatLoop } from './heartbeat-manager.js';
-import { startEventQueue, stopEventQueue, flush as flushEventQueue } from './event-queue.js';
+import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent } from './event-queue.js';
 import { writeMessage, pickNextMessage, markProcessed, hasUnprocessed } from './inbox-manager.js';
 // Track active message processing
 const processingMessages = new Set();
@@ -64,6 +64,20 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 if (result.success) {
                     succeeded = true;
                     sessionLog.info(`[Loop] Claude completed iteration #${iteration}`);
+                    if (result.metrics) {
+                        emitEvent('session.completed', queueMessage.teamvibe.channelId, {
+                            threadId: queueMessage.thread_id,
+                            total_cost_usd: result.metrics.total_cost_usd,
+                            input_tokens: result.metrics.input_tokens,
+                            output_tokens: result.metrics.output_tokens,
+                            cache_read_input_tokens: result.metrics.cache_read_input_tokens,
+                            cache_creation_input_tokens: result.metrics.cache_creation_input_tokens,
+                            duration_ms: result.metrics.duration_ms,
+                            duration_api_ms: result.metrics.duration_api_ms,
+                            num_turns: result.metrics.num_turns,
+                            model: result.metrics.model,
+                        });
+                    }
                     if (queueMessage.teamvibe.brain?.brainId) {
                         await pushBrainChanges(kbPath, queueMessage.teamvibe.brain.brainId, queueMessage.teamvibe.workspaceId);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {