profclaw 0.0.1-beta.1 → 0.0.1-beta.2

package/dist/integrations/github-ticket-sync.js

@@ -9,6 +9,8 @@ import { randomUUID } from 'crypto';
 import { getDb } from '../storage/index.js';
 import { tickets, ticketExternalLinks, ticketComments, ticketHistory, githubCommentSyncs, } from '../storage/schema.js';
 import { findOrCreateLabel, setTicketLabels } from '../labels/index.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('GitHubSync');
 function isGitHubSyncWebhookPayload(payload) {
     return typeof payload === 'object' && payload !== null;
 }
@@ -181,7 +183,7 @@ export async function handleIssueEvent(action, issue, repository) {
             await setTicketLabels(ticketId, labelIds);
         }
         catch (e) {
-            console.warn('[GitHub Sync] Failed to sync labels:', e);
+            log.warn('Failed to sync labels', { error: e instanceof Error ? e.message : String(e) });
         }
     }
     // Update last synced timestamp
@@ -189,7 +191,7 @@ export async function handleIssueEvent(action, issue, repository) {
         lastSyncedAt: now,
         syncError: null,
     }).where(eq(ticketExternalLinks.ticketId, ticketId));
-    console.log(`[GitHub Sync] Updated ticket ${ticketId} from issue #${issue.number}: ${changes.map(c => c.field).join(', ')}`);
+    log.info('Updated ticket from issue', { ticketId, issueNumber: issue.number, fields: changes.map(c => c.field) });
     return { action: 'updated', ticketId };
 }
 /**
@@ -250,7 +252,7 @@ export async function handleCommentCreated(issue, comment, repository) {
         githubCommentId: comment.id,
         createdAt: now,
     });
-    console.log(`[GitHub Sync] Created comment ${commentId} from GitHub comment #${comment.id}`);
+    log.info('Created comment from GitHub', { commentId, githubCommentId: comment.id });
     return { action: 'comment_created', ticketId, commentId };
 }
 /**
@@ -279,7 +281,7 @@ export async function handleCommentEdited(issue, comment, repository) {
         content: comment.body,
         updatedAt: new Date(),
     }).where(eq(ticketComments.id, syncRecord[0].commentId));
-    console.log(`[GitHub Sync] Updated comment ${syncRecord[0].commentId} from GitHub comment #${comment.id}`);
+    log.info('Updated comment from GitHub', { commentId: syncRecord[0].commentId, githubCommentId: comment.id });
     return { action: 'comment_updated', ticketId: synced.ticketId, commentId: syncRecord[0].commentId };
 }
 /**
@@ -305,7 +307,7 @@ export async function handleCommentDeleted(issue, comment, repository) {
     // Delete sync record and comment
     await db.delete(githubCommentSyncs).where(eq(githubCommentSyncs.id, syncRecord[0].id));
     await db.delete(ticketComments).where(eq(ticketComments.id, syncRecord[0].commentId));
-    console.log(`[GitHub Sync] Deleted comment ${syncRecord[0].commentId}`);
+    log.info('Deleted comment', { commentId: syncRecord[0].commentId });
     return { action: 'comment_deleted', ticketId: synced.ticketId };
 }
 // MAIN WEBHOOK HANDLER
@@ -345,7 +347,7 @@ export async function processGitHubWebhookForTicketSync(event, payload) {
         return { action: 'ignored', reason: `unhandled_event: ${event}` };
     }
     catch (error) {
-        console.error('[GitHub Sync] Error processing webhook:', error);
+        log.error('Error processing webhook', error instanceof Error ? error : new Error(String(error)));
         throw error;
     }
 }

package/dist/integrations/github.js

@@ -1,4 +1,6 @@
 import { createHmac, timingSafeEqual } from 'crypto';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('GitHub');
 /**
  * GitHub Webhook Integration
  *
@@ -20,7 +22,7 @@ const WEBHOOK_SECRET = process.env.GITHUB_WEBHOOK_SECRET || '';
  */
 export function verifyGitHubSignature(payload, signature) {
     if (!WEBHOOK_SECRET) {
-        console.warn('GITHUB_WEBHOOK_SECRET not set - skipping signature verification');
+        log.warn('GITHUB_WEBHOOK_SECRET not set - skipping signature verification');
         return true;
     }
     if (!signature) {
@@ -49,10 +51,10 @@ export async function handleGitHubWebhook(c) {
         throw new Error('Invalid webhook signature');
     }
     const payload = JSON.parse(rawBody);
-    console.log(`[GitHub Webhook] Event: ${event}, Delivery: ${deliveryId}`);
+    log.info('GitHub webhook received', { event, deliveryId });
     switch (event) {
         case 'ping':
-            console.log('[GitHub Webhook] Ping received');
+            log.info('GitHub ping received');
             return null;
         case 'issues':
             return handleIssueEvent(payload);
@@ -61,7 +63,7 @@ export async function handleGitHubWebhook(c) {
         case 'pull_request':
             return handlePullRequestEvent(payload);
         default:
-            console.log(`[GitHub Webhook] Unhandled event: ${event}`);
+            log.info('Unhandled event', { event });
             return null;
     }
 }
@@ -75,7 +77,7 @@ function handleIssueEvent(payload) {
         // Check if issue has the AI task label
         const hasAiLabel = issue.labels?.some((l) => l.name === AI_TASK_LABEL || l.name === AI_REVIEW_LABEL);
         if (!hasAiLabel) {
-            console.log('[GitHub] Issue opened without AI label, skipping');
+            log.info('Issue opened without AI label, skipping', { issueNumber: issue.number });
             return null;
         }
     }
@@ -121,7 +123,7 @@ function handleIssueCommentEvent(payload) {
         return null;
     }
     const prompt = triggerMatch[1].trim();
-    console.log(`[GitHub] AI trigger command in issue #${issue.number}: ${prompt.substring(0, 50)}...`);
+    log.info('AI trigger command received', { issueNumber: issue.number, promptPreview: prompt.substring(0, 50) });
     return {
         title: `AI Task: ${issue.title}`,
         description: `Triggered by @${comment.user.login} in issue #${issue.number}`,

package/dist/integrations/jira.js

@@ -1,3 +1,5 @@
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('Jira');
 /**
  * Jira Webhook Integration
  *
@@ -16,7 +18,7 @@ const WEBHOOK_SECRET = process.env.JIRA_WEBHOOK_SECRET || '';
  */
 export function verifyJiraToken(c) {
     if (!WEBHOOK_SECRET) {
-        console.warn('JIRA_WEBHOOK_SECRET not set - skipping verification');
+        log.warn('JIRA_WEBHOOK_SECRET not set - skipping verification');
         return true;
     }
     const token = c.req.query('token');
@@ -33,7 +35,7 @@ export async function handleJiraWebhook(c) {
     const rawBody = await c.req.text();
     const payload = JSON.parse(rawBody);
     const { webhookEvent, issue } = payload;
-    console.log(`[Jira Webhook] Event: ${webhookEvent}, Issue: ${issue.key}`);
+    log.info('Jira webhook received', { webhookEvent, issueKey: issue.key });
     // Only handle created or updated events
     if (webhookEvent !== 'jira:issue_created' && webhookEvent !== 'jira:issue_updated') {
         return null;
@@ -41,7 +43,7 @@ export async function handleJiraWebhook(c) {
     // Check for AI label
     const hasAiLabel = issue.fields.labels?.includes(JIRA_AI_TASK_LABEL);
     if (!hasAiLabel) {
-        console.log('[Jira] Issue does not have AI label, skipping');
+        log.info('Issue does not have AI label, skipping', { issueKey: issue.key });
         return null;
     }
     // Construct source URL (convert API URL to browser URL)

package/dist/mcp/server.js

@@ -24,6 +24,8 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { BROWSER_TOOLS, handleBrowserTool } from './browser-tools.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('MCPServer', { stream: 'stderr' });
 // MCP Server configuration
 const PROFCLAW_API_URL = process.env.PROFCLAW_API_URL || process.env.PROFCLAW_API_URL || 'http://localhost:3000';
 const sessionState = {
@@ -405,12 +407,12 @@ export async function handleLogTask(args) {
             }),
         });
         if (!response.ok) {
-            console.error('[MCP] Failed to report to profClaw:', response.statusText);
+            log.error('[MCP] Failed to report to profClaw', { statusText: response.statusText });
         }
     }
     catch (error) {
         // Silently fail - don't block the agent
-        console.error('[MCP] Failed to connect to profClaw:', error);
+        log.error('[MCP] Failed to connect to profClaw', error instanceof Error ? error : { error });
     }
     return {
         content: [
@@ -447,11 +449,11 @@ export async function handleCompleteTask(args) {
             }),
         });
         if (!response.ok) {
-            console.error('[MCP] Failed to report completion to profClaw:', response.statusText);
+            log.error('[MCP] Failed to report completion to profClaw', { statusText: response.statusText });
         }
     }
     catch (error) {
-        console.error('[MCP] Failed to connect to profClaw:', error);
+        log.error('[MCP] Failed to connect to profClaw', error instanceof Error ? error : { error });
     }
     // Clear current task
     sessionState.currentTask = undefined;
@@ -510,7 +512,7 @@ async function handleGetContext(args) {
         }
     }
     catch (error) {
-        console.error('[MCP] Failed to fetch context from profClaw:', error);
+        log.error('[MCP] Failed to fetch context from profClaw', error instanceof Error ? error : { error });
     }
     // Fallback if API unavailable
     return {
@@ -815,12 +817,13 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // Log startup to stderr (stdout is for MCP protocol)
-    console.error('[profClaw MCP] Server started');
-    console.error(`[profClaw MCP] Session ID: ${sessionState.sessionId}`);
-    console.error(`[profClaw MCP] API URL: ${PROFCLAW_API_URL}`);
+    log.info('[profClaw MCP] Server started', {
+        apiUrl: PROFCLAW_API_URL,
+        sessionId: sessionState.sessionId,
+    });
 }
 main().catch((error) => {
-    console.error('[profClaw MCP] Fatal error:', error);
+    log.error('[profClaw MCP] Fatal error', error instanceof Error ? error : { error });
     process.exit(1);
 });
 //# sourceMappingURL=server.js.map

package/dist/memory/experience-store.js

@@ -10,7 +10,8 @@
  */
 import { randomUUID } from 'node:crypto';
 import { getClient } from '../storage/index.js';
-import { logger } from '../utils/logger.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('ExperienceStore');
 // Table Initialization
 /**
  * Initialize the experiences table and indexes.
@@ -90,7 +91,7 @@ export async function recordExperience(exp) {
         return id;
     }
     catch (error) {
-        console.error('[experience-store] Failed to record experience:', error);
+        log.error('Failed to record experience', error instanceof Error ? error : new Error(String(error)));
         throw error;
     }
 }
@@ -109,7 +110,7 @@ export async function getExperience(id) {
         return rowToExperience(result.rows[0]);
     }
     catch (error) {
-        console.error('[experience-store] Failed to get experience:', error);
+        log.error('Failed to get experience', error instanceof Error ? error : new Error(String(error)));
         return null;
     }
 }
@@ -129,7 +130,7 @@ export async function markUsed(id) {
         });
     }
     catch (error) {
-        console.error('[experience-store] Failed to mark experience used:', error);
+        log.error('Failed to mark experience used', error instanceof Error ? error : new Error(String(error)));
     }
 }
 /**
@@ -145,7 +146,7 @@ export async function deleteExperience(id) {
         return true;
     }
     catch (error) {
-        console.error('[experience-store] Failed to delete experience:', error);
+        log.error('Failed to delete experience', error instanceof Error ? error : new Error(String(error)));
         return false;
     }
 }
@@ -190,7 +191,7 @@ export async function listExperiences(options = {}) {
         };
     }
     catch (error) {
-        console.error('[experience-store] Failed to list experiences:', error);
+        log.error('Failed to list experiences', error instanceof Error ? error : new Error(String(error)));
         return { experiences: [], total: 0 };
     }
 }
@@ -246,7 +247,7 @@ export async function findSimilarExperiences(intent, tags, limit = 10) {
         return results;
     }
     catch (error) {
-        console.error('[experience-store] Similarity search failed:', error);
+        log.error('Similarity search failed', error instanceof Error ? error : new Error(String(error)));
         return [];
     }
 }
@@ -306,7 +307,7 @@ export async function trackPreference(userId, category, value) {
         }
     }
     catch (error) {
-        console.error('[experience-store] Failed to track preference:', error);
+        log.error('Failed to track preference', error instanceof Error ? error : new Error(String(error)));
     }
 }
 /**
@@ -334,7 +335,7 @@ export async function getUserPreferences(userId) {
         return grouped;
     }
     catch (error) {
-        console.error('[experience-store] Failed to get user preferences:', error);
+        log.error('Failed to get user preferences', error instanceof Error ? error : new Error(String(error)));
         return {};
     }
 }
@@ -369,11 +370,11 @@ export async function applyDecay(halfLifeDays = DEFAULT_HALF_LIFE_DAYS) {
             });
             updated++;
         }
-        logger.info(`[experience-store] Decay applied to ${updated} experiences (halfLife=${halfLifeDays}d)`);
+        log.info('Decay applied', { count: updated, halfLifeDays });
         return updated;
     }
     catch (error) {
-        console.error('[experience-store] Decay calculation failed:', error);
+        log.error('Decay calculation failed', error instanceof Error ? error : new Error(String(error)));
         return 0;
     }
 }
@@ -394,12 +395,12 @@ export async function pruneExpired(minWeight = 0.05) {
                 sql: `DELETE FROM experiences WHERE weight < ?`,
                 args: [minWeight],
             });
-            logger.info(`[experience-store] Pruned ${count} expired experiences (minWeight=${minWeight})`);
+            log.info('Pruned expired experiences', { count, minWeight });
         }
         return count;
     }
     catch (error) {
-        console.error('[experience-store] Prune failed:', error);
+        log.error('Prune failed', error instanceof Error ? error : new Error(String(error)));
         return 0;
     }
 }
@@ -432,7 +433,7 @@ export async function getStats() {
         return { total, byType, avgAge: Math.round(avgAge * 10) / 10 };
     }
     catch (error) {
-        console.error('[experience-store] Failed to get stats:', error);
+        log.error('Failed to get stats', error instanceof Error ? error : new Error(String(error)));
         return { total: 0, byType: {}, avgAge: 0 };
     }
 }

package/dist/notifications/slack.js

@@ -3,6 +3,8 @@
  *
  * Sends notifications to Slack via incoming webhooks.
  */
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('SlackNotify');
 const SLACK_WEBHOOK_URL = process.env.SLACK_WEBHOOK_URL || '';
 const SLACK_CHANNEL = process.env.SLACK_CHANNEL || '';
 const NOTIFY_ON_START = process.env.SLACK_NOTIFY_ON_START === 'true';
@@ -84,11 +86,11 @@ export async function sendSlackNotification(notification) {
             body: JSON.stringify(payload),
         });
         if (!response.ok) {
-            console.error(`[Slack] Failed to send notification: ${response.status}`);
+            log.error('Failed to send notification', new Error(`HTTP ${response.status}`));
         }
     }
     catch (error) {
-        console.error('[Slack] Error sending notification:', error);
+        log.error('Error sending notification', error instanceof Error ? error : new Error(String(error)));
     }
 }
 /**

package/dist/providers/types.d.ts

@@ -306,6 +306,7 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
     ticketId: z.ZodOptional<z.ZodString>;
     taskId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    stream: boolean;
     messages: {
         id: string;
         timestamp: string;
@@ -317,7 +318,6 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
         imageUrls?: string[] | undefined;
     }[];
     temperature: number;
-    stream: boolean;
     taskId?: string | undefined;
     model?: string | undefined;
     ticketId?: string | undefined;
@@ -342,6 +342,7 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
         imageUrls?: string[] | undefined;
     }[];
     taskId?: string | undefined;
+    stream?: boolean | undefined;
     model?: string | undefined;
     ticketId?: string | undefined;
     provider?: "custom" | "anthropic" | "openai" | "google" | "azure" | "ollama" | "openrouter" | "bedrock" | undefined;
@@ -354,7 +355,6 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
     systemPrompt?: string | undefined;
     temperature?: number | undefined;
     maxTokens?: number | undefined;
-    stream?: boolean | undefined;
 }>;
 export type ChatCompletionRequest = z.infer<typeof ChatCompletionRequestSchema>;
 export declare const ChatCompletionResponseSchema: z.ZodObject<{

package/dist/queue/failure-handler.js

@@ -9,6 +9,8 @@
 import { sendSlackNotification } from '../notifications/slack.js';
 import { getStorage } from '../storage/index.js';
 import { randomUUID } from 'crypto';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('FailureHandler');
 // Reference to the task queue (set during init)
 let taskQueueRef = null;
 /**
@@ -69,12 +71,12 @@ export async function initDeadLetterQueue() {
  * Handle a failed task
  */
 export async function handleTaskFailure(task, error) {
-    console.error(`[FailureHandler] Task ${task.id} failed: ${error.message}`);
+    log.error(`Task ${task.id} failed`, new Error(error.message));
     task.attempts = (task.attempts || 0) + 1;
     // Check if we should retry
     if (task.attempts < task.maxAttempts) {
         const delay = calculateBackoffWithJitter(task.attempts);
-        console.log(`[FailureHandler] Scheduling retry ${task.attempts}/${task.maxAttempts} in ${Math.round(delay / 1000)}s`);
+        log.info('Scheduling retry', { taskId: task.id, attempt: task.attempts, maxAttempts: task.maxAttempts, delaySeconds: Math.round(delay / 1000) });
         // Actually retry with BullMQ delay
         if (taskQueueRef) {
             await taskQueueRef.add(`retry-${task.id}-${task.attempts}`, { ...task, status: 'pending' }, {
@@ -82,10 +84,10 @@ export async function handleTaskFailure(task, error) {
                 priority: task.priority,
                 jobId: `${task.id}-retry-${task.attempts}`,
             });
-            console.log(`[FailureHandler] Task ${task.id} requeued with ${delay}ms delay`);
+            log.info('Task requeued with delay', { taskId: task.id, delayMs: delay });
         }
         else {
-            console.warn('[FailureHandler] Task queue not available, cannot retry');
+            log.warn('Task queue not available, cannot retry');
         }
         await sendSlackNotification({
             type: 'task_retry',
@@ -93,11 +95,11 @@ export async function handleTaskFailure(task, error) {
             message: `Attempt ${task.attempts}/${task.maxAttempts} failed. Retrying in ${Math.round(delay / 60000)} minutes.\nError: ${error.message}`,
             task,
             severity: 'info',
-        }).catch(console.error);
+        }).catch((err) => log.error('Slack notification failed', err instanceof Error ? err : new Error(String(err))));
         return;
     }
     // Max retries reached - move to dead letter queue
-    console.error(`[FailureHandler] Task ${task.id} exceeded max retries, moving to dead letter queue`);
+    log.error(`Task ${task.id} exceeded max retries, moving to dead letter queue`, new Error('MAX_RETRIES_EXCEEDED'));
     task.status = 'failed';
     task.result = {
         success: false,
@@ -119,7 +121,7 @@ export async function handleTaskFailure(task, error) {
         message: `Task failed after ${task.maxAttempts} attempts and moved to dead letter queue.\n\nLast error: ${error.message}\n\nSource: ${task.sourceUrl || 'N/A'}`,
         task,
         severity: 'error',
-    }).catch(console.error);
+    }).catch((err) => log.error('Slack notification failed', err instanceof Error ? err : new Error(String(err))));
 }
 /**
  * Calculate exponential backoff with jitter
@@ -167,7 +169,7 @@ async function addToDeadLetterQueue(task, error) {
         toUnixSeconds(task.createdAt),
         toUnixSeconds(task.startedAt),
     ]);
-    console.log(`[FailureHandler] Task ${task.id} persisted to DLQ with ID ${id}`);
+    log.info('Task persisted to DLQ', { taskId: task.id, dlqId: id });
 }
 /**
  * Post failure comment on GitHub issue
@@ -216,7 +218,7 @@ This task has been moved to the dead letter queue for manual review. Please:
         });
     }
     catch (err) {
-        console.error('[FailureHandler] Failed to post GitHub comment:', err);
+        log.error('Failed to post GitHub comment', err instanceof Error ? err : new Error(String(err)));
     }
 }
 /**
@@ -289,14 +291,14 @@ export async function discardFromDeadLetterQueue(dlqId, resolvedBy, resolutionNo
  */
 export async function retryDeadLetterTask(dlqId) {
     if (!taskQueueRef) {
-        console.error('[FailureHandler] Task queue not available, cannot retry');
+        log.error('Task queue not available, cannot retry', new Error('QUEUE_NOT_INITIALIZED'));
         return false;
     }
     const storage = getStorage();
     // Get the DLQ entry
     const rows = await storage.query('SELECT * FROM dead_letter_tasks WHERE id = ? AND status = ?', [dlqId, 'pending']);
     if (rows.length === 0) {
-        console.error(`[FailureHandler] DLQ entry ${dlqId} not found or not pending`);
+        log.error(`DLQ entry not found or not pending`, new Error(`DLQ entry ${dlqId} not found`));
         return false;
     }
     const dlqEntry = rows[0];
@@ -334,7 +336,7 @@ export async function retryDeadLetterTask(dlqId) {
     await storage.execute(`UPDATE dead_letter_tasks
      SET retry_count = retry_count + 1, last_retry_at = strftime('%s', 'now'), status = 'resolved', resolution_note = 'Retried'
      WHERE id = ?`, [dlqId]);
-    console.log(`[FailureHandler] Task ${task.id} moved from DLQ back to main queue`);
+    log.info('Task moved from DLQ back to main queue', { taskId: task.id, dlqId });
     return true;
 }
 /**
@@ -350,7 +352,7 @@ export async function cleanupDeadLetterQueue(retentionDays = parseInt(process.en
     // SQLite execute doesn't reliably return affected rows, so count separately
     const remaining = await storage.query(`SELECT COUNT(*) as count FROM dead_letter_tasks WHERE status IN ('resolved', 'discarded')`);
     const remainingCount = remaining[0]?.count ?? 0;
-    console.log(`[FailureHandler] DLQ cleanup: removed entries older than ${retentionDays} days (${remainingCount} resolved/discarded remaining)`);
+    log.info('DLQ cleanup complete', { retentionDays, remainingResolved: remainingCount });
     return remainingCount;
 }
 /**

package/dist/queue/index.js

@@ -5,6 +5,8 @@
  * All consumers import from this module instead of task-queue or memory-queue directly.
  */
 import { shouldUseRedis } from '../core/deployment.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('Queue');
 let backend = null;
 let backendType = null;
 async function loadBackend() {
@@ -25,21 +27,21 @@ async function loadBackend() {
             await testRedis.disconnect();
             backend = await import('./task-queue.js');
             backendType = 'redis';
-            console.log('[Queue] Using Redis-backed BullMQ queue');
+            log.info('Using Redis-backed BullMQ queue');
             return backend;
         }
         catch {
             if (process.env.PROFCLAW_REQUIRE_REDIS === 'true') {
-                console.error('[FATAL] PROFCLAW_REQUIRE_REDIS=true but Redis is unreachable');
+                log.error('PROFCLAW_REQUIRE_REDIS=true but Redis is unreachable', new Error('REDIS_UNREACHABLE'));
                 process.exit(1);
             }
-            console.log('[Queue] Redis unavailable, falling back to in-memory queue');
+            log.warn('Redis unavailable, falling back to in-memory queue');
         }
     }
     // Fallback: in-memory queue
     backend = await import('./memory-queue.js');
     backendType = 'memory';
-    console.log('[Queue] Using in-memory queue (no Redis)');
+    log.info('Using in-memory queue (no Redis)');
     return backend;
 }
 function getBackend() {