@wrongstack/core 0.282.2 → 0.283.0

package/dist/{events-BOv8h6I1.d.ts → events-KmxSmvho.d.ts}

@@ -424,6 +424,11 @@ interface EventMap {
         };
         status: number;
         providerSwitched: boolean;
+        contextWindowWarning?: {
+            fromMaxContext: number;
+            toMaxContext: number;
+            currentTokens?: number | undefined;
+        } | undefined;
     };
     'tool.started': {
         sessionId?: string | undefined;

package/dist/execution/index.d.ts

@@ -1,14 +1,14 @@
-export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorOptions, d as CompactorStrategy, Z as ContextWindowBudgetSnapshot, $ as DEFAULT_RECOVERY_STRATEGIES, D as DefaultDesignKitLoader, e as DefaultErrorHandler, f as DefaultPromptLoader, g as DefaultRetryPolicy, h as DefaultSkillLoader, i as DesignKitLoaderOptions, k as DoneCheckResult, l as DoneConditionChecker, H as HybridCompactor, I as IntelligentCompactor, m as IntelligentCompactorOptions, P as PersistedActiveKit, n as PromptLoaderOptions, a0 as RecoveryStrategy, S as SelectiveCompactor, o as SelectiveCompactorOptions, p as SkillLoaderOptions, q as StrategyCompactorOptions, T as ToolExecutor, _ as _resetDesignKitLoaderMemo, r as _resetDesignRulesCache, s as activateDesign, u as buildGoalPreamble, a1 as buildRecoveryStrategies, v as clearActiveKit, w as clearPersistedActiveKit, x as createStrategyCompactor, y as designProjectDir, z as detectFrontendFile, B as detectFrontendIntent, E as getDesignKitLoader, F as getDesignState, G as installDesignStudioMiddleware, J as loadActiveKit, K as loadProjectDesignRules, L as makeAutonomyPromptContributor, M as makeDesignDetectToolCallMiddleware, N as makeDesignDetectUserInputMiddleware, O as makeDesignStudioRequestMiddleware, R as recordKitChoice, V as renderPrompt, W as resolveBundledDesignKitsDir, X as setActiveKit } from '../tool-executor-4mWN2vHW.js';
+export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorOptions, d as CompactorStrategy, Z as ContextWindowBudgetSnapshot, $ as DEFAULT_RECOVERY_STRATEGIES, D as DefaultDesignKitLoader, e as DefaultErrorHandler, f as DefaultPromptLoader, g as DefaultRetryPolicy, h as DefaultSkillLoader, i as DesignKitLoaderOptions, k as DoneCheckResult, l as DoneConditionChecker, H as HybridCompactor, I as IntelligentCompactor, m as IntelligentCompactorOptions, P as PersistedActiveKit, n as PromptLoaderOptions, a0 as RecoveryStrategy, S as SelectiveCompactor, o as SelectiveCompactorOptions, p as SkillLoaderOptions, q as StrategyCompactorOptions, T as ToolExecutor, _ as _resetDesignKitLoaderMemo, r as _resetDesignRulesCache, s as activateDesign, u as buildGoalPreamble, a1 as buildRecoveryStrategies, v as clearActiveKit, w as clearPersistedActiveKit, x as createStrategyCompactor, y as designProjectDir, z as detectFrontendFile, B as detectFrontendIntent, E as getDesignKitLoader, F as getDesignState, G as installDesignStudioMiddleware, J as loadActiveKit, K as loadProjectDesignRules, L as makeAutonomyPromptContributor, M as makeDesignDetectToolCallMiddleware, N as makeDesignDetectUserInputMiddleware, O as makeDesignStudioRequestMiddleware, R as recordKitChoice, V as renderPrompt, W as resolveBundledDesignKitsDir, X as setActiveKit } from '../tool-executor-kElSEgO0.js';
 import { P as Provider, a as ReasoningConfig, r as Capabilities, c as Request } from '../tool-LVSLiE1s.js';
-import { e as BrainDecision, h as BrainDecisionRequest, B as BrainArbiter } from '../events-BOv8h6I1.js';
-export { E as EternalAutonomyEngine, h as EternalAutonomyOptions, i as EternalEngineState, I as IterationStage, P as ParallelEngineState, j as ParallelEternalEngine, k as ParallelEternalOptions, l as ParallelIterationStage } from '../parallel-eternal-engine-BXECuOVG.js';
+import { e as BrainDecision, h as BrainDecisionRequest, B as BrainArbiter } from '../events-KmxSmvho.js';
+export { E as EternalAutonomyEngine, h as EternalAutonomyOptions, i as EternalEngineState, I as IterationStage, P as ParallelEngineState, j as ParallelEternalEngine, k as ParallelEternalOptions, l as ParallelIterationStage } from '../parallel-eternal-engine-iY2uxocj.js';
 import { h as ModelRuntimeConfig } from '../config-DkCbA3Bw.js';
 import '../pipeline-ixSFe5jg.js';
 import '../mailbox-types-BGZWrYTJ.js';
 import '../session-event-bridge-Bkp7ORfc.js';
 import '../compactor-BxddyCFu.js';
-import '../agent-subagent-runner-DCczSoQj.js';
-import '../index-Dd-PJJ8A.js';
+import '../agent-subagent-runner-BsuWhB28.js';
+import '../index-BhCteHAF.js';
 import '../logger-B63L5bTg.js';
 import '../permission-B6YAtNFz.js';
 import '../observability-D-HZN_mF.js';
@@ -18,8 +18,8 @@ import '../selector-Bx2HgUkU.js';
 import '../skill-DHniprNl.js';
 import '../wstack-paths-C3K40Qst.js';
 import '../prompt-DLd35n4Q.js';
-import '../goal-store-BEmDmSKF.js';
-import '../multi-agent-coordinator-BRqtpn-a.js';
+import '../goal-store-8owBXJT2.js';
+import '../multi-agent-coordinator-CrjeTB9i.js';
 import 'node:events';
 
 /**

package/dist/extension/index.d.ts

@@ -1,4 +1,4 @@
-export { j as AfterIterationHook, k as AfterRunHook, l as AfterToolExecutionHook, i as AgentExtension, B as BeforeIterationHook, m as BeforeRunHook, n as BeforeToolExecutionHook, E as ExtensionRegistry, O as OnErrorHook, v as ProviderRunnerFn, t as ProviderRunnerWrapper } from '../index-Dd-PJJ8A.js';
+export { j as AfterIterationHook, k as AfterRunHook, l as AfterToolExecutionHook, i as AgentExtension, B as BeforeIterationHook, m as BeforeRunHook, n as BeforeToolExecutionHook, E as ExtensionRegistry, O as OnErrorHook, v as ProviderRunnerFn, t as ProviderRunnerWrapper } from '../index-BhCteHAF.js';
 import '../tool-LVSLiE1s.js';
 import '../logger-B63L5bTg.js';
 import '../pipeline-ixSFe5jg.js';
@@ -6,5 +6,5 @@ import '../mailbox-types-BGZWrYTJ.js';
 import '../config-DkCbA3Bw.js';
 import '../permission-B6YAtNFz.js';
 import '../observability-D-HZN_mF.js';
-import '../events-BOv8h6I1.js';
+import '../events-KmxSmvho.js';
 import '../secret-scrubber-3MHDDAtm.js';

package/dist/{global-mailbox-MDDFhLYh.d.ts → global-mailbox-rWVt8YlO.d.ts}

@@ -1,5 +1,5 @@
 import { M as MailboxMessage, a as MailboxAgentStatus, b as Mailbox, c as MailboxSendInput, d as MailboxQuery, e as MailboxAckInput, f as MailboxAckBatchInput, A as AgentRegistrationInput, g as AgentHeartbeatInput, C as ClientRegistrationInput, h as ClientHeartbeatInput, i as ClientStatus, P as PurgeOptions, j as PurgeResult } from './mailbox-types-BGZWrYTJ.js';
-import { E as EventBus } from './events-BOv8h6I1.js';
+import { E as EventBus } from './events-KmxSmvho.js';
 
 declare const HQ_PROTOCOL_VERSION: 1;
 type HqProtocolVersion = typeof HQ_PROTOCOL_VERSION;
@@ -789,6 +789,17 @@ declare class GlobalMailbox implements Mailbox {
     private _messageCacheMtime;
     /** Size of the file when `_messageCache` was populated (extra guard). */
     private _messageCacheSize;
+    /**
+     * Serializes reads of the message file so overlapping concurrent
+     * `_readMessagesCached()` calls don't both enter the incremental "file
+     * only grew" branch against the same stale `_messageCacheSize` and
+     * each push the same tail bytes onto the cache (duplicating every
+     * appended message). The chain runs each read to completion before
+     * the next starts, in issue order — readers are read-only and never
+     * conflict with each other on content, only on the cache mutation
+     * that follows the read. Pattern mirrors `DefaultMemoryStore.runSerialized`.
+     */
+    private _readChain;
     /**
      * @param projectDir — `~/.wrongstack/projects/<slug>/`
      * @param events — optional EventBus for real-time TUI/WebUI notifications
@@ -843,10 +854,28 @@ declare class GlobalMailbox implements Mailbox {
      * from writers that just took the file lock — the read reflects the
      * authoritative post-lock state and should be served to subsequent
      * queries without re-reading.
+     *
+     * The mtime/size are captured from the stat at read time so the cache
+     * trackers match exactly what was parsed. Writers that subsequently
+     * rewrite the file MUST re-stat after the write and re-promote with the
+     * post-write values (see ackMany / softDelete / restore / purgeStale /
+     * clearAll) — otherwise a concurrent reader misclassifies the rewrite
+     * as a "file only grew" append and corrupts the cache.
      */
     private _readMessagesFresh;
     /**
-     * Read messages, consulting the mtime-bounded in-memory cache first.
+     * Stat the message file, returning its mtimeMs and size. Returns
+     * `-1/-1` when the file does not yet exist (ENOENT) so callers can
+     * still promote a cache snapshot — the next read will re-stat and
+     * fall through to a full re-read. Call from inside the file lock so
+     * the result reflects the post-write on-disk state, not a later
+     * intermediate state from another process.
+     */
+    private _statMessageFile;
+    /**
+     * Read messages, consulting the mtime-bounded in-memory cache first,
+     * serialized so concurrent callers don't both mutate the cache.
+     *
      * The mailbox file is shared across processes; every `send`/`ack`/
      * `clearAll`/`purgeStale` takes the file lock, so writes are serialized
      * and a changed mtimeMs is a definitive freshness signal. When the
@@ -857,19 +886,53 @@ declare class GlobalMailbox implements Mailbox {
      * When the file only grew (new messages appended by another process),
      * we read and parse just the tail bytes instead of the entire file.
      * This avoids re-parsing the full 10K-message history on every check.
+     *
+     * SERIALIZATION: the actual work is chained onto `_readChain` so two
+     * overlapping calls can't both pass the `st.size > _messageCacheSize`
+     * incremental check against the same stale tracker and each push the
+     * same tail bytes onto the cache (duplicating every appended message).
+     * Readers don't conflict on file content — only on the cache mutation
+     * that follows the read — so we run them one at a time in issue order.
+     * Errors in the chain are swallowed so a failed read never poisons
+     * subsequent reads; each caller observes and re-throws its own error.
      */
     private _readMessagesCached;
     /**
-     * Replace the in-memory cache. Caller is responsible for guaranteeing
-     * that `messages` reflects the current on-disk state (e.g. they just
-     * read or wrote it under the file lock).
+     * The un-serialized body of {@link _readMessagesCached}. Reads the
+     * message file with the mtime-bounded cache + incremental-tail
+     * optimization. Must only be called from `_readMessagesCached` so the
+     * cache mutations here don't race a sibling read.
+     */
+    private _readMessagesCachedWork;
+    /**
+     * Replace the in-memory cache, setting the mtime/size trackers
+     * synchronously in the same step. Callers MUST pass the stat of the
+     * on-disk file state that produced `messages`.
+     *
+     * Why both are required (not fire-and-forget): `_readMessagesCached()`
+     * validates the cache against a fresh stat using these two trackers.
+     * If the cache array is updated but the trackers lag behind (e.g. via
+     * a deferred `stat().then(...)`), a concurrent reader landing in that
+     * window sees a mismatched mtime and falls into the incremental
+     * "file only grew" branch — parsing rewritten bytes as an appended
+     * tail and corrupting the cache with duplicates/garbage. So both
+     * values are captured under the file lock and applied synchronously
+     * here, matching the fix already shipped in DefaultMailbox.
      */
     private _setMessageCache;
     /**
      * Append a single just-sent message to the in-memory cache without
      * re-reading the file. The caller must hold the file lock (or have
-     * just released it after a successful append) so the cache stays
-     * consistent with on-disk state.
+     * just released it after a successful append) and MUST pass the
+     * post-append stat so the mtime/size trackers advance in lock-step
+     * with the pushed content.
+     *
+     * Why the stat is required here: without it, `_messageCacheSize`
+     * stays at the pre-append value. A concurrent `_readMessagesCached()`
+     * then sees `st.size > _messageCacheSize` (the file did grow), takes
+     * the incremental branch, and re-reads the just-appended tail —
+     * pushing the same message onto the cache a second time. Setting the
+     * trackers here closes that window for the local-process append path.
      */
     private _pushToCache;
     private _ensureRegistry;

package/dist/{goal-store-BEmDmSKF.d.ts → goal-store-8owBXJT2.d.ts}

@@ -1,4 +1,4 @@
-import { E as EventBus } from './events-BOv8h6I1.js';
+import { E as EventBus } from './events-KmxSmvho.js';
 
 /**
  * Long-running autonomous mission. A goal survives across sessions and

package/dist/hq/index.d.ts

@@ -1,6 +1,6 @@
-import { $ as HqRedactionPolicy, t as HqEventEnvelope, W as HqPublisher, p as HqClientIdentity, ac as HqSocketFactory, i as HqClientCapability, X as HqPublisherCommandHandler, G as GlobalMailbox, ab as HqSnapshot, _ as HqQueuedCommand, c as HqAlertMessage, aj as HqTranscriptEntry } from '../global-mailbox-MDDFhLYh.js';
-export { D as DEFAULT_HQ_REDACTION_POLICY, H as HQ_PROTOCOL_VERSION, a as HqAgentMessagePayload, b as HqAgentStatusPayload, d as HqBrainEventKind, e as HqBrainEventPayload, f as HqBrowserEventMessage, g as HqBrowserMessage, h as HqBrowserSnapshotMessage, j as HqClientCommandAckMessage, k as HqClientCommandPollMessage, l as HqClientEventMessage, m as HqClientHeartbeatPayload, n as HqClientHelloMessage, o as HqClientHelloPayload, q as HqClientKind, r as HqClientMessage, s as HqClientRecord, u as HqEventPayloadResult, v as HqEventType, w as HqFleetEventPayload, x as HqFleetSnapshotPayload, y as HqFleetSummary, z as HqGitSnapshotPayload, A as HqMachineRecord, B as HqMailboxAgentStatus, C as HqMailboxAgentSummary, E as HqMailboxEventAction, F as HqMailboxEventPayload, I as HqMailboxMappingOptions, J as HqMailboxMessageSummary, K as HqMailboxMessageType, L as HqMailboxPriority, M as HqMailboxSnapshotOptions, N as HqMailboxSnapshotPayload, O as HqMailboxSummary, P as HqParseResult, Q as HqPathPolicy, R as HqProjectIdentity, S as HqProjectRecord, T as HqProjectStatus, U as HqProtocolVersion, V as HqPublishEventOptions, Y as HqPublisherCommandResult, Z as HqPublisherOptions, a0 as HqServerCommandBatchMessage, a1 as HqServerMessage, a2 as HqSessionAgentLiveStatus, a3 as HqSessionAgentSummary, a4 as HqSessionEndedPayload, a5 as HqSessionLiveStatus, a6 as HqSessionSnapshotPayload, a7 as HqSessionStartedPayload, a8 as HqSessionStatus, a9 as HqSessionStatusPayload, aa as HqSessionSummary, ad as HqSocketLike, ae as HqSubagentSummary, af as HqToolArgsPolicy, ag as HqToolCompletedPayload, ah as HqToolStartedPayload, ai as HqTranscriptAppendPayload, ak as HqTranscriptRole, al as HqUsagePayload, am as HqWelcomePayload, an as HqWorklistCounts, ao as HqWorklistSnapshotPayload, ap as HqWorkspaceKind, aq as HqWorktreeEventKind, ar as HqWorktreeEventPayload, as as createHqEventEnvelope, at as createMailboxEventPayload, au as createMailboxSnapshotPayload, av as createMailboxSnapshotPayloadFromMailbox, aw as mapMailboxAgentToHqSummary, ax as mapMailboxMessageToHqSummary, ay as parseHqEventPayload, az as parseHqFrame } from '../global-mailbox-MDDFhLYh.js';
-import { E as EventBus, T as TrackedAgentSnapshot } from '../events-BOv8h6I1.js';
+import { $ as HqRedactionPolicy, t as HqEventEnvelope, W as HqPublisher, p as HqClientIdentity, ac as HqSocketFactory, i as HqClientCapability, X as HqPublisherCommandHandler, G as GlobalMailbox, ab as HqSnapshot, _ as HqQueuedCommand, c as HqAlertMessage, aj as HqTranscriptEntry } from '../global-mailbox-rWVt8YlO.js';
+export { D as DEFAULT_HQ_REDACTION_POLICY, H as HQ_PROTOCOL_VERSION, a as HqAgentMessagePayload, b as HqAgentStatusPayload, d as HqBrainEventKind, e as HqBrainEventPayload, f as HqBrowserEventMessage, g as HqBrowserMessage, h as HqBrowserSnapshotMessage, j as HqClientCommandAckMessage, k as HqClientCommandPollMessage, l as HqClientEventMessage, m as HqClientHeartbeatPayload, n as HqClientHelloMessage, o as HqClientHelloPayload, q as HqClientKind, r as HqClientMessage, s as HqClientRecord, u as HqEventPayloadResult, v as HqEventType, w as HqFleetEventPayload, x as HqFleetSnapshotPayload, y as HqFleetSummary, z as HqGitSnapshotPayload, A as HqMachineRecord, B as HqMailboxAgentStatus, C as HqMailboxAgentSummary, E as HqMailboxEventAction, F as HqMailboxEventPayload, I as HqMailboxMappingOptions, J as HqMailboxMessageSummary, K as HqMailboxMessageType, L as HqMailboxPriority, M as HqMailboxSnapshotOptions, N as HqMailboxSnapshotPayload, O as HqMailboxSummary, P as HqParseResult, Q as HqPathPolicy, R as HqProjectIdentity, S as HqProjectRecord, T as HqProjectStatus, U as HqProtocolVersion, V as HqPublishEventOptions, Y as HqPublisherCommandResult, Z as HqPublisherOptions, a0 as HqServerCommandBatchMessage, a1 as HqServerMessage, a2 as HqSessionAgentLiveStatus, a3 as HqSessionAgentSummary, a4 as HqSessionEndedPayload, a5 as HqSessionLiveStatus, a6 as HqSessionSnapshotPayload, a7 as HqSessionStartedPayload, a8 as HqSessionStatus, a9 as HqSessionStatusPayload, aa as HqSessionSummary, ad as HqSocketLike, ae as HqSubagentSummary, af as HqToolArgsPolicy, ag as HqToolCompletedPayload, ah as HqToolStartedPayload, ai as HqTranscriptAppendPayload, ak as HqTranscriptRole, al as HqUsagePayload, am as HqWelcomePayload, an as HqWorklistCounts, ao as HqWorklistSnapshotPayload, ap as HqWorkspaceKind, aq as HqWorktreeEventKind, ar as HqWorktreeEventPayload, as as createHqEventEnvelope, at as createMailboxEventPayload, au as createMailboxSnapshotPayload, av as createMailboxSnapshotPayloadFromMailbox, aw as mapMailboxAgentToHqSummary, ax as mapMailboxMessageToHqSummary, ay as parseHqEventPayload, az as parseHqFrame } from '../global-mailbox-rWVt8YlO.js';
+import { E as EventBus, T as TrackedAgentSnapshot } from '../events-KmxSmvho.js';
 import { K as HqClientConfig } from '../config-DkCbA3Bw.js';
 import '../mailbox-types-BGZWrYTJ.js';
 import '../tool-LVSLiE1s.js';

package/dist/hq/index.js

@@ -1506,6 +1506,17 @@ var GlobalMailbox = class {
   _messageCacheMtime = -1;
   /** Size of the file when `_messageCache` was populated (extra guard). */
   _messageCacheSize = -1;
+  /**
+   * Serializes reads of the message file so overlapping concurrent
+   * `_readMessagesCached()` calls don't both enter the incremental "file
+   * only grew" branch against the same stale `_messageCacheSize` and
+   * each push the same tail bytes onto the cache (duplicating every
+   * appended message). The chain runs each read to completion before
+   * the next starts, in issue order — readers are read-only and never
+   * conflict with each other on content, only on the cache mutation
+   * that follows the read. Pattern mirrors `DefaultMemoryStore.runSerialized`.
+   */
+  _readChain = Promise.resolve([]);
   /**
    * @param projectDir — `~/.wrongstack/projects/<slug>/`
    * @param events — optional EventBus for real-time TUI/WebUI notifications
@@ -1559,7 +1570,8 @@ var GlobalMailbox = class {
     await fsp.mkdir(path2.dirname(this.messagePath), { recursive: true });
     await withFileLock(this.messagePath, async () => {
       await fsp.appendFile(this.messagePath, line, "utf8");
-      this._pushToCache(msg);
+      const { mtimeMs, size } = await this._statMessageFile();
+      this._pushToCache(msg, mtimeMs, size);
     });
     this.publishHqMailboxEvent({
       mailboxId: this.hqMailboxId,
@@ -1603,7 +1615,6 @@ var GlobalMailbox = class {
     for (const a of input.acks) {
       byId.set(a.messageId, a);
     }
-    let cacheSnapshot = null;
     await withFileLock(this.messagePath, async () => {
       const all = await this._readMessagesFresh();
       const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1631,9 +1642,9 @@ var GlobalMailbox = class {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
         await fsp.writeFile(this.messagePath, serialized, "utf8");
       }
-      cacheSnapshot = all;
+      const { mtimeMs, size } = await this._statMessageFile();
+      this._setMessageCache(all, mtimeMs, size);
     });
-    if (cacheSnapshot) this._setMessageCache(cacheSnapshot);
     for (const message of updated) {
       this.publishHqMailboxEvent({
         mailboxId: this.hqMailboxId,
@@ -1657,7 +1668,6 @@ var GlobalMailbox = class {
   }
   async softDelete(mailId, by) {
     let updated = null;
-    let cacheSnapshot = null;
     await withFileLock(this.messagePath, async () => {
       const all = await this._readMessagesFresh();
       const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1673,9 +1683,9 @@ var GlobalMailbox = class {
       }
       const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
       await fsp.writeFile(this.messagePath, serialized, "utf8");
-      cacheSnapshot = all;
+      const { mtimeMs, size } = await this._statMessageFile();
+      this._setMessageCache(all, mtimeMs, size);
     });
-    if (cacheSnapshot) this._setMessageCache(cacheSnapshot);
     if (updated !== null) {
       this.publishHqMailboxEvent({
         mailboxId: this.hqMailboxId,
@@ -1688,7 +1698,6 @@ var GlobalMailbox = class {
   }
   async restore(mailId) {
     let updated = null;
-    let cacheSnapshot = null;
     await withFileLock(this.messagePath, async () => {
       const all = await this._readMessagesFresh();
       for (const m of all) {
@@ -1699,9 +1708,9 @@ var GlobalMailbox = class {
       }
       const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
       await fsp.writeFile(this.messagePath, serialized, "utf8");
-      cacheSnapshot = all;
+      const { mtimeMs, size } = await this._statMessageFile();
+      this._setMessageCache(all, mtimeMs, size);
     });
-    if (cacheSnapshot) this._setMessageCache(cacheSnapshot);
     if (updated !== null) {
       this.publishHqMailboxEvent({
         mailboxId: this.hqMailboxId,
@@ -1946,8 +1955,9 @@ var GlobalMailbox = class {
   async clearAll() {
     await withFileLock(this.messagePath, async () => {
       await fsp.writeFile(this.messagePath, "", "utf8");
+      const { mtimeMs, size } = await this._statMessageFile();
+      this._setMessageCache([], mtimeMs, size);
     });
-    this._setMessageCache([]);
   }
   async purgeStale(opts) {
     const COMPLETED_MAX_AGE_MS = opts?.completedMaxAgeMs ?? 864e5;
@@ -1979,7 +1989,8 @@ var GlobalMailbox = class {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
         await fsp.writeFile(this.messagePath, content, "utf8");
       }
-      this._setMessageCache(kept);
+      const { mtimeMs, size } = await this._statMessageFile();
+      this._setMessageCache(kept, mtimeMs, size);
     });
     return {
       completedPurged,
@@ -2066,14 +2077,43 @@ var GlobalMailbox = class {
    * from writers that just took the file lock — the read reflects the
    * authoritative post-lock state and should be served to subsequent
    * queries without re-reading.
+   *
+   * The mtime/size are captured from the stat at read time so the cache
+   * trackers match exactly what was parsed. Writers that subsequently
+   * rewrite the file MUST re-stat after the write and re-promote with the
+   * post-write values (see ackMany / softDelete / restore / purgeStale /
+   * clearAll) — otherwise a concurrent reader misclassifies the rewrite
+   * as a "file only grew" append and corrupts the cache.
    */
   async _readMessagesFresh() {
     const all = await this._readMessages();
-    this._setMessageCache(all);
+    const { mtimeMs, size } = await this._statMessageFile();
+    this._setMessageCache(all, mtimeMs, size);
     return all;
   }
   /**
-   * Read messages, consulting the mtime-bounded in-memory cache first.
+   * Stat the message file, returning its mtimeMs and size. Returns
+   * `-1/-1` when the file does not yet exist (ENOENT) so callers can
+   * still promote a cache snapshot — the next read will re-stat and
+   * fall through to a full re-read. Call from inside the file lock so
+   * the result reflects the post-write on-disk state, not a later
+   * intermediate state from another process.
+   */
+  async _statMessageFile() {
+    try {
+      const st = await fsp.stat(this.messagePath);
+      return { mtimeMs: st.mtimeMs, size: st.size };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { mtimeMs: -1, size: -1 };
+      }
+      throw err;
+    }
+  }
+  /**
+   * Read messages, consulting the mtime-bounded in-memory cache first,
+   * serialized so concurrent callers don't both mutate the cache.
+   *
    * The mailbox file is shared across processes; every `send`/`ack`/
    * `clearAll`/`purgeStale` takes the file lock, so writes are serialized
    * and a changed mtimeMs is a definitive freshness signal. When the
@@ -2084,8 +2124,28 @@ var GlobalMailbox = class {
    * When the file only grew (new messages appended by another process),
    * we read and parse just the tail bytes instead of the entire file.
    * This avoids re-parsing the full 10K-message history on every check.
+   *
+   * SERIALIZATION: the actual work is chained onto `_readChain` so two
+   * overlapping calls can't both pass the `st.size > _messageCacheSize`
+   * incremental check against the same stale tracker and each push the
+   * same tail bytes onto the cache (duplicating every appended message).
+   * Readers don't conflict on file content — only on the cache mutation
+   * that follows the read — so we run them one at a time in issue order.
+   * Errors in the chain are swallowed so a failed read never poisons
+   * subsequent reads; each caller observes and re-throws its own error.
+   */
+  _readMessagesCached() {
+    const run = this._readChain.catch(() => void 0).then(() => this._readMessagesCachedWork());
+    this._readChain = run.catch(() => []);
+    return run;
+  }
+  /**
+   * The un-serialized body of {@link _readMessagesCached}. Reads the
+   * message file with the mtime-bounded cache + incremental-tail
+   * optimization. Must only be called from `_readMessagesCached` so the
+   * cache mutations here don't race a sibling read.
    */
-  async _readMessagesCached() {
+  async _readMessagesCachedWork() {
     try {
       const st = await fsp.stat(this.messagePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
@@ -2114,9 +2174,19 @@ var GlobalMailbox = class {
     }
   }
   /**
-   * Replace the in-memory cache. Caller is responsible for guaranteeing
-   * that `messages` reflects the current on-disk state (e.g. they just
-   * read or wrote it under the file lock).
+   * Replace the in-memory cache, setting the mtime/size trackers
+   * synchronously in the same step. Callers MUST pass the stat of the
+   * on-disk file state that produced `messages`.
+   *
+   * Why both are required (not fire-and-forget): `_readMessagesCached()`
+   * validates the cache against a fresh stat using these two trackers.
+   * If the cache array is updated but the trackers lag behind (e.g. via
+   * a deferred `stat().then(...)`), a concurrent reader landing in that
+   * window sees a mismatched mtime and falls into the incremental
+   * "file only grew" branch — parsing rewritten bytes as an appended
+   * tail and corrupting the cache with duplicates/garbage. So both
+   * values are captured under the file lock and applied synchronously
+   * here, matching the fix already shipped in DefaultMailbox.
    */
   _setMessageCache(messages, mtime, size) {
     if (messages.length > MESSAGE_CACHE_MAX_ENTRIES) {
@@ -2126,25 +2196,27 @@ var GlobalMailbox = class {
       return;
     }
     this._messageCache = messages;
-    if (mtime !== void 0 && size !== void 0) {
-      this._messageCacheMtime = mtime;
-      this._messageCacheSize = size;
-    } else {
-      void fsp.stat(this.messagePath).then((st) => {
-        this._messageCacheMtime = st.mtimeMs;
-        this._messageCacheSize = st.size;
-      }).catch(() => {
-      });
-    }
+    this._messageCacheMtime = mtime;
+    this._messageCacheSize = size;
   }
   /**
    * Append a single just-sent message to the in-memory cache without
    * re-reading the file. The caller must hold the file lock (or have
-   * just released it after a successful append) so the cache stays
-   * consistent with on-disk state.
+   * just released it after a successful append) and MUST pass the
+   * post-append stat so the mtime/size trackers advance in lock-step
+   * with the pushed content.
+   *
+   * Why the stat is required here: without it, `_messageCacheSize`
+   * stays at the pre-append value. A concurrent `_readMessagesCached()`
+   * then sees `st.size > _messageCacheSize` (the file did grow), takes
+   * the incremental branch, and re-reads the just-appended tail —
+   * pushing the same message onto the cache a second time. Setting the
+   * trackers here closes that window for the local-process append path.
    */
-  _pushToCache(msg) {
-    if (this._messageCache === null) return;
+  _pushToCache(msg, mtime, size) {
+    if (this._messageCache === null) {
+      return;
+    }
     if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES) {
       this._messageCache = null;
       this._messageCacheMtime = -1;
@@ -2152,6 +2224,8 @@ var GlobalMailbox = class {
       return;
     }
     this._messageCache.push(msg);
+    this._messageCacheMtime = mtime;
+    this._messageCacheSize = size;
   }
   async _ensureRegistry() {
     await fsp.mkdir(path2.dirname(this.registryPath), { recursive: true });