@evomap/evolver-core 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/mailbox/dispatch.d.ts

@@ -1,6 +1,6 @@
 import type { Envelope } from './envelope.js';
 import type { Handler } from './catalog.js';
-import type { MailboxStore } from './store.js';
+import { type MailboxStore } from './store.js';
 export interface DispatchResult {
     id: string;
     handler: Handler;

package/dist/mailbox/dispatch.js

@@ -1,3 +1,4 @@
+import { mailboxClaimOwner } from './store.js';
 /**
  * 选择性 Material 判定(M2-7). 默认遵目录 feedsMaterial; 两类在 dispatch 决定:
  * - asset_publish_result: 仅 rejected 进(失败=养料 #40); 通过无需.
@@ -25,10 +26,16 @@ export class Dispatcher {
     }
     async dispatchOne(e) {
         const now = this.deps.now();
+        const claimOwner = mailboxClaimOwner(e);
+        if (!claimOwner) {
+            return { id: e.id, handler: e.handler, handled: false, fedMaterial: false, note: 'claim-owner-missing' };
+        }
         // 副作用幂等: 业务键(非默认=id)命中 → 跳过不二次执行, 直接 complete (money-safety A7/A13)
         const sideEffecting = e.handler !== 'agent' && e.idempotencyKey !== e.id;
         if (sideEffecting && this.deps.store.isProcessed(e.idempotencyKey)) {
-            this.deps.store.complete(e.id, now);
+            if (!this.deps.store.completeClaimed(e.id, now, claimOwner)) {
+                return { id: e.id, handler: e.handler, handled: false, fedMaterial: false, note: 'claim-lost' };
+            }
             return { id: e.id, handler: e.handler, handled: true, fedMaterial: false, note: 'idempotent-skip' };
         }
         try {
@@ -38,14 +45,23 @@ export class Dispatcher {
                 await this.deps.onMaterial(e);
                 fedMaterial = true;
             }
-            if (sideEffecting)
-                this.deps.store.markProcessed(e.idempotencyKey, result ?? null, now);
-            this.deps.store.complete(e.id, now);
+            const completed = sideEffecting
+                ? this.deps.store.completeClaimedAndMarkProcessed(e.id, e.idempotencyKey, result ?? null, now, claimOwner)
+                : this.deps.store.completeClaimed(e.id, now, claimOwner);
+            if (!completed) {
+                return { id: e.id, handler: e.handler, handled: false, fedMaterial, note: 'claim-lost' };
+            }
             return { id: e.id, handler: e.handler, handled: true, fedMaterial };
         }
         catch (err) {
-            this.deps.store.fail(e.id, err instanceof Error ? err.message : String(err), now);
-            return { id: e.id, handler: e.handler, handled: false, fedMaterial: false, note: 'failed' };
+            const failed = this.deps.store.failClaimed(e.id, err instanceof Error ? err.message : String(err), now, claimOwner);
+            return {
+                id: e.id,
+                handler: e.handler,
+                handled: false,
+                fedMaterial: false,
+                note: failed ? 'failed' : 'claim-lost',
+            };
         }
     }
     /** 拉一批并分派. 默认 daemon 侧 core+proxy; agent 由 runtime 经 IPC 拉取. */

package/dist/mailbox/envelope.d.ts

@@ -1,6 +1,8 @@
 import { specForType, type Direction, type Handler } from './catalog.js';
 export type Status = 'pending' | 'in_flight' | 'done' | 'failed' | 'expired';
-export declare const ENVELOPE_SCHEMA_VERSION = "1.0.0";
+export type Priority = 'high' | 'normal' | 'low';
+export declare const PRIORITIES: readonly ["high", "normal", "low"];
+export declare const ENVELOPE_SCHEMA_VERSION = "1.1.0";
 export interface Envelope {
     id: string;
     type: string;
@@ -15,6 +17,7 @@ export interface Envelope {
     sourceAgent: string;
     targetAgent: string;
     runtimeNamespace: string;
+    priority: Priority;
     attempts: number;
     nextRetryAt: number | null;
     ttlAt: number | null;
@@ -22,6 +25,7 @@ export interface Envelope {
     updatedAt: number;
     schemaVersion: string;
     feedsMaterial: boolean;
+    lastError: string | null;
 }
 /** 固定 envelope 字段集 (schema-snapshot 锁; 增删字段必须改此处). */
 export declare const ENVELOPE_FIELDS: readonly (keyof Envelope)[];
@@ -37,7 +41,9 @@ export interface CreateEnvelopeInput {
     sourceAgent?: string;
     targetAgent?: string;
     runtimeNamespace?: string;
+    priority?: unknown;
     now?: number;
 }
+export declare function normalizePriority(value: unknown): Priority;
 export declare function createEnvelope(input: CreateEnvelopeInput): Envelope;
 export { specForType };

package/dist/mailbox/envelope.js

@@ -1,11 +1,13 @@
 import { ulid as makeUlid } from 'ulid';
 import { specForType, assertKnownType } from './catalog.js';
-export const ENVELOPE_SCHEMA_VERSION = '1.0.0';
+export const PRIORITIES = Object.freeze(['high', 'normal', 'low']);
+export const ENVELOPE_SCHEMA_VERSION = '1.1.0';
 /** 固定 envelope 字段集 (schema-snapshot 锁; 增删字段必须改此处). */
 export const ENVELOPE_FIELDS = [
     'id', 'type', 'direction', 'status', 'handler', 'payload', 'correlationId', 'replyTo',
     'receiptId', 'idempotencyKey', 'sourceAgent', 'targetAgent', 'runtimeNamespace',
-    'attempts', 'nextRetryAt', 'ttlAt', 'createdAt', 'updatedAt', 'schemaVersion', 'feedsMaterial',
+    'priority', 'attempts', 'nextRetryAt', 'ttlAt', 'createdAt', 'updatedAt', 'schemaVersion', 'feedsMaterial',
+    'lastError',
 ];
 const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 /** 防原型污染 (v1 GHSA). */
@@ -22,6 +24,9 @@ export function sanitizePayload(v) {
     return v;
 }
 const TTL_MS = { control: 60 * 60 * 1000, default: 7 * 24 * 60 * 60 * 1000 };
+export function normalizePriority(value) {
+    return value === 'high' || value === 'low' ? value : 'normal';
+}
 export function createEnvelope(input) {
     const spec = assertKnownType(input.type);
     const id = input.id ?? makeUlid();
@@ -40,6 +45,7 @@ export function createEnvelope(input) {
         sourceAgent: input.sourceAgent ?? '',
         targetAgent: input.targetAgent ?? '',
         runtimeNamespace: input.runtimeNamespace ?? 'default',
+        priority: normalizePriority(input.priority),
         attempts: 0,
         nextRetryAt: null,
         ttlAt: now + TTL_MS[spec.ttlClass],
@@ -47,6 +53,7 @@ export function createEnvelope(input) {
         updatedAt: now,
         schemaVersion: ENVELOPE_SCHEMA_VERSION,
         feedsMaterial: spec.feedsMaterial,
+        lastError: null,
     };
 }
 export { specForType };

package/dist/mailbox/ipcServer.d.ts

@@ -1,11 +1,13 @@
 import { type IncomingMessage, type ServerResponse } from 'node:http';
 import { type Envelope } from './envelope.js';
-import type { MailboxStore } from './store.js';
+import { type MailboxStore } from './store.js';
 export interface IpcServerOptions {
     store: MailboxStore;
     token: string;
     host?: string;
     now?: () => number;
+    /** When set, every mailbox route is pinned to this daemon namespace. */
+    runtimeNamespace?: string;
     extraRoutes?: IpcRouteHandler[];
     onSend?: (envelope: Envelope, result: {
         receiptId: string;
@@ -20,6 +22,8 @@ export interface IpcRouteContext {
     route: string;
     now: number;
     store: MailboxStore;
+    /** 请求连接中止或响应提前关闭时触发；长任务应将其传给可取消的宿主执行器。 */
+    signal?: AbortSignal;
     readJson: () => Promise<unknown>;
     json: (code: number, body: unknown) => void;
 }
@@ -34,6 +38,7 @@ export declare class MailboxIpcServer {
     private readonly token;
     private readonly host;
     private readonly now;
+    private readonly runtimeNamespace;
     private readonly extraRoutes;
     private readonly onSend;
     private readonly onAuthFailure;
@@ -42,5 +47,10 @@ export declare class MailboxIpcServer {
     close(): Promise<void>;
     private handle;
     private readJson;
+    private resolveSendNamespace;
+    private resolveRuntimeNamespace;
+    private messageInRuntime;
+    private canMutateMessage;
     private json;
-}
+}
+export declare function legacyMailboxMessage(message: Envelope): Record<string, unknown>;

package/dist/mailbox/ipcServer.js

@@ -1,8 +1,33 @@
 import { createServer } from 'node:http';
 import { timingSafeEqual } from 'node:crypto';
 import { createEnvelope } from './envelope.js';
+import { mailboxClaimOwner } from './store.js';
 const MAX_BODY = 256 * 1024; // 256KB 上限(防本机注入超大体)
 const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+const STATUSES = new Set(['pending', 'in_flight', 'done', 'failed', 'expired']);
+const DIRECTIONS = new Set(['outbound', 'inbound', 'local']);
+const PRIORITIES = new Set(['high', 'normal', 'low']);
+function serializeClaimedMessage(message) {
+    const claimToken = mailboxClaimOwner(message);
+    if (!claimToken)
+        throw new Error('claimed mailbox message is missing its claim token');
+    return { ...message, claimToken };
+}
+function requiredClaimToken(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error('claimToken must be a non-empty string');
+    return value;
+}
+function optionalQueryInteger(url, name) {
+    const raw = url.searchParams.get(name);
+    if (raw === null)
+        return undefined;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) {
+        throw new Error(`${name} must be a non-negative integer`);
+    }
+    return value;
+}
 /** 定长常量时间比较(防 token 计时侧信道). */
 function tokenEq(a, b) {
     const ba = Buffer.from(a), bb = Buffer.from(b);
@@ -20,6 +45,7 @@ export class MailboxIpcServer {
     token;
     host;
     now;
+    runtimeNamespace;
     extraRoutes;
     onSend;
     onAuthFailure;
@@ -28,6 +54,7 @@ export class MailboxIpcServer {
         this.token = opts.token;
         this.host = opts.host ?? '127.0.0.1';
         this.now = opts.now ?? (() => Date.now());
+        this.runtimeNamespace = opts.runtimeNamespace;
         this.extraRoutes = opts.extraRoutes ?? [];
         this.onSend = opts.onSend;
         this.onAuthFailure = opts.onAuthFailure;
@@ -57,6 +84,20 @@ export class MailboxIpcServer {
         return new Promise((resolve, reject) => this.server.close((e) => (e ? reject(e) : resolve())));
     }
     async handle(req, res) {
+        const requestAbort = new AbortController();
+        const abortRequest = () => {
+            if (!requestAbort.signal.aborted)
+                requestAbort.abort(new Error('ipc_request_aborted'));
+        };
+        // 请求/响应 close 既可能表示客户端提前断开，也可能只是正常响应结束。
+        // 只有响应尚未完成时才传播取消，避免正常返回把后台验证误判为客户端取消。
+        const abortIfResponseOpen = () => {
+            if (!res.writableEnded && !res.writableFinished)
+                abortRequest();
+        };
+        req.once('aborted', abortIfResponseOpen);
+        req.socket.once('close', abortIfResponseOpen);
+        res.once('close', abortIfResponseOpen);
         try {
             const ra = req.socket.remoteAddress ?? '';
             if (!LOOPBACK.has(ra))
@@ -82,6 +123,7 @@ export class MailboxIpcServer {
                     route,
                     now,
                     store: this.store,
+                    signal: requestAbort.signal,
                     readJson: () => this.readJson(req),
                     json: (code, body) => this.json(res, code, body),
                 });
@@ -90,47 +132,109 @@ export class MailboxIpcServer {
             }
             if (route === 'POST /mailbox/send') {
                 const body = (await this.readJson(req));
-                const env = createEnvelope({ ...body, now });
+                if (body.priority !== undefined && !PRIORITIES.has(body.priority)) {
+                    throw new Error('priority must be high, normal, or low');
+                }
+                const legacyRef = typeof body.ref_id === 'string' && body.ref_id ? body.ref_id : undefined;
+                const runtimeNamespace = this.resolveSendNamespace(body);
+                let env = createEnvelope({
+                    ...body,
+                    runtimeNamespace,
+                    correlationId: body.correlationId ?? legacyRef,
+                    now,
+                });
+                if (body.expires_at !== undefined) {
+                    if (typeof body.expires_at !== 'number' || !Number.isFinite(body.expires_at)) {
+                        throw new Error('expires_at must be a finite epoch-millisecond number');
+                    }
+                    env = { ...env, ttlAt: body.expires_at };
+                }
                 const r = this.store.send(env);
                 if (r.stored)
                     this.onSend?.(env, r);
-                return this.json(res, 200, { id: env.id, receiptId: r.receiptId, stored: r.stored, correlationId: env.correlationId });
+                return this.json(res, 200, {
+                    id: env.id,
+                    receiptId: r.receiptId,
+                    stored: r.stored,
+                    correlationId: env.correlationId,
+                    message_id: env.id,
+                    status: env.status,
+                });
             }
             if (route === 'POST /mailbox/claim') {
                 const b = (await this.readJson(req));
-                const got = this.store.claim(b.handler, b.limit ?? 16, b.leaseMs ?? 30_000, now, b.runtimeNamespace);
-                return this.json(res, 200, { messages: got });
+                const runtimeNamespace = this.resolveRuntimeNamespace(b.runtimeNamespace);
+                const got = this.store.claim(b.handler, b.limit ?? 16, b.leaseMs ?? 30_000, now, runtimeNamespace);
+                return this.json(res, 200, { messages: got.map(serializeClaimedMessage) });
             }
             if (route === 'POST /mailbox/complete') {
                 const b = (await this.readJson(req));
-                this.store.complete(b.id, now);
+                if (!this.canMutateMessage(b.id))
+                    return this.json(res, 404, { error: 'not found' });
+                const claimToken = requiredClaimToken(b.claimToken);
+                if (!this.store.completeClaimed(b.id, now, claimToken)) {
+                    return this.json(res, 409, { error: 'mailbox claim is no longer owned by this worker', code: 'claim_conflict' });
+                }
                 return this.json(res, 200, { ok: true });
             }
             if (route === 'POST /mailbox/fail') {
                 const b = (await this.readJson(req));
-                this.store.fail(b.id, b.error ?? 'ipc fail', now);
+                if (!this.canMutateMessage(b.id))
+                    return this.json(res, 404, { error: 'not found' });
+                const claimToken = requiredClaimToken(b.claimToken);
+                if (!this.store.failClaimed(b.id, b.error ?? 'ipc fail', now, claimToken)) {
+                    return this.json(res, 409, { error: 'mailbox claim is no longer owned by this worker', code: 'claim_conflict' });
+                }
                 return this.json(res, 200, { ok: true });
             }
-            if (req.method === 'GET' && url.pathname === '/mailbox/status') {
-                const id = url.searchParams.get('id') ?? '';
+            const statusPathMatch = req.method === 'GET' ? /^\/mailbox\/status\/([^/]+)$/.exec(url.pathname) : null;
+            if (req.method === 'GET' && (url.pathname === '/mailbox/status' || statusPathMatch)) {
+                const id = statusPathMatch ? decodeURIComponent(statusPathMatch[1] ?? '') : url.searchParams.get('id') ?? '';
+                const message = this.messageInRuntime(id);
+                if (!message)
+                    return this.json(res, 404, { error: 'not found' });
+                if (statusPathMatch) {
+                    return this.json(res, 200, legacyMailboxMessage(message));
+                }
                 const s = this.store.getStatus(id);
                 return s ? this.json(res, 200, s) : this.json(res, 404, { error: 'not found' });
             }
             if (req.method === 'GET' && url.pathname === '/mailbox/list') {
-                const status = url.searchParams.get('status') ?? undefined;
+                const type = url.searchParams.get('type') ?? undefined;
+                const legacy = type !== undefined;
+                const rawStatus = url.searchParams.get('status') ?? undefined;
+                const statusValue = legacyMailboxStatus(rawStatus);
+                if (rawStatus !== undefined && statusValue === undefined)
+                    throw new Error('invalid status');
+                const directionValue = url.searchParams.get('direction') ?? undefined;
+                if (directionValue !== undefined && !DIRECTIONS.has(directionValue)) {
+                    throw new Error('invalid direction');
+                }
                 const got = this.store.list({
-                    status: status,
+                    status: statusValue,
                     handler: url.searchParams.get('handler') ?? undefined,
-                    runtimeNamespace: url.searchParams.get('runtimeNamespace') ?? undefined,
-                    limit: Number(url.searchParams.get('limit') ?? 200),
+                    runtimeNamespace: this.resolveRuntimeNamespace(url.searchParams.get('runtimeNamespace') ?? undefined),
+                    type,
+                    direction: directionValue,
+                    newestFirst: legacy,
+                    offset: optionalQueryInteger(url, 'offset'),
+                    limit: optionalQueryInteger(url, 'limit') ?? 200,
+                });
+                return this.json(res, 200, {
+                    messages: legacy ? got.map(legacyMailboxMessage) : got,
+                    count: got.length,
                 });
-                return this.json(res, 200, { messages: got });
             }
             return this.json(res, 404, { error: 'unknown route' });
         }
         catch (e) {
             return this.json(res, 400, { error: e instanceof Error ? e.message : String(e), code: 'invalid_request' });
         }
+        finally {
+            req.off('aborted', abortIfResponseOpen);
+            req.socket.off('close', abortIfResponseOpen);
+            res.off('close', abortIfResponseOpen);
+        }
     }
     readJson(req) {
         return new Promise((resolve, reject) => {
@@ -161,8 +265,74 @@ export class MailboxIpcServer {
             req.on('error', reject);
         });
     }
+    resolveSendNamespace(body) {
+        const bound = this.runtimeNamespace;
+        if (bound === undefined)
+            return body.runtimeNamespace;
+        const requested = body.runtimeNamespace;
+        if (requested !== undefined && (typeof requested !== 'string' || requested !== bound)) {
+            throw new Error('runtimeNamespace does not match the IPC server namespace');
+        }
+        const channel = body.channel;
+        if (channel !== undefined && (typeof channel !== 'string'
+            || (channel !== 'evomap-hub' && channel !== bound))) {
+            throw new Error('channel does not match the IPC server namespace');
+        }
+        return bound;
+    }
+    resolveRuntimeNamespace(requested) {
+        if (requested !== undefined && typeof requested !== 'string') {
+            throw new Error('runtimeNamespace must be a string');
+        }
+        const bound = this.runtimeNamespace;
+        if (bound === undefined)
+            return requested;
+        if (requested !== undefined && requested !== bound) {
+            throw new Error('runtimeNamespace does not match the IPC server namespace');
+        }
+        return bound;
+    }
+    messageInRuntime(id) {
+        const message = this.store.getById(id);
+        if (this.runtimeNamespace !== undefined && message?.runtimeNamespace !== this.runtimeNamespace)
+            return undefined;
+        return message;
+    }
+    canMutateMessage(id) {
+        return this.messageInRuntime(id) !== undefined;
+    }
     json(res, code, body) {
         res.writeHead(code, { 'content-type': 'application/json' });
         res.end(JSON.stringify(body));
     }
+}
+export function legacyMailboxMessage(message) {
+    return {
+        id: message.id,
+        message_id: message.id,
+        channel: message.runtimeNamespace === 'default' ? 'evomap-hub' : message.runtimeNamespace,
+        direction: message.direction,
+        type: message.type,
+        status: message.status === 'done' ? (message.direction === 'inbound' ? 'delivered' : 'synced') : message.status,
+        payload: message.payload,
+        priority: message.priority,
+        ref_id: message.replyTo ?? message.correlationId,
+        created_at: message.createdAt,
+        synced_at: message.status === 'done' ? message.updatedAt : null,
+        expires_at: message.ttlAt,
+        retry_count: message.attempts,
+        next_retry_at: message.nextRetryAt,
+        error: message.lastError,
+    };
+}
+function legacyMailboxStatus(value) {
+    if (value === undefined)
+        return undefined;
+    if (STATUSES.has(value))
+        return value;
+    if (value === 'delivered' || value === 'synced' || value === 'acked')
+        return 'done';
+    if (value === 'rejected')
+        return 'failed';
+    return undefined;
 }

package/dist/mailbox/store.d.ts

@@ -1,7 +1,59 @@
 import { type Envelope, type Status, type CreateEnvelopeInput } from './envelope.js';
 export declare const MAX_ATTEMPTS = 5;
 export declare const DEFAULT_IMPORT_JSONL_MAX_LINE_BYTES: number;
+export declare const DEFAULT_IMPORT_JSONL_MAX_BYTES: number;
+export declare const DEFAULT_IMPORT_JSONL_MAX_RECORDS = 100000;
+export declare const MAILBOX_CLAIM_OWNER: unique symbol;
+export type ClaimedEnvelope = Envelope & {
+    readonly [MAILBOX_CLAIM_OWNER]: string;
+};
+export type MailboxImportRecord = Readonly<{
+    kind: 'message';
+    envelope: Readonly<Envelope>;
+}> | Readonly<{
+    kind: 'update';
+    id: string;
+    fields: Readonly<Record<string, unknown>>;
+}>;
+export type PreparedMailboxImport = Readonly<{
+    records: readonly MailboxImportRecord[];
+    sourceRecords: number;
+    messageCandidates: number;
+    uniqueMessageCandidates: number;
+    updateCandidates: number;
+}>;
+export type MailboxImportPreview = Readonly<{
+    sourceRecords: number;
+    messageCandidates: number;
+    uniqueMessageCandidates: number;
+    updateCandidates: number;
+    insertedMessages: number;
+    updatedMessages: number;
+    managedMessages: number;
+    protectedMessages: number;
+}>;
+export type MailboxJsonlImportErrorCode = 'line_too_large' | 'journal_too_large' | 'too_many_records' | 'invalid_utf8' | 'invalid_json' | 'invalid_record' | 'invalid_update' | 'unsupported_operation' | 'invalid_message';
+export declare class MailboxJsonlImportError extends Error {
+    readonly code: MailboxJsonlImportErrorCode;
+    readonly line: number;
+    constructor(code: MailboxJsonlImportErrorCode, line: number, message: string);
+}
+export declare function mailboxClaimOwner(envelope: Envelope): string | undefined;
 export declare function expBackoffMs(attempt: number): number;
+/** Read one mailbox state value without creating, migrating, or taking write ownership of the database. */
+export declare function readMailboxState(path: string, key: string): string | undefined;
+/**
+ * Parse and normalize a V1 mailbox journal without opening or mutating a V2 mailbox.
+ * The returned batch is sealed so dry-run and apply can consume the exact same records.
+ */
+export declare function prepareMailboxJsonlImport(source: string | number, options?: {
+    maxLineBytes?: number;
+    maxBytes?: number;
+    maxRecords?: number;
+    now?: number;
+}): PreparedMailboxImport;
+/** Preview a prepared import against an optional existing mailbox without creating or migrating it. */
+export declare function previewPreparedMailboxImport(batch: PreparedMailboxImport, mailboxPath?: string): MailboxImportPreview;
 /** mailbox sqlite 引擎 (WAL + busy_timeout). 状态机 pending→in_flight→done/failed/expired + 租约 + 重试/DLQ. */
 export declare class MailboxStore {
     private readonly db;
@@ -47,12 +99,31 @@ export declare class MailboxStore {
     hasMessageWithIdempotencyKey(idempotencyKey: string): boolean;
     hasMessageWithPayload(type: string, payload: unknown): boolean;
     /** 原子 claim: pending(或租约过期的 in_flight) → in_flight + 租约. 可按 runtimeNamespace 分区. */
-    claim(handler: string, limit: number, leaseMs: number, now: number, runtimeNamespace?: string): Envelope[];
+    claim(handler: string, limit: number, leaseMs: number, now: number, runtimeNamespace?: string): ClaimedEnvelope[];
     complete(id: string, now: number): void;
     /** 失败: attempts<N→退避回 pending; ≥N→DLQ(不自动丢). */
     fail(id: string, err: string, now: number, maxAttempts?: number): void;
     /** 暂缓: transient upstream outage 不消耗 attempts, 仅设置下次可 claim 时间. */
     defer(id: string, err: string, now: number, retryAfterMs: number): void;
+    deferUnlessProcessed(id: string, processedKey: string, err: string, now: number, retryAfterMs: number): boolean;
+    failUnlessProcessed(id: string, processedKey: string, err: string, now: number, maxAttempts?: number): boolean;
+    completeClaimed(id: string, now: number, claimOwner: string): boolean;
+    /** Atomically complete the current worker's lease and persist its idempotency result. */
+    completeClaimedAndMarkProcessed(id: string, processedKey: string, result: unknown, now: number, claimOwner: string): boolean;
+    renewClaim(id: string, now: number, leaseMs: number, claimOwner: string): boolean;
+    setClaimedCheckpoint(id: string, checkpoint: unknown, now: number, claimOwner: string): boolean;
+    getClaimedCheckpoint(id: string): unknown | undefined;
+    deferClaimed(id: string, err: string, now: number, retryAfterMs: number, claimOwner: string): boolean;
+    failClaimed(id: string, err: string, now: number, claimOwner: string, maxAttempts?: number): boolean;
+    /** Transition only the row held by the current worker, unless a concurrent success marker already exists. */
+    deferClaimedUnlessProcessed(id: string, processedKey: string, err: string, now: number, retryAfterMs: number, claimOwner: string): boolean;
+    /** Transition only the row held by the current worker, unless a concurrent success marker already exists. */
+    failClaimedUnlessProcessed(id: string, processedKey: string, err: string, now: number, claimOwner: string, maxAttempts?: number): boolean;
+    /** Atomically fail a non-leased intent and persist the replayable terminal result. */
+    failAndMarkProcessedUnlessProcessed(id: string, blockingProcessedKeys: readonly string[], resultKey: string, result: unknown, err: string, now: number, maxAttempts?: number): boolean;
+    /** Atomically fail the current worker's leased intent and persist the replayable terminal result. */
+    failClaimedAndMarkProcessedUnlessProcessed(id: string, blockingProcessedKeys: readonly string[], resultKey: string, result: unknown, err: string, now: number, claimOwner: string, maxAttempts?: number): boolean;
+    private transitionUnlessProcessed;
     /** DLQ 重放(人工/agent 显式, 不自动丢). */
     replayDlq(id: string, now: number): void;
     dlq(): Envelope[];
@@ -73,16 +144,31 @@ export declare class MailboxStore {
         id: string;
         type: string;
         status: Status;
+        priority: Envelope['priority'];
         attempts: number;
         nextRetryAt: number | null;
         ttlAt: number | null;
         dlq: boolean;
+        lastError: string | null;
     } | undefined;
     /** 幂等(A13): 副作用 handler 用 idempotencyKey 去重; 命中返缓存不重跑. */
     isProcessed(key: string): boolean;
     getProcessed(key: string): unknown;
     markProcessed(key: string, result: unknown, now: number): void;
-    /** v1 messages.jsonl → sqlite 迁移(幂等可重入). */
-    importJsonl(path: string): number;
+    replaceProcessed(key: string, result: unknown, now: number): void;
+    /** Persist a monotonic outcome and its lightweight concurrency marker in one SQLite transaction. */
+    replaceProcessedWithMarker(key: string, result: unknown, markerKey: string, markerResult: unknown, now: number): void;
+    /** Backfill a concurrency marker only when the durable source result still satisfies the caller's predicate. */
+    markProcessedIf(sourceKey: string, markerKey: string, markerResult: unknown, now: number, matches: (sourceResult: unknown) => boolean): boolean;
+    deleteProcessed(keys: readonly string[]): void;
+    private messageClaimOwner;
+    /** Build the target-aware plan shared by preview and apply. */
+    private buildPreparedImportPlan;
+    /** Preview the exact import result against the current mailbox snapshot without writing to it. */
+    previewPreparedImport(batch: PreparedMailboxImport): MailboxImportPreview;
+    private writeImportedEnvelopeFields;
+    /** Apply a parsed batch; planning and writes share one transaction and one normalized journal. */
+    importPrepared(batch: PreparedMailboxImport): number;
+    importJsonl(source: string | number): number;
     close(): void;
 }