bunqueue 2.8.9 → 2.8.11

package/dist/cli/output.js

@@ -143,6 +143,15 @@ function formatStats(stats) {
         lines.push(`  Total Completed: ${str(stats.totalCompleted)}`);
         lines.push(`  Total Failed:    ${str(stats.totalFailed)}`);
     }
+    if (stats.uptime !== undefined) {
+        lines.push('', `  ${color('Uptime:', colors.cyan)}      ${str(stats.uptime)}s`);
+    }
+    if (stats.pushPerSec !== undefined) {
+        lines.push(`  Push/sec:    ${str(stats.pushPerSec)}`);
+    }
+    if (stats.pullPerSec !== undefined) {
+        lines.push(`  Pull/sec:    ${str(stats.pullPerSec)}`);
+    }
     return lines.join('\n');
 }
 /** Format counts object */
@@ -167,7 +176,17 @@ function formatCronJobs(jobs) {
         const schedule = job.schedule !== null && job.schedule !== undefined
             ? str(job.schedule)
             : `every ${str(job.repeatEvery)}ms`;
-        return `  ${color(str(job.name), colors.bold)}\n    Queue: ${str(job.queue)}\n    Schedule: ${schedule}\n    Executions: ${str(job.executions)}`;
+        let out = `  ${color(str(job.name), colors.bold)}\n    Queue: ${str(job.queue)}\n    Schedule: ${schedule}\n    Executions: ${str(job.executions)}`;
+        if (typeof job.nextRun === 'number') {
+            out += `\n    Next run: ${new Date(job.nextRun).toISOString()}`;
+        }
+        if (job.maxLimit !== null && job.maxLimit !== undefined) {
+            out += `\n    Max: ${str(job.maxLimit)}`;
+        }
+        if (job.timezone !== null && job.timezone !== undefined) {
+            out += `\n    Timezone: ${str(job.timezone)}`;
+        }
+        return out;
     });
     return lines.join('\n\n');
 }
@@ -177,7 +196,25 @@ function formatWorkers(workers) {
         return color('No workers registered', colors.yellow);
     }
     return workers
-        .map((w) => `  ${color(str(w.id), colors.bold)}: ${str(w.name)} (${Array.isArray(w.queues) ? w.queues.join(', ') : 'none'})`)
+        .map((w) => {
+        const queues = Array.isArray(w.queues) ? w.queues.join(', ') : 'none';
+        // status matters operationally: a stale worker must be visible
+        const status = w.status === 'stale'
+            ? color('[stale]', colors.red)
+            : w.status !== undefined
+                ? color(`[${str(w.status)}]`, colors.green)
+                : '';
+        const extra = [];
+        if (w.concurrency !== undefined)
+            extra.push(`concurrency=${str(w.concurrency)}`);
+        if (w.activeJobs !== undefined)
+            extra.push(`active=${str(w.activeJobs)}`);
+        if (w.processedJobs !== undefined) {
+            extra.push(`processed=${str(w.processedJobs)}/failed=${str(w.failedJobs, '0')}`);
+        }
+        const extraStr = extra.length > 0 ? `\n    ${extra.join(' ')}` : '';
+        return `  ${color(str(w.id), colors.bold)}: ${str(w.name)} ${status} (${queues})${extraStr}`;
+    })
         .join('\n');
 }
 /** Format webhooks list */
@@ -186,7 +223,15 @@ function formatWebhooks(webhooks) {
         return color('No webhooks registered', colors.yellow);
     }
     return webhooks
-        .map((w) => `  ${color(str(w.id), colors.bold)}: ${str(w.url)}\n    Events: ${w.events.join(', ')}`)
+        .map((w) => {
+        const events = Array.isArray(w.events) ? w.events.join(', ') : 'none';
+        const enabled = w.enabled === false ? ` ${color('[disabled]', colors.yellow)}` : '';
+        const queue = w.queue !== null && w.queue !== undefined ? `\n    Queue: ${str(w.queue)}` : '';
+        const counters = w.successCount !== undefined || w.failureCount !== undefined
+            ? `\n    Delivered: ${str(w.successCount, '0')} ok / ${str(w.failureCount, '0')} failed`
+            : '';
+        return `  ${color(str(w.id), colors.bold)}: ${str(w.url)}${enabled}\n    Events: ${events}${queue}${counters}`;
+    })
         .join('\n\n');
 }
 /** Format DLQ jobs */
@@ -300,6 +345,15 @@ function formatSuccess(response, command, subcommand) {
     // Worker registered
     if ('workerId' in r)
         return color(`Worker registered: ${str(r.workerId)}`, colors.green);
+    // Webhook added — show the id, it is needed for `webhook remove`
+    if ('webhookId' in r)
+        return color(`Webhook added: ${str(r.webhookId)}`, colors.green);
+    // Cron scheduled — surface nextRun
+    if ('cron' in r && r.cron !== null && typeof r.cron === 'object') {
+        const c = r.cron;
+        const next = typeof c.nextRun === 'number' ? ` (next run: ${new Date(c.nextRun).toISOString()})` : '';
+        return color(`Cron scheduled: ${str(c.name)}${next}`, colors.green);
+    }
     // State
     if ('state' in r)
         return `State: ${str(r.state)}`;

package/dist/client/jobConversionHelpers.js

@@ -20,7 +20,8 @@ export function buildJobProperties(job, name, stacktrace, token, processedBy) {
         delay: job.runAt > job.createdAt ? job.runAt - job.createdAt : 0,
         processedOn: job.startedAt ?? undefined,
         finishedOn: job.completedAt ?? undefined,
-        stacktrace: stacktrace ?? null,
+        // Fall back to the stack persisted on the internal job at FAIL time (#74)
+        stacktrace: stacktrace ?? job.stacktrace ?? null,
         stalledCounter: job.stallCount,
         priority: job.priority,
         parentKey: buildParentKey(job),
@@ -66,6 +67,8 @@ export function buildStateCheckMethods(id, getState, getDependenciesCount) {
 }
 /** Build serialization methods */
 export function buildSerializationMethods(job, id, name, jobOpts, stacktrace) {
+    // Fall back to the stack persisted on the internal job at FAIL time (#74)
+    const stack = stacktrace ?? job.stacktrace ?? null;
     return {
         toJSON: () => ({
             id,
@@ -76,7 +79,7 @@ export function buildSerializationMethods(job, id, name, jobOpts, stacktrace) {
             delay: job.runAt > job.createdAt ? job.runAt - job.createdAt : 0,
             timestamp: job.createdAt,
             attemptsMade: job.attempts,
-            stacktrace: stacktrace ?? null,
+            stacktrace: stack,
             returnvalue: undefined,
             failedReason: undefined,
             finishedOn: job.completedAt ?? undefined,
@@ -93,7 +96,7 @@ export function buildSerializationMethods(job, id, name, jobOpts, stacktrace) {
             delay: String(job.runAt > job.createdAt ? job.runAt - job.createdAt : 0),
             timestamp: String(job.createdAt),
             attemptsMade: String(job.attempts),
-            stacktrace: stacktrace ? JSON.stringify(stacktrace) : null,
+            stacktrace: stack ? JSON.stringify(stack) : null,
             returnvalue: undefined,
             failedReason: undefined,
             finishedOn: job.completedAt ? String(job.completedAt) : undefined,

package/dist/client/queue/jobProxy.d.ts

@@ -22,6 +22,10 @@ export interface JobReflectionMeta {
     delay?: number;
     opts?: JobOptions;
     timestamp?: number;
+    /** Persisted stacktrace of the last failure, from the server/manager job (#74) */
+    stacktrace?: string[] | null;
+    /** Last failure's error message, derived from the job timeline (#74) */
+    failedReason?: string;
 }
 /** Create a full Job proxy with TCP methods */
 export declare function createJobProxy<T>(id: string, name: string, data: T, ctx: JobProxyContext, meta?: JobReflectionMeta): Job<T>;

package/dist/client/queue/jobProxy.js

@@ -17,6 +17,8 @@ function reflectFields(id, queueName, meta) {
         parentKey: p ? `${p.queue}:${p.id}` : undefined,
         parent: p ? { id: p.id, queueQualifiedName: p.queue } : undefined,
         repeatJobKey: repeat ? `${queueName}:${id}:${pattern}` : undefined,
+        stacktrace: meta?.stacktrace ?? null,
+        failedReason: meta?.failedReason,
     };
 }
 /** Create a full Job proxy with TCP methods */
@@ -35,7 +37,8 @@ export function createJobProxy(id, name, data, ctx, meta) {
         delay: r.delay,
         processedOn: undefined,
         finishedOn: undefined,
-        stacktrace: null,
+        stacktrace: r.stacktrace,
+        failedReason: r.failedReason,
         stalledCounter: 0,
         priority: r.priority,
         parent: r.parent,
@@ -103,7 +106,8 @@ export function createJobProxy(id, name, data, ctx, meta) {
             delay: r.delay,
             timestamp: ts,
             attemptsMade: 0,
-            stacktrace: null,
+            stacktrace: r.stacktrace,
+            failedReason: r.failedReason,
             queueQualifiedName: `bull:${queueName}`,
             parentKey: r.parentKey,
         }),
@@ -116,7 +120,8 @@ export function createJobProxy(id, name, data, ctx, meta) {
             delay: String(r.delay),
             timestamp: String(ts),
             attemptsMade: '0',
-            stacktrace: null,
+            stacktrace: r.stacktrace ? JSON.stringify(r.stacktrace) : null,
+            failedReason: r.failedReason,
             parentKey: r.parentKey,
         }),
         // Move methods
@@ -212,7 +217,8 @@ export function createSimpleJob(id, name, data, timestamp, ctx) {
         delay: r.delay,
         processedOn: undefined,
         finishedOn: undefined,
-        stacktrace: null,
+        stacktrace: r.stacktrace,
+        failedReason: r.failedReason,
         stalledCounter: 0,
         priority: r.priority,
         parent: r.parent,
@@ -318,7 +324,8 @@ export function createSimpleJob(id, name, data, timestamp, ctx) {
             delay: r.delay,
             timestamp,
             attemptsMade: 0,
-            stacktrace: null,
+            stacktrace: r.stacktrace,
+            failedReason: r.failedReason,
             queueQualifiedName: `bull:${queueName}`,
             parentKey: r.parentKey,
         }),
@@ -331,7 +338,8 @@ export function createSimpleJob(id, name, data, timestamp, ctx) {
             delay: String(r.delay),
             timestamp: String(timestamp),
             attemptsMade: '0',
-            stacktrace: null,
+            stacktrace: r.stacktrace ? JSON.stringify(r.stacktrace) : null,
+            failedReason: r.failedReason,
             parentKey: r.parentKey,
         }),
         moveToCompleted: async (returnValue) => {

package/dist/client/queue/operations/query.js

@@ -8,10 +8,28 @@ import { toPublicJob } from '../../types';
 import { jobId } from '../../../domain/types/job';
 import { createSimpleJob } from '../jobProxy';
 import { buildJobOpts } from '../../jobHelpers';
-/** Build reflection meta (priority/delay/opts) from an internal job shape */
+/** Last failure's error message from the job timeline (#74) */
+function lastFailedError(timeline) {
+    if (!timeline)
+        return undefined;
+    for (let i = timeline.length - 1; i >= 0; i--) {
+        const entry = timeline[i];
+        if (entry.state === 'failed' && entry.error)
+            return entry.error;
+    }
+    return undefined;
+}
+/** Build reflection meta (priority/delay/opts/stacktrace) from an internal job shape */
 function metaFromJob(job) {
     const opts = buildJobOpts(job);
-    return { priority: job.priority ?? 0, delay: opts.delay ?? 0, opts };
+    return {
+        priority: job.priority ?? 0,
+        delay: opts.delay ?? 0,
+        opts,
+        // Persisted server-side on FAIL (#74); absent on pre-#74 servers
+        stacktrace: job.stacktrace ?? null,
+        failedReason: lastFailedError(job.timeline),
+    };
 }
 /** Get a single job by ID */
 export async function getJob(ctx, id) {

package/dist/client/worker/processor.js

@@ -157,16 +157,27 @@ async function handleJobFailure(internalJob, error, config, context) {
         internalJob.maxAttempts = 1;
         internalJob.attempts = 0;
     }
+    // Bug #74: stack lines computed BEFORE the send so the server can persist
+    // them. The wire copy is capped at 50 lines as a bandwidth guard; the
+    // authoritative cap (job.stackTraceLimit) is applied server-side in failJob.
+    const stackLines = err.stack
+        ? err.stack
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean)
+        : [];
+    const wireStack = stackLines.length > 0 ? stackLines.slice(0, 50) : undefined;
     try {
         if (embedded) {
             const manager = getSharedManager();
-            await manager.fail(internalJob.id, err.message, token ?? undefined);
+            await manager.fail(internalJob.id, err.message, token ?? undefined, undefined, wireStack);
         }
         else if (tcp) {
             await tcp.send({
                 cmd: 'FAIL',
                 id: internalJob.id,
                 error: err.message,
+                ...(wireStack ? { stack: wireStack } : {}),
                 ...(token ? { token } : {}),
                 ...(err instanceof UnrecoverableError ? { unrecoverable: true } : {}),
             });
@@ -180,14 +191,10 @@ async function handleJobFailure(internalJob, error, config, context) {
         emitter.emit('error', Object.assign(wrappedError, { context: 'fail', jobId: jobIdStr }));
     }
     job.failedReason = err.message;
-    // Bug #74: populate stacktrace from the error's stack
+    // Bug #74: populate stacktrace on the local `failed` event object
     if (err.stack) {
         const limit = internalJob.stackTraceLimit;
-        const lines = err.stack
-            .split('\n')
-            .map((l) => l.trim())
-            .filter(Boolean);
-        job.stacktrace = lines.slice(0, limit);
+        job.stacktrace = stackLines.slice(0, limit);
     }
     config.onOutcome?.(false);
     emitter.emit('failed', job, err);

package/dist/domain/types/command.d.ts

@@ -100,6 +100,8 @@ export interface FailCommand extends BaseCommand {
     readonly token?: string;
     /** Skip all remaining retries and fail terminally (UnrecoverableError over TCP). */
     readonly unrecoverable?: boolean;
+    /** Stack trace lines of the failure — persisted server-side, capped at job.stackTraceLimit (#74). */
+    readonly stack?: string[];
 }
 export interface GetJobCommand extends BaseCommand {
     readonly cmd: 'GetJob';

package/dist/domain/types/cron.js

@@ -16,7 +16,9 @@ export function createCronJob(input, nextRun) {
         timezone: input.timezone ?? null,
         nextRun,
         executions: 0,
-        maxLimit: input.maxLimit ?? null,
+        // 0/negative mean "no limit" on every surface (CLI/HTTP/TCP/MCP): storing
+        // 0 would make isAtLimit treat the cron as already exhausted (0 >= 0).
+        maxLimit: input.maxLimit !== undefined && input.maxLimit > 0 ? input.maxLimit : null,
         uniqueKey: input.uniqueKey ?? null,
         dedup: input.dedup ?? null,
         skipMissedOnRestart: input.skipMissedOnRestart ?? true,

package/dist/domain/types/job.d.ts

@@ -94,6 +94,8 @@ export interface Job {
     readonly groupId: string | null;
     progress: number;
     progressMessage: string | null;
+    /** Last failure's stack trace lines (trimmed, capped at stackTraceLimit). Null until a FAIL carries a stack. (#74) */
+    stacktrace: string[] | null;
     readonly removeOnComplete: boolean;
     readonly removeOnFail: boolean;
     readonly repeat: RepeatConfig | null;
@@ -220,6 +222,12 @@ export declare const JOB_DEFAULTS: {
 };
 /** Create a new job from input */
 export declare function createJob(id: JobId, queue: string, input: JobInput, now?: number): Job;
+/**
+ * Normalize raw stack lines for persistence: keep only strings, trim, drop
+ * empties, cap at `limit` (job.stackTraceLimit). Returns null when nothing
+ * remains (e.g. stackTraceLimit: 0), matching the 2.6.110 event semantics. (#74)
+ */
+export declare function normalizeStacktrace(lines: readonly unknown[] | undefined, limit: number): string[] | null;
 /** Check if job is delayed */
 export declare function isDelayed(job: Job, now?: number): boolean;
 /** Check if job is ready to process */

package/dist/domain/types/job.js

@@ -122,6 +122,7 @@ export function createJob(id, queue, input, now = Date.now()) {
         tags: input.tags ?? [],
         progress: 0,
         progressMessage: null,
+        stacktrace: null,
         repeat: parseRepeatConfig(input.repeat),
         lastHeartbeat: createdAt,
         stallCount: 0,
@@ -131,6 +132,26 @@ export function createJob(id, queue, input, now = Date.now()) {
         timeline: [],
     };
 }
+/**
+ * Normalize raw stack lines for persistence: keep only strings, trim, drop
+ * empties, cap at `limit` (job.stackTraceLimit). Returns null when nothing
+ * remains (e.g. stackTraceLimit: 0), matching the 2.6.110 event semantics. (#74)
+ */
+export function normalizeStacktrace(lines, limit) {
+    if (!lines || lines.length === 0)
+        return null;
+    const out = [];
+    for (const line of lines) {
+        if (out.length >= limit)
+            break;
+        if (typeof line !== 'string')
+            continue;
+        const trimmed = line.trim();
+        if (trimmed)
+            out.push(trimmed);
+    }
+    return out.length > 0 ? out : null;
+}
 /** Check if job is delayed */
 export function isDelayed(job, now = Date.now()) {
     return job.runAt > now;

package/dist/domain/types/webhook.d.ts

@@ -3,8 +3,18 @@
  */
 /** Webhook ID type */
 export type WebhookId = string;
-/** Webhook event types */
-export type WebhookEvent = 'job.pushed' | 'job.started' | 'job.completed' | 'job.failed' | 'job.progress' | 'job.stalled';
+/**
+ * Canonical list of webhook events the server actually triggers — single
+ * source of truth for CLI/TCP/HTTP/MCP validation. job.pushed/started/
+ * completed/failed flow through eventsManager.mapEventToWebhook; job.progress
+ * is triggered directly by updateProgress (jobManagement).
+ */
+export declare const WEBHOOK_EVENTS: readonly ["job.pushed", "job.started", "job.completed", "job.failed", "job.progress"];
+/**
+ * Webhook event types. Includes 'job.stalled' for backward compatibility with
+ * stored webhooks, but it is never emitted and not accepted on new ones.
+ */
+export type WebhookEvent = (typeof WEBHOOK_EVENTS)[number] | 'job.stalled';
 /** Webhook configuration */
 export interface Webhook {
     id: WebhookId;

package/dist/domain/types/webhook.js

@@ -2,6 +2,19 @@
  * Webhook domain types
  */
 import { uuid } from '../../shared/hash';
+/**
+ * Canonical list of webhook events the server actually triggers — single
+ * source of truth for CLI/TCP/HTTP/MCP validation. job.pushed/started/
+ * completed/failed flow through eventsManager.mapEventToWebhook; job.progress
+ * is triggered directly by updateProgress (jobManagement).
+ */
+export const WEBHOOK_EVENTS = [
+    'job.pushed',
+    'job.started',
+    'job.completed',
+    'job.failed',
+    'job.progress',
+];
 /** Create a new webhook */
 export function createWebhook(url, events, queue, secret) {
     return {

package/dist/infrastructure/persistence/schema.d.ts

@@ -4,10 +4,10 @@
 /** SQLite PRAGMA settings for optimal performance */
 export declare const PRAGMA_SETTINGS = "\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\nPRAGMA page_size = 4096;\nPRAGMA busy_timeout = 5000;\n";
 /** Main schema creation */
-export declare const SCHEMA = "\n-- Jobs table (using UUIDv7 for job IDs)\n-- Uses BLOB for data fields (MessagePack serialization for ~2-3x faster than JSON)\nCREATE TABLE IF NOT EXISTS jobs (\n    id TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    data BLOB NOT NULL,\n    priority INTEGER NOT NULL DEFAULT 0,\n    created_at INTEGER NOT NULL,\n    run_at INTEGER NOT NULL,\n    started_at INTEGER,\n    completed_at INTEGER,\n    attempts INTEGER NOT NULL DEFAULT 0,\n    max_attempts INTEGER NOT NULL DEFAULT 3,\n    backoff INTEGER NOT NULL DEFAULT 1000,\n    ttl INTEGER,\n    timeout INTEGER,\n    unique_key TEXT,\n    custom_id TEXT,\n    depends_on BLOB,\n    parent_id TEXT,\n    children_ids BLOB,\n    tags BLOB,\n    state TEXT NOT NULL DEFAULT 'waiting',\n    lifo INTEGER NOT NULL DEFAULT 0,\n    group_id TEXT,\n    progress INTEGER DEFAULT 0,\n    progress_msg TEXT,\n    remove_on_complete INTEGER DEFAULT 0,\n    remove_on_fail INTEGER DEFAULT 0,\n    stall_timeout INTEGER,\n    last_heartbeat INTEGER,\n    timeline BLOB\n);\n\n-- Indexes for common queries\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_state\n    ON jobs(queue, state);\nCREATE INDEX IF NOT EXISTS idx_jobs_run_at\n    ON jobs(run_at) WHERE state IN ('waiting', 'delayed');\nCREATE INDEX IF NOT EXISTS idx_jobs_unique\n    ON jobs(queue, unique_key) WHERE unique_key IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_custom_id\n    ON jobs(custom_id) WHERE custom_id IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_parent\n    ON jobs(parent_id) WHERE parent_id IS NOT NULL;\n\n-- Job results storage (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS job_results (\n    job_id TEXT PRIMARY KEY,\n    result BLOB,\n    completed_at INTEGER NOT NULL\n);\n\n-- Dead letter queue (BLOB for MessagePack - stores full DlqEntry)\nCREATE TABLE IF NOT EXISTS dlq (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    job_id TEXT NOT NULL,\n    queue TEXT NOT NULL,\n    entry BLOB NOT NULL,\n    entered_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_dlq_queue ON dlq(queue);\nCREATE INDEX IF NOT EXISTS idx_dlq_job_id ON dlq(job_id);\nCREATE INDEX IF NOT EXISTS idx_dlq_entered_at ON dlq(entered_at);\n\n-- Performance indexes for high-throughput operations\n-- Stall detection: runs every 5s, needs fast lookup of active jobs by started_at\nCREATE INDEX IF NOT EXISTS idx_jobs_state_started\n    ON jobs(state, started_at) WHERE state = 'active';\n\n-- Group operations: fast lookup by group_id\nCREATE INDEX IF NOT EXISTS idx_jobs_group_id\n    ON jobs(group_id) WHERE group_id IS NOT NULL;\n\n-- Pending jobs: compound index for priority-ordered retrieval\nCREATE INDEX IF NOT EXISTS idx_jobs_pending_priority\n    ON jobs(queue, state, priority DESC, run_at ASC) WHERE state IN ('waiting', 'delayed');\n\n-- Completed jobs: index for recovery ordering (issue #84)\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_order\n    ON jobs(completed_at DESC) WHERE state = 'completed';\n\n-- Cron jobs (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS cron_jobs (\n    name TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    data BLOB NOT NULL,\n    schedule TEXT,\n    repeat_every INTEGER,\n    priority INTEGER NOT NULL DEFAULT 0,\n    next_run INTEGER NOT NULL,\n    executions INTEGER NOT NULL DEFAULT 0,\n    max_limit INTEGER,\n    timezone TEXT,\n    unique_key TEXT,\n    dedup BLOB,\n    skip_missed_on_restart INTEGER NOT NULL DEFAULT 0,\n    skip_if_no_worker INTEGER NOT NULL DEFAULT 0,\n    prevent_overlap INTEGER NOT NULL DEFAULT 1,\n    job_options BLOB\n);\n\n-- Queue state persistence (optional)\nCREATE TABLE IF NOT EXISTS queue_state (\n    name TEXT PRIMARY KEY,\n    paused INTEGER NOT NULL DEFAULT 0,\n    rate_limit INTEGER,\n    concurrency_limit INTEGER\n);\n";
+export declare const SCHEMA = "\n-- Jobs table (using UUIDv7 for job IDs)\n-- Uses BLOB for data fields (MessagePack serialization for ~2-3x faster than JSON)\nCREATE TABLE IF NOT EXISTS jobs (\n    id TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    data BLOB NOT NULL,\n    priority INTEGER NOT NULL DEFAULT 0,\n    created_at INTEGER NOT NULL,\n    run_at INTEGER NOT NULL,\n    started_at INTEGER,\n    completed_at INTEGER,\n    attempts INTEGER NOT NULL DEFAULT 0,\n    max_attempts INTEGER NOT NULL DEFAULT 3,\n    backoff INTEGER NOT NULL DEFAULT 1000,\n    ttl INTEGER,\n    timeout INTEGER,\n    unique_key TEXT,\n    custom_id TEXT,\n    depends_on BLOB,\n    parent_id TEXT,\n    children_ids BLOB,\n    tags BLOB,\n    state TEXT NOT NULL DEFAULT 'waiting',\n    lifo INTEGER NOT NULL DEFAULT 0,\n    group_id TEXT,\n    progress INTEGER DEFAULT 0,\n    progress_msg TEXT,\n    remove_on_complete INTEGER DEFAULT 0,\n    remove_on_fail INTEGER DEFAULT 0,\n    stall_timeout INTEGER,\n    last_heartbeat INTEGER,\n    timeline BLOB,\n    stacktrace BLOB\n);\n\n-- Indexes for common queries\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_state\n    ON jobs(queue, state);\nCREATE INDEX IF NOT EXISTS idx_jobs_run_at\n    ON jobs(run_at) WHERE state IN ('waiting', 'delayed');\nCREATE INDEX IF NOT EXISTS idx_jobs_unique\n    ON jobs(queue, unique_key) WHERE unique_key IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_custom_id\n    ON jobs(custom_id) WHERE custom_id IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_parent\n    ON jobs(parent_id) WHERE parent_id IS NOT NULL;\n\n-- Job results storage (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS job_results (\n    job_id TEXT PRIMARY KEY,\n    result BLOB,\n    completed_at INTEGER NOT NULL\n);\n\n-- Dead letter queue (BLOB for MessagePack - stores full DlqEntry)\nCREATE TABLE IF NOT EXISTS dlq (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    job_id TEXT NOT NULL,\n    queue TEXT NOT NULL,\n    entry BLOB NOT NULL,\n    entered_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_dlq_queue ON dlq(queue);\nCREATE INDEX IF NOT EXISTS idx_dlq_job_id ON dlq(job_id);\nCREATE INDEX IF NOT EXISTS idx_dlq_entered_at ON dlq(entered_at);\n\n-- Performance indexes for high-throughput operations\n-- Stall detection: runs every 5s, needs fast lookup of active jobs by started_at\nCREATE INDEX IF NOT EXISTS idx_jobs_state_started\n    ON jobs(state, started_at) WHERE state = 'active';\n\n-- Group operations: fast lookup by group_id\nCREATE INDEX IF NOT EXISTS idx_jobs_group_id\n    ON jobs(group_id) WHERE group_id IS NOT NULL;\n\n-- Pending jobs: compound index for priority-ordered retrieval\nCREATE INDEX IF NOT EXISTS idx_jobs_pending_priority\n    ON jobs(queue, state, priority DESC, run_at ASC) WHERE state IN ('waiting', 'delayed');\n\n-- Completed jobs: index for recovery ordering (issue #84)\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_order\n    ON jobs(completed_at DESC) WHERE state = 'completed';\n\n-- Cron jobs (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS cron_jobs (\n    name TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    data BLOB NOT NULL,\n    schedule TEXT,\n    repeat_every INTEGER,\n    priority INTEGER NOT NULL DEFAULT 0,\n    next_run INTEGER NOT NULL,\n    executions INTEGER NOT NULL DEFAULT 0,\n    max_limit INTEGER,\n    timezone TEXT,\n    unique_key TEXT,\n    dedup BLOB,\n    skip_missed_on_restart INTEGER NOT NULL DEFAULT 0,\n    skip_if_no_worker INTEGER NOT NULL DEFAULT 0,\n    prevent_overlap INTEGER NOT NULL DEFAULT 1,\n    job_options BLOB\n);\n\n-- Queue state persistence (optional)\nCREATE TABLE IF NOT EXISTS queue_state (\n    name TEXT PRIMARY KEY,\n    paused INTEGER NOT NULL DEFAULT 0,\n    rate_limit INTEGER,\n    concurrency_limit INTEGER\n);\n";
 /** Migration version table */
 export declare const MIGRATION_TABLE = "\nCREATE TABLE IF NOT EXISTS migrations (\n    version INTEGER PRIMARY KEY,\n    applied_at INTEGER NOT NULL\n);\n";
 /** Current schema version */
-export declare const SCHEMA_VERSION = 12;
+export declare const SCHEMA_VERSION = 13;
 /** All migrations in order */
 export declare const MIGRATIONS: Record<number, string>;

package/dist/infrastructure/persistence/schema.js

@@ -44,7 +44,8 @@ CREATE TABLE IF NOT EXISTS jobs (
     remove_on_fail INTEGER DEFAULT 0,
     stall_timeout INTEGER,
     last_heartbeat INTEGER,
-    timeline BLOB
+    timeline BLOB,
+    stacktrace BLOB
 );
 
 -- Indexes for common queries
@@ -132,7 +133,7 @@ CREATE TABLE IF NOT EXISTS migrations (
 );
 `;
 /** Current schema version */
-export const SCHEMA_VERSION = 12;
+export const SCHEMA_VERSION = 13;
 /** All migrations in order */
 export const MIGRATIONS = {
     1: SCHEMA,
@@ -182,5 +183,9 @@ CREATE INDEX IF NOT EXISTS idx_jobs_completed_order
     // Migration 12: Add per-cron job options (retry/cleanup policy, issue #86)
     12: `
 ALTER TABLE cron_jobs ADD COLUMN job_options BLOB;
+`,
+    // Migration 13: Persist the last failure's stacktrace on jobs (issue #74)
+    13: `
+ALTER TABLE jobs ADD COLUMN stacktrace BLOB;
 `,
 };

package/dist/infrastructure/persistence/sqlite.js

@@ -332,8 +332,8 @@ export class SqliteStorage {
     updateForRetry(job) {
         this.safeWrite(() => {
             this.db
-                .prepare('UPDATE jobs SET attempts = ?, run_at = ?, state = ?, timeline = ? WHERE id = ?')
-                .run(job.attempts, job.runAt, 'waiting', job.timeline.length > 0 ? pack(job.timeline) : null, job.id);
+                .prepare('UPDATE jobs SET attempts = ?, run_at = ?, state = ?, timeline = ?, stacktrace = ? WHERE id = ?')
+                .run(job.attempts, job.runAt, 'waiting', job.timeline.length > 0 ? pack(job.timeline) : null, job.stacktrace && job.stacktrace.length > 0 ? pack(job.stacktrace) : null, job.id);
         });
     }
     deleteJob(jobId) {

package/dist/infrastructure/persistence/sqliteSerializer.js

@@ -121,6 +121,9 @@ export function rowToJob(row) {
         timeline: row.timeline
             ? unpack(row.timeline, [], `${jobContext}:timeline`)
             : [],
+        stacktrace: row.stacktrace
+            ? unpack(row.stacktrace, null, `${jobContext}:stacktrace`)
+            : null,
     };
     // Stamp a collision-proof corruption marker (non-enumerable Symbol, never
     // persisted) so the recovery path routes this job to the DLQ rather than
@@ -157,6 +160,8 @@ export function reconstructDlqEntry(entry) {
             dependsOn: entry.job.dependsOn.map((id) => brandId(id)),
             parentId: entry.job.parentId !== null ? brandId(entry.job.parentId) : null,
             childrenIds: entry.job.childrenIds.map((id) => brandId(id)),
+            // Pre-#74 blobs have no stacktrace field — restore the domain invariant
+            stacktrace: entry.job.stacktrace ?? null,
         },
     };
 }

package/dist/infrastructure/persistence/statements.d.ts

@@ -40,6 +40,7 @@ export interface DbJob {
     stall_timeout: number | null;
     last_heartbeat: number | null;
     timeline: Uint8Array | null;
+    stacktrace: Uint8Array | null;
 }
 /** Database row type for cron jobs */
 export interface DbCron {

package/dist/infrastructure/server/bootstrap.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Server bootstrap — the ONE place that boots a full bunqueue server.
+ * Used by both entry points (`bunqueue` bare via main.ts and
+ * `bunqueue start` via the CLI) so they cannot drift: S3 backup, cloud
+ * agent, stats interval, crash handlers and graceful shutdown are always on.
+ */
+import { type BunqueueConfig, type ResolvedConfig } from '../../config';
+/** Boot the full server from resolved configuration. Runs until shutdown. */
+export declare function bootServer(fileConfig: BunqueueConfig | null, config: ResolvedConfig): void;