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

package/dist/sync/engine.d.ts

@@ -23,6 +23,13 @@ export interface SyncEngineDeps {
     onOutboundSucceeded?: (envelope: Envelope, result: unknown) => void | Promise<void>;
     /** Cache a durable facade terminal result after SyncEngine moved the envelope to DLQ. */
     onOutboundTerminal?: (envelope: Envelope, error: unknown) => void | Promise<void>;
+    /** Return the durable marker that proves a racing facade request already reached external acceptance. */
+    acceptedOutcomeKey?: (envelope: Envelope) => string | undefined;
+    /** Return a replayable terminal result that must be committed atomically with the mailbox DLQ transition. */
+    terminalOutcome?: (envelope: Envelope, error: unknown) => {
+        key: string;
+        result: unknown;
+    } | undefined;
     /** Canonicalize an inbound envelope before durable insertion. */
     normalizeInboundEnvelope?: (envelope: Envelope) => Envelope;
     onOutboundFlushed?: (result: OutboundResult) => void | Promise<void>;
@@ -44,6 +51,7 @@ export interface InboundResult {
 }
 export declare class SyncEngine {
     private readonly deps;
+    private readonly acceptedTaskOutboundMemory;
     private lastActivityAt;
     constructor(deps: SyncEngineDeps);
     /** 出站: claim proxy 消息 → 经 proxyHandler 推 hub → complete; 终态(publish reject)直进 DLQ 不重试(money-safety). */
@@ -59,6 +67,10 @@ export declare class SyncEngine {
     private notifyOutboundFlushed;
     private normalizeOutbound;
     private outboundDedupKey;
+    private acceptedTaskOutbound;
+    private durableAcceptedTaskOutbound;
+    private completeAcceptedOutcome;
+    private rememberAcceptedTaskOutbound;
     private safeAck;
     /** AgentEvent → core Envelope; 未知类型(不在目录)跳过. */
     private toEnvelope;

package/dist/sync/engine.js

@@ -9,6 +9,9 @@ export const MAX_BATCH = 50;
 export const IDLE_THRESHOLD_MS = 5 * 60_000;
 const MAX_SYNC_ERROR_LENGTH = 2_000;
 const CURSOR_KEY = 'sync:inbound_cursor';
+const ACCEPTED_TASK_OUTBOUND_PREFIX = 'sync:accepted_task_outbound:';
+const ACCEPTED_TASK_JOURNAL_WRITE_ATTEMPTS = 2;
+const LOCAL_FINALIZE_RETRY_MS = 1_000;
 const BATCHABLE_PROXY_TYPES = new Set(['proxy_trace']);
 const TRACE_CONFIG_TYPES = new Set(['trace_collection_config', 'proxy_trace_config']);
 const STATE = {
@@ -95,6 +98,12 @@ function envelopeToAgentEvent(e) {
         ...(e.type === 'proxy_trace' && e.idempotencyKey ? { refId: e.idempotencyKey } : {}),
     };
 }
+function requiredClaimOwner(envelope) {
+    const claimOwner = mailbox.mailboxClaimOwner(envelope);
+    if (!claimOwner)
+        throw new Error(`mailbox_claim_owner_missing:${envelope.id}`);
+    return claimOwner;
+}
 /**
  * SyncEngine(M6-2): proxy↔hub 双向同步. 移植 v1 sync/{engine,outbound,inbound} 到 TS,
  * hub I/O 全走 HubCapability.mailbox(非裸 hubFetch). tick 方法纯逻辑(注入 now), 可对 FakeHubCapability 确定性测;
@@ -104,7 +113,13 @@ function applyMailboxPushManyOutcomes(group, outcomes, deps) {
     const byId = new Map(outcomes.map((outcome) => [outcome.id, outcome]));
     const result = { sent: 0, failed: 0, terminal: 0, deferred: 0, completedDuplicates: 0 };
     for (const pushed of group) {
-        const outcome = byId.get(pushed.event.id) ?? byId.get(pushed.original.id);
+        const outcome = byId.get(pushed.event.id) ?? byId.get(pushed.original.id) ?? {
+            id: pushed.event.id,
+            status: 'failed',
+            reason: 'mailbox_response_incomplete',
+            retryable: true,
+            terminal: false,
+        };
         if (outcome?.status === 'failed') {
             const msg = redactAndTruncate(outcome.reason ?? 'mailbox_push_rejected');
             const authLike = isAuthError(msg);
@@ -119,36 +134,47 @@ function applyMailboxPushManyOutcomes(group, outcomes, deps) {
                     result.authFailed = true;
                     result.authErrorMessage ??= msg;
                 }
-                deps.store.defer(pushed.original.id, msg, nowAfterFailure, retry);
-                for (const duplicate of pushed.duplicates)
-                    deps.store.defer(duplicate.id, msg, nowAfterFailure, retry);
-                result.deferred += 1 + pushed.duplicates.length;
+                if (deps.store.deferClaimed(pushed.original.id, msg, nowAfterFailure, retry, requiredClaimOwner(pushed.original)))
+                    result.deferred += 1;
+                for (const duplicate of pushed.duplicates) {
+                    if (deps.store.deferClaimed(duplicate.id, msg, nowAfterFailure, retry, requiredClaimOwner(duplicate))) {
+                        result.deferred += 1;
+                    }
+                }
             }
             else {
                 const maxAttempts = outcome.terminal ? 1 : undefined;
-                deps.store.fail(pushed.original.id, msg, deps.now(), maxAttempts);
-                for (const duplicate of pushed.duplicates)
-                    deps.store.fail(duplicate.id, msg, deps.now(), maxAttempts);
+                let transitioned = deps.store.failClaimed(pushed.original.id, msg, deps.now(), requiredClaimOwner(pushed.original), maxAttempts) ? 1 : 0;
+                for (const duplicate of pushed.duplicates) {
+                    if (deps.store.failClaimed(duplicate.id, msg, deps.now(), requiredClaimOwner(duplicate), maxAttempts)) {
+                        transitioned += 1;
+                    }
+                }
                 if (outcome.terminal)
-                    result.terminal += 1 + pushed.duplicates.length;
+                    result.terminal += transitioned;
                 else
-                    result.failed += 1 + pushed.duplicates.length;
+                    result.failed += transitioned;
             }
         }
         else {
-            deps.store.complete(pushed.original.id, deps.now());
-            for (const duplicate of pushed.duplicates)
-                deps.store.complete(duplicate.id, deps.now());
+            const completedOriginal = deps.store.completeClaimed(pushed.original.id, deps.now(), requiredClaimOwner(pushed.original));
+            let completedDuplicates = 0;
+            for (const duplicate of pushed.duplicates) {
+                if (deps.store.completeClaimed(duplicate.id, deps.now(), requiredClaimOwner(duplicate)))
+                    completedDuplicates += 1;
+            }
             if (pushed.dedupKey)
                 deps.store.markProcessed(pushed.dedupKey, { type: pushed.original.type }, deps.now());
-            result.sent += 1;
-            result.completedDuplicates += pushed.duplicates.length;
+            if (completedOriginal)
+                result.sent += 1;
+            result.completedDuplicates += completedDuplicates;
         }
     }
     return result;
 }
 export class SyncEngine {
     deps;
+    acceptedTaskOutboundMemory = new Map();
     lastActivityAt;
     constructor(deps) {
         this.deps = deps;
@@ -160,6 +186,7 @@ export class SyncEngine {
         const batch = this.deps.store.claim('proxy', limit, this.deps.leaseMs ?? 30_000, now, this.deps.runtimeNamespace);
         let sent = 0, failed = 0, terminal = 0, deferred = 0, completedDuplicates = 0;
         let authFailed = false;
+        let localPersistenceFailed = false;
         let authErrorMessage; // first auth-failure detail, carried up so the daemon surfaces the real code (#314)
         for (let i = 0; i < batch.length; i += 1) {
             const e = batch[i];
@@ -173,8 +200,9 @@ export class SyncEngine {
                         break;
                     const outboundDedupKey = this.outboundDedupKey(current);
                     if (outboundDedupKey && this.deps.store.isProcessed(outboundDedupKey)) {
-                        this.deps.store.complete(current.id, this.deps.now());
-                        completedDuplicates += 1;
+                        if (this.deps.store.completeClaimed(current.id, this.deps.now(), requiredClaimOwner(current))) {
+                            completedDuplicates += 1;
+                        }
                         continue;
                     }
                     const existing = outboundDedupKey ? groupByDedupKey.get(outboundDedupKey) : undefined;
@@ -184,8 +212,9 @@ export class SyncEngine {
                     }
                     const guard = this.normalizeOutbound(current);
                     if (!guard.ok) {
-                        this.deps.store.fail(current.id, guard.reason, this.deps.now(), 1);
-                        terminal += 1;
+                        if (this.deps.store.failClaimed(current.id, guard.reason, this.deps.now(), requiredClaimOwner(current), 1)) {
+                            terminal += 1;
+                        }
                         continue;
                     }
                     const entry = {
@@ -220,22 +249,24 @@ export class SyncEngine {
                         if (applied.deferredFailure) {
                             const nowAfterFailure = this.deps.now();
                             for (const pending of batch.slice(j)) {
-                                this.deps.store.defer(pending.id, applied.deferredFailure.msg, nowAfterFailure, applied.deferredFailure.retryAfterMs);
-                                deferred += 1;
+                                if (this.deps.store.deferClaimed(pending.id, applied.deferredFailure.msg, nowAfterFailure, applied.deferredFailure.retryAfterMs, requiredClaimOwner(pending)))
+                                    deferred += 1;
                             }
                             break;
                         }
                     }
                     else {
                         for (const pushed of group) {
-                            this.deps.store.complete(pushed.original.id, this.deps.now());
-                            for (const duplicate of pushed.duplicates)
-                                this.deps.store.complete(duplicate.id, this.deps.now());
+                            if (this.deps.store.completeClaimed(pushed.original.id, this.deps.now(), requiredClaimOwner(pushed.original)))
+                                sent += 1;
+                            for (const duplicate of pushed.duplicates) {
+                                if (this.deps.store.completeClaimed(duplicate.id, this.deps.now(), requiredClaimOwner(duplicate))) {
+                                    completedDuplicates += 1;
+                                }
+                            }
                             if (pushed.dedupKey)
                                 this.deps.store.markProcessed(pushed.dedupKey, { type: pushed.original.type }, this.deps.now());
-                            completedDuplicates += pushed.duplicates.length;
                         }
-                        sent += group.length;
                     }
                     i = j - 1;
                     continue;
@@ -248,14 +279,17 @@ export class SyncEngine {
                         const nowAfterFailure = this.deps.now();
                         const retry = retryAfterMs(err);
                         for (const pushed of group) {
-                            this.deps.store.defer(pushed.original.id, msg, nowAfterFailure, retry);
-                            for (const duplicate of pushed.duplicates)
-                                this.deps.store.defer(duplicate.id, msg, nowAfterFailure, retry);
-                            deferred += 1 + pushed.duplicates.length;
+                            if (this.deps.store.deferClaimed(pushed.original.id, msg, nowAfterFailure, retry, requiredClaimOwner(pushed.original)))
+                                deferred += 1;
+                            for (const duplicate of pushed.duplicates) {
+                                if (this.deps.store.deferClaimed(duplicate.id, msg, nowAfterFailure, retry, requiredClaimOwner(duplicate)))
+                                    deferred += 1;
+                            }
                         }
                         for (const pending of batch.slice(j)) {
-                            this.deps.store.defer(pending.id, msg, nowAfterFailure, retry);
-                            deferred += 1;
+                            if (this.deps.store.deferClaimed(pending.id, msg, nowAfterFailure, retry, requiredClaimOwner(pending))) {
+                                deferred += 1;
+                            }
                         }
                         authFailed = true;
                         authErrorMessage ??= msg;
@@ -263,10 +297,12 @@ export class SyncEngine {
                     }
                     else if (isTerminal(err, group[0].original.type)) {
                         for (const pushed of group) {
-                            this.deps.store.fail(pushed.original.id, msg, this.deps.now(), 1);
-                            for (const duplicate of pushed.duplicates)
-                                this.deps.store.fail(duplicate.id, msg, this.deps.now(), 1);
-                            terminal += 1 + pushed.duplicates.length;
+                            if (this.deps.store.failClaimed(pushed.original.id, msg, this.deps.now(), requiredClaimOwner(pushed.original), 1))
+                                terminal += 1;
+                            for (const duplicate of pushed.duplicates) {
+                                if (this.deps.store.failClaimed(duplicate.id, msg, this.deps.now(), requiredClaimOwner(duplicate), 1))
+                                    terminal += 1;
+                            }
                         }
                         i = j - 1;
                     }
@@ -274,23 +310,27 @@ export class SyncEngine {
                         const nowAfterFailure = this.deps.now();
                         const retry = retryAfterMs(err);
                         for (const pushed of group) {
-                            this.deps.store.defer(pushed.original.id, msg, nowAfterFailure, retry);
-                            for (const duplicate of pushed.duplicates)
-                                this.deps.store.defer(duplicate.id, msg, nowAfterFailure, retry);
-                            deferred += 1 + pushed.duplicates.length;
+                            if (this.deps.store.deferClaimed(pushed.original.id, msg, nowAfterFailure, retry, requiredClaimOwner(pushed.original)))
+                                deferred += 1;
+                            for (const duplicate of pushed.duplicates) {
+                                if (this.deps.store.deferClaimed(duplicate.id, msg, nowAfterFailure, retry, requiredClaimOwner(duplicate)))
+                                    deferred += 1;
+                            }
                         }
                         for (const pending of batch.slice(j)) {
-                            this.deps.store.defer(pending.id, msg, nowAfterFailure, retry);
-                            deferred += 1;
+                            if (this.deps.store.deferClaimed(pending.id, msg, nowAfterFailure, retry, requiredClaimOwner(pending)))
+                                deferred += 1;
                         }
                         break;
                     }
                     else {
                         for (const pushed of group) {
-                            this.deps.store.fail(pushed.original.id, msg, this.deps.now());
-                            for (const duplicate of pushed.duplicates)
-                                this.deps.store.fail(duplicate.id, msg, this.deps.now());
-                            failed += 1 + pushed.duplicates.length;
+                            if (this.deps.store.failClaimed(pushed.original.id, msg, this.deps.now(), requiredClaimOwner(pushed.original)))
+                                failed += 1;
+                            for (const duplicate of pushed.duplicates) {
+                                if (this.deps.store.failClaimed(duplicate.id, msg, this.deps.now(), requiredClaimOwner(duplicate)))
+                                    failed += 1;
+                            }
                         }
                         i = j - 1;
                     }
@@ -299,25 +339,99 @@ export class SyncEngine {
             }
             const outboundDedupKey = this.outboundDedupKey(e);
             if (outboundDedupKey && this.deps.store.isProcessed(outboundDedupKey)) {
-                this.deps.store.complete(e.id, this.deps.now());
-                completedDuplicates += 1;
+                if (this.deps.store.completeClaimed(e.id, this.deps.now(), requiredClaimOwner(e)))
+                    completedDuplicates += 1;
                 continue;
             }
             const guard = this.normalizeOutbound(e);
             if (!guard.ok) {
-                this.deps.store.fail(e.id, redactAndTruncate(guard.reason), this.deps.now(), 1);
-                terminal += 1;
+                if (this.deps.store.failClaimed(e.id, redactAndTruncate(guard.reason), this.deps.now(), requiredClaimOwner(e), 1))
+                    terminal += 1;
                 continue;
             }
+            const claimOwner = requiredClaimOwner(e);
+            let handlerResult;
+            let hubAccepted = false;
             try {
-                const handlerResult = await this.deps.proxyHandler(guard.envelope);
-                await this.deps.onOutboundSucceeded?.(e, handlerResult);
-                this.deps.store.complete(e.id, this.deps.now());
+                const accepted = this.acceptedTaskOutbound(e);
+                handlerResult = accepted ? accepted.result : await this.deps.proxyHandler(guard.envelope);
+                hubAccepted = true;
+                let journalError;
+                try {
+                    this.rememberAcceptedTaskOutbound(e, handlerResult);
+                }
+                catch (err) {
+                    journalError = `accepted_journal: ${safeErrorMessage(err)}`;
+                }
+                if (!this.deps.store.renewClaim(e.id, this.deps.now(), this.deps.leaseMs ?? 30_000, claimOwner))
+                    continue;
+                try {
+                    await this.deps.onOutboundSucceeded?.(e, handlerResult);
+                }
+                catch (err) {
+                    const msg = `local_finalize: ${safeErrorMessage(err)}`;
+                    localPersistenceFailed = true;
+                    if (journalError && !this.durableAcceptedTaskOutbound(e)) {
+                        try {
+                            this.rememberAcceptedTaskOutbound(e, handlerResult);
+                            journalError = undefined;
+                        }
+                        catch (retryError) {
+                            journalError = `accepted_journal_retry: ${safeErrorMessage(retryError)}`;
+                            this.markError(journalError, false);
+                        }
+                    }
+                    this.markError(msg, false);
+                    if (this.durableAcceptedTaskOutbound(e)) {
+                        if (this.deps.store.deferClaimed(e.id, msg, this.deps.now(), LOCAL_FINALIZE_RETRY_MS, claimOwner)) {
+                            deferred += 1;
+                        }
+                        continue;
+                    }
+                    // The Hub has already accepted this envelope. A local observer must not cause a second external action.
+                }
+                if (!this.deps.store.completeClaimed(e.id, this.deps.now(), claimOwner))
+                    continue;
+                this.acceptedTaskOutboundMemory.delete(e.id);
                 if (outboundDedupKey)
                     this.deps.store.markProcessed(outboundDedupKey, { type: e.type }, this.deps.now());
+                if (journalError)
+                    this.markError(journalError, false);
+                if (journalError)
+                    localPersistenceFailed = true;
                 sent += 1;
             }
             catch (err) {
+                if (hubAccepted) {
+                    if (this.deps.store.getById(e.id)?.status === 'done') {
+                        this.acceptedTaskOutboundMemory.delete(e.id);
+                        sent += 1;
+                        continue;
+                    }
+                    const msg = `local_finalize: ${safeErrorMessage(err)}`;
+                    localPersistenceFailed = true;
+                    if (!this.durableAcceptedTaskOutbound(e)) {
+                        try {
+                            this.rememberAcceptedTaskOutbound(e, handlerResult);
+                        }
+                        catch (journalRetryError) {
+                            this.markError(`accepted_journal_retry: ${safeErrorMessage(journalRetryError)}`, false);
+                        }
+                    }
+                    this.markError(msg, false);
+                    if (this.durableAcceptedTaskOutbound(e)) {
+                        if (this.deps.store.deferClaimed(e.id, msg, this.deps.now(), LOCAL_FINALIZE_RETRY_MS, claimOwner)) {
+                            deferred += 1;
+                        }
+                    }
+                    else {
+                        // No durable local replay is possible for this callback, but the external action is already complete.
+                        if (this.deps.store.completeClaimed(e.id, this.deps.now(), claimOwner))
+                            sent += 1;
+                        this.acceptedTaskOutboundMemory.delete(e.id);
+                    }
+                    continue;
+                }
                 const msg = safeErrorMessage(err);
                 const authLike = isAuthError(err);
                 this.markError(`outbound: ${msg}`, authLike);
@@ -325,18 +439,34 @@ export class SyncEngine {
                     const nowAfterFailure = this.deps.now();
                     const retry = retryAfterMs(err);
                     for (const pending of batch.slice(i)) {
-                        this.deps.store.defer(pending.id, msg, nowAfterFailure, retry); // Auth recovery owns retries; mailbox attempts stay intact.
-                        deferred += 1;
+                        const acceptedKey = this.deps.acceptedOutcomeKey?.(pending);
+                        const pendingClaimOwner = requiredClaimOwner(pending);
+                        const transitioned = acceptedKey
+                            ? this.deps.store.deferClaimedUnlessProcessed(pending.id, acceptedKey, msg, nowAfterFailure, retry, pendingClaimOwner)
+                            : this.deps.store.deferClaimed(pending.id, msg, nowAfterFailure, retry, pendingClaimOwner);
+                        if (transitioned)
+                            deferred += 1;
+                        else if (this.completeAcceptedOutcome(pending))
+                            sent += 1;
                     }
                     authFailed = true;
                     authErrorMessage ??= msg;
                     break;
                 }
                 else if (isTerminal(err, e.type)) {
-                    // A concurrent facade attempt may already have finalized this durable intent successfully.
-                    if (this.deps.store.getById(e.id)?.status === 'done')
+                    const transitionNow = this.deps.now();
+                    const acceptedKey = this.deps.acceptedOutcomeKey?.(e);
+                    const terminalOutcome = this.deps.terminalOutcome?.(e, err);
+                    const transitioned = acceptedKey && terminalOutcome
+                        ? this.deps.store.failClaimedAndMarkProcessedUnlessProcessed(e.id, [acceptedKey], terminalOutcome.key, terminalOutcome.result, msg, transitionNow, claimOwner, 1)
+                        : acceptedKey
+                            ? this.deps.store.failClaimedUnlessProcessed(e.id, acceptedKey, msg, transitionNow, claimOwner, 1)
+                            : this.deps.store.failClaimed(e.id, msg, transitionNow, claimOwner, 1);
+                    if (!transitioned) {
+                        if (this.completeAcceptedOutcome(e))
+                            sent += 1;
                         continue;
-                    this.deps.store.fail(e.id, msg, this.deps.now(), 1); // maxAttempts=1 → 直进 DLQ, 不反复打经济端点
+                    }
                     await this.deps.onOutboundTerminal?.(e, err);
                     terminal += 1;
                 }
@@ -344,20 +474,34 @@ export class SyncEngine {
                     const nowAfterFailure = this.deps.now();
                     const retry = retryAfterMs(err);
                     for (const pending of batch.slice(i)) {
-                        this.deps.store.defer(pending.id, msg, nowAfterFailure, retry); // Hub outage 不消耗 attempts
-                        deferred += 1;
+                        const acceptedKey = this.deps.acceptedOutcomeKey?.(pending);
+                        const pendingClaimOwner = requiredClaimOwner(pending);
+                        const transitioned = acceptedKey
+                            ? this.deps.store.deferClaimedUnlessProcessed(pending.id, acceptedKey, msg, nowAfterFailure, retry, pendingClaimOwner)
+                            : this.deps.store.deferClaimed(pending.id, msg, nowAfterFailure, retry, pendingClaimOwner);
+                        if (transitioned)
+                            deferred += 1;
+                        else if (this.completeAcceptedOutcome(pending))
+                            sent += 1;
                     }
                     break;
                 }
                 else {
-                    this.deps.store.fail(e.id, msg, this.deps.now()); // 退避重试
-                    failed += 1;
+                    const transitionNow = this.deps.now();
+                    const acceptedKey = this.deps.acceptedOutcomeKey?.(e);
+                    const transitioned = acceptedKey
+                        ? this.deps.store.failClaimedUnlessProcessed(e.id, acceptedKey, msg, transitionNow, claimOwner)
+                        : this.deps.store.failClaimed(e.id, msg, transitionNow, claimOwner);
+                    if (transitioned)
+                        failed += 1;
+                    else if (this.completeAcceptedOutcome(e))
+                        sent += 1;
                 }
             }
         }
         if (sent > 0)
             this.lastActivityAt = now;
-        if (failed === 0 && terminal === 0 && deferred === 0)
+        if (failed === 0 && terminal === 0 && deferred === 0 && !localPersistenceFailed)
             this.markOk();
         if (sent > 0 || terminal > 0 || completedDuplicates > 0) {
             await this.notifyOutboundFlushed({ sent, failed, terminal, deferred });
@@ -409,7 +553,7 @@ export class SyncEngine {
             };
         }
         catch (err) {
-            if (isHubUnreachable(err)) {
+            if (isHubUnreachable(err) || (err instanceof HubClientError && err.status === 429)) {
                 const msg = `inbound: ${safeErrorMessage(err)}`;
                 this.markError(msg, false);
                 return { received: 0, enqueued: 0, hasMore: false, nextPollAfterMs: retryAfterMs(err) };
@@ -482,6 +626,53 @@ export class SyncEngine {
             return null;
         return e.idempotencyKey ? `outbound:${e.idempotencyKey}` : null;
     }
+    acceptedTaskOutbound(e) {
+        if (e.type !== 'task_claim' && e.type !== 'task_complete')
+            return undefined;
+        return this.durableAcceptedTaskOutbound(e) ?? this.acceptedTaskOutboundMemory.get(e.id);
+    }
+    durableAcceptedTaskOutbound(e) {
+        if (e.type !== 'task_claim' && e.type !== 'task_complete')
+            return undefined;
+        const value = this.deps.store.getProcessed(`${ACCEPTED_TASK_OUTBOUND_PREFIX}${e.id}`);
+        if (value && typeof value === 'object' && value.accepted === true) {
+            return value;
+        }
+        const checkpoint = this.deps.store.getClaimedCheckpoint(e.id);
+        if (checkpoint && typeof checkpoint === 'object'
+            && checkpoint.accepted === true) {
+            return checkpoint;
+        }
+        return undefined;
+    }
+    completeAcceptedOutcome(e) {
+        const acceptedKey = this.deps.acceptedOutcomeKey?.(e);
+        if (!acceptedKey || !this.deps.store.isProcessed(acceptedKey))
+            return false;
+        return this.deps.store.completeClaimed(e.id, this.deps.now(), requiredClaimOwner(e));
+    }
+    rememberAcceptedTaskOutbound(e, result) {
+        if (e.type !== 'task_claim' && e.type !== 'task_complete')
+            return;
+        const accepted = { accepted: true, result };
+        this.acceptedTaskOutboundMemory.set(e.id, accepted);
+        let lastError;
+        for (let attempt = 0; attempt < ACCEPTED_TASK_JOURNAL_WRITE_ATTEMPTS; attempt += 1) {
+            try {
+                this.deps.store.markProcessed(`${ACCEPTED_TASK_OUTBOUND_PREFIX}${e.id}`, accepted, this.deps.now());
+                this.acceptedTaskOutboundMemory.delete(e.id);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        if (this.deps.store.setClaimedCheckpoint(e.id, accepted, this.deps.now(), requiredClaimOwner(e))) {
+            this.acceptedTaskOutboundMemory.delete(e.id);
+            return;
+        }
+        throw lastError;
+    }
     async safeAck(id) {
         try {
             await this.deps.hub.mailbox.ack(id);

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@evomap/evolver-proxy",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.22",
   "private": false,
   "type": "module",
+  "engines": {
+    "node": "^22.13.0 || >=23.4.0"
+  },
   "description": "系统级 mailbox/hub 同步 daemon (Node)",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -26,8 +29,12 @@
   },
   "dependencies": {
     "@aws-sdk/client-bedrock-runtime": "^3.1053.0",
-    "@evomap/evolver-adapter-public": "2.0.0-beta.2",
-    "@evomap/evolver-core": "2.0.0-beta.2"
+    "@evomap/evolver-adapter-public": "2.0.0-beta.22",
+    "@evomap/evolver-core": "2.0.0-beta.22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EvoMap/evolver.git"
   },
   "publishConfig": {
     "access": "public",