larkin 0.3.3 → 0.4.2

package/dist/agent/agent-state-store.mjs

@@ -4,7 +4,8 @@ import * as path from "node:path";
 import { TargetRootLayout } from "../platform/root-layout.mjs";
 import { acquireProcessLock, inspectProcess } from "../platform/process-state.mjs";
 import { isWindows } from "../platform/secure-metadata.mjs";
-import { targetKeyOfInboxEnvelope } from "./inbox-projection.mjs";
+import { isCanonicalInboxTarget, targetKeyOfInboxEnvelope } from "./inbox-projection.mjs";
+import { buildStrictProviderErrorInput, classifyStrictProviderError } from "../runtime/provider-error-classifier.mjs";
 const JSON_KEYS = new Set([
     "agentState", "status", "map", "replyctx", "botIdentity", "senderProfiles", "readReceipts", "pendingReact", "runtimeDeliveries", "inboxState", "freshnessState", "documentComments", "reminders", "interactions",
 ]);
@@ -103,7 +104,9 @@ function normalizeInboxState(value) {
                 continue;
             const row = candidate;
             if (typeof row.target === "string" && row.target && validSequence(row.seq))
-                state.messages[messageId] = { target: row.target, seq: row.seq };
+                state.messages[messageId] = {
+                    target: row.target, seq: row.seq, ...(typeof row.kind === "string" && row.kind ? { kind: row.kind } : {}),
+                };
         }
     }
     if (raw.drafts && typeof raw.drafts === "object" && !Array.isArray(raw.drafts)) {
@@ -158,6 +161,14 @@ function validInboxLockOwner(value) {
         && typeof owner.processStartToken === "string" && !!owner.processStartToken
         && typeof owner.nonce === "string" && /^[0-9a-f-]{36}$/i.test(owner.nonce);
 }
+export class ContextOverflowRecoveryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ContextOverflowRecoveryError";
+    }
+}
 export class AgentStateStore {
     paths;
     boundary;
@@ -424,13 +435,14 @@ export class AgentStateStore {
         if (!value || typeof value !== "object" || Array.isArray(value))
             throw new Error("Inbox envelope must be an object");
         const input = value;
-        const target = typeof input.target === "string" && input.target ? input.target : targetKeyOfInboxEnvelope(input);
+        const target = targetKeyOfInboxEnvelope(input);
         const current = state.targets[target] ?? { latest_received_seq: 0, model_seen_seq: 0 };
         const requested = validSequence(input.target_seq) ? input.target_seq : 0;
         const targetSeq = requested > current.latest_received_seq ? requested : current.latest_received_seq + 1;
         state.targets[target] = { ...current, latest_received_seq: targetSeq };
         if (typeof input.message_id === "string" && input.message_id) {
-            state.messages[input.message_id] = { target, seq: targetSeq };
+            state.messages[input.message_id] = { target, seq: targetSeq,
+                ...(typeof input.kind === "string" && input.kind ? { kind: input.kind } : {}) };
             const messageIds = Object.keys(state.messages);
             for (const stale of messageIds.slice(0, Math.max(0, messageIds.length - 2_048)))
                 delete state.messages[stale];
@@ -438,8 +450,9 @@ export class AgentStateStore {
         return { ...input, envelope_version: 2, target, target_seq: targetSeq };
     }
     reconcileInboxRows(rows, state) {
-        return rows.map((row) => {
-            const target = typeof row.target === "string" && row.target ? row.target : targetKeyOfInboxEnvelope(row);
+        const targets = rows.map((row) => targetKeyOfInboxEnvelope(row));
+        return rows.map((row, index) => {
+            const target = targets[index];
             const existing = typeof row.message_id === "string" ? state.messages[row.message_id] : undefined;
             const current = state.targets[target] ?? { latest_received_seq: 0, model_seen_seq: 0 };
             const targetSeq = validSequence(row.target_seq) ? row.target_seq
@@ -447,7 +460,8 @@ export class AgentStateStore {
             current.latest_received_seq = Math.max(current.latest_received_seq, targetSeq);
             state.targets[target] = current;
             if (typeof row.message_id === "string" && row.message_id)
-                state.messages[row.message_id] = { target, seq: targetSeq };
+                state.messages[row.message_id] = { target, seq: targetSeq,
+                    ...(typeof row.kind === "string" && row.kind ? { kind: row.kind } : {}) };
             return { ...row, envelope_version: 2, target, target_seq: targetSeq };
         });
     }
@@ -573,23 +587,302 @@ export class AgentStateStore {
         else
             append();
     }
-    /** Append a canonical Inbox envelope once by stable message_id under the shared cross-process lock. */
-    appendInboxOnce(value) {
+    /**
+     * Append one canonical Inbox envelope and return the exact normalized object
+     * serialized to disk. Stable message_id dedupe and locator coherence share the
+     * same lock as poll, so HostShell can deliver that very object without a
+     * persistence/delivery split.
+     */
+    appendCanonicalInboxOnce(value) {
         if (!value || typeof value !== "object" || Array.isArray(value))
             throw new Error("Inbox envelope must be an object");
-        const messageId = value.message_id;
+        const input = value;
+        const messageId = input.message_id;
         if (typeof messageId !== "string" || !messageId)
             throw new Error("Inbox envelope requires message_id");
+        const incomingTarget = targetKeyOfInboxEnvelope(input);
         const file = this.file("inbox");
         return this.withInboxLock(file, () => {
-            if (this.inboxState().messages[messageId])
-                return false;
-            if (this.readNdjson("inbox").some((row) => row.message_id === messageId))
-                return false;
-            this.appendInboxUnlocked(value);
-            return true;
+            const state = this.inboxState();
+            const matching = this.readNdjson("inbox").filter((row) => row.message_id === messageId);
+            if (matching.length > 1)
+                throw new Error("Inbox duplicate message_id has multiple pending canonical rows");
+            if (matching.length === 1) {
+                const existing = matching[0];
+                if (targetKeyOfInboxEnvelope(existing) !== incomingTarget) {
+                    throw new Error("Inbox duplicate message_id conflicts with its canonical target");
+                }
+                if (existing.target_seq !== undefined && !validSequence(existing.target_seq)) {
+                    throw new Error("Inbox duplicate message_id has a malformed canonical sequence");
+                }
+                const known = state.messages[messageId];
+                if (known) {
+                    if (known.target !== incomingTarget)
+                        throw new Error("Inbox message state conflicts with its canonical target");
+                    if (validSequence(existing.target_seq) && existing.target_seq !== known.seq) {
+                        throw new Error("Inbox message state conflicts with its canonical sequence");
+                    }
+                    const targetState = state.targets[known.target];
+                    if (targetState && targetState.model_seen_seq >= known.seq) {
+                        throw new Error("Inbox pending row conflicts with consumed model-seen state");
+                    }
+                }
+                return { status: "duplicate_pending", envelope: existing };
+            }
+            const known = state.messages[messageId];
+            if (known) {
+                if (known.target !== incomingTarget)
+                    throw new Error("Inbox duplicate message_id conflicts with consumed canonical target");
+                const targetState = state.targets[known.target];
+                if (!targetState || targetState.model_seen_seq < known.seq) {
+                    throw new Error("Inbox state references a missing unconsumed canonical row");
+                }
+                return { status: "duplicate_consumed", envelope: null };
+            }
+            return { status: "appended", envelope: this.appendInboxUnlocked(input) };
+        });
+    }
+    /** Append a canonical Inbox envelope once by stable message_id under the shared cross-process lock. */
+    appendInboxOnce(value) {
+        return this.appendCanonicalInboxOnce(value).status === "appended";
+    }
+    /**
+     * Resolve one Runtime delivery solely from canonical Inbox row/state. This is
+     * the single replay resolver used for startup migration and every retry; it
+     * never derives a DM/generic fallback from stale RuntimeInput text.
+     */
+    resolveInboxDeliverySource(messageId) {
+        if (!messageId)
+            return { status: "missing", code: "canonical_inbox_row_missing" };
+        return this.withInboxLock(this.file("inbox"), () => {
+            let rows;
+            try {
+                rows = this.readNdjson("inbox");
+            }
+            catch {
+                return { status: "invalid", code: "canonical_inbox_malformed" };
+            }
+            const matching = rows.filter((row) => row?.message_id === messageId);
+            if (matching.length > 1)
+                return { status: "invalid", code: "duplicate_message_id" };
+            const state = this.inboxState();
+            const known = state.messages[messageId];
+            if (matching.length === 1) {
+                const envelope = matching[0];
+                let target;
+                try {
+                    target = targetKeyOfInboxEnvelope(envelope);
+                }
+                catch {
+                    return { status: "invalid", code: "canonical_inbox_malformed" };
+                }
+                if (envelope.target_seq !== undefined && !validSequence(envelope.target_seq)) {
+                    return { status: "invalid", code: "canonical_inbox_malformed" };
+                }
+                if (known) {
+                    const targetState = state.targets[known.target];
+                    if (known.target !== target || !validSequence(known.seq)
+                        || (validSequence(envelope.target_seq) && envelope.target_seq !== known.seq)
+                        || Boolean(targetState && targetState.model_seen_seq >= known.seq)) {
+                        return { status: "invalid", code: "inbox_state_conflict" };
+                    }
+                }
+                return { status: "pending", target, envelope };
+            }
+            if (!known)
+                return { status: "missing", code: "canonical_inbox_row_missing" };
+            if (!isCanonicalInboxTarget(known.target) || !validSequence(known.seq)) {
+                return { status: "invalid", code: "inbox_state_conflict" };
+            }
+            const targetState = state.targets[known.target];
+            if (targetState && targetState.model_seen_seq >= known.seq)
+                return { status: "consumed", target: known.target };
+            return { status: "missing", code: "canonical_inbox_row_missing" };
         });
     }
+    /**
+     * Re-arm only the durable deliveries proven to be the context-window incident.
+     * The Inbox bytes are intentionally untouched. An optional synchronous commit
+     * hook lets RuntimeHost swap its in-memory generation while this same lock is
+     * still held. If the hook fails, the ledger is restored before the lock is
+     * released. The callback also receives a guarded rollback for post-callback
+     * commit failures before retry scheduling begins.
+     */
+    rearmContextOverflow(onCommit, expected) {
+        let lockActive = true;
+        try {
+            return this.withInboxTransaction(() => {
+                let rows;
+                try {
+                    rows = this.readNdjson("inbox");
+                }
+                catch {
+                    throw new ContextOverflowRecoveryError("canonical_inbox_malformed", "canonical Inbox is malformed");
+                }
+                if (rows.length === 0)
+                    throw new ContextOverflowRecoveryError("inbox_empty", "canonical Inbox backlog is empty");
+                const messageIds = new Set();
+                for (const row of rows) {
+                    try {
+                        targetKeyOfInboxEnvelope(row);
+                    }
+                    catch {
+                        throw new ContextOverflowRecoveryError("canonical_inbox_malformed", "canonical Inbox contains a malformed row");
+                    }
+                    if (typeof row.message_id !== "string" || !row.message_id) {
+                        throw new ContextOverflowRecoveryError("canonical_inbox_malformed", "canonical Inbox row has no message identity");
+                    }
+                    if (messageIds.has(row.message_id))
+                        throw new ContextOverflowRecoveryError("duplicate_message_id", "canonical Inbox contains duplicate message identities");
+                    messageIds.add(row.message_id);
+                }
+                const ledger = this.readJson("runtimeDeliveries", { version: 1, records: [] });
+                if (!Array.isArray(ledger.records))
+                    throw new ContextOverflowRecoveryError("canonical_inbox_malformed", "Runtime delivery ledger is malformed");
+                const ledgerRecords = ledger.records;
+                const matches = new Map();
+                const deliveryIds = new Set();
+                const inputIds = new Set();
+                for (const candidate of ledger.records) {
+                    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+                        continue;
+                    const record = candidate;
+                    if (typeof record.messageId !== "string" || !messageIds.has(record.messageId))
+                        continue;
+                    if (typeof record.deliveryId !== "string" || !record.deliveryId)
+                        throw new ContextOverflowRecoveryError("delivery_missing", "a matching Runtime delivery record has no delivery identity");
+                    if (!record.input || typeof record.input !== "object" || Array.isArray(record.input)) {
+                        throw new ContextOverflowRecoveryError("delivery_identity_invalid", "a matching Runtime delivery record has no Runtime input identity");
+                    }
+                    const input = record.input;
+                    if (typeof input.inputId !== "string" || !input.inputId.trim()
+                        || typeof input.deliveryId !== "string" || input.deliveryId !== record.deliveryId) {
+                        throw new ContextOverflowRecoveryError("delivery_identity_invalid", "a matching Runtime delivery record has malformed input identity");
+                    }
+                    if (matches.has(record.messageId))
+                        throw new ContextOverflowRecoveryError("delivery_duplicate", "a canonical Inbox row maps to multiple delivery records");
+                    if (deliveryIds.has(record.deliveryId))
+                        throw new ContextOverflowRecoveryError("delivery_duplicate", "matching Runtime delivery records share a delivery identity");
+                    if (inputIds.has(input.inputId))
+                        throw new ContextOverflowRecoveryError("duplicate_input_id", "matching Runtime delivery records share an input identity");
+                    deliveryIds.add(record.deliveryId);
+                    inputIds.add(input.inputId);
+                    matches.set(record.messageId, record);
+                }
+                if (expected?.messageId && !messageIds.has(expected.messageId)) {
+                    throw new ContextOverflowRecoveryError("delivery_missing", "the expected context-overflow message is not in canonical Inbox");
+                }
+                if (expected?.messageId) {
+                    const expectedRecord = matches.get(expected.messageId);
+                    if (!expectedRecord || (expected.deliveryId && expectedRecord.deliveryId !== expected.deliveryId)
+                        || (expected.inputId && expectedRecord.input.inputId !== expected.inputId)) {
+                        throw new ContextOverflowRecoveryError("delivery_identity_invalid", "the expected context-overflow delivery identity changed");
+                    }
+                }
+                for (const messageId of messageIds) {
+                    const record = matches.get(messageId);
+                    if (!record)
+                        throw new ContextOverflowRecoveryError("delivery_missing", "a canonical Inbox row has no Runtime delivery record");
+                    if (record.status !== "error" || record.retryable === true) {
+                        throw new ContextOverflowRecoveryError("delivery_not_terminal", "a canonical Inbox row is not backed by a non-retryable terminal Runtime error");
+                    }
+                    const reasonCategory = classifyStrictProviderError(buildStrictProviderErrorInput({
+                        reason: record.reason, errorCategory: record.errorCategory,
+                    }));
+                    if (record.retryable !== false || reasonCategory !== "context_window"
+                        || (record.errorCategory !== undefined && record.errorCategory !== "context_window")) {
+                        throw new ContextOverflowRecoveryError("delivery_not_context_window", "a Runtime delivery error is not classified as context_window");
+                    }
+                }
+                for (const candidate of ledgerRecords) {
+                    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+                        continue;
+                    const record = candidate;
+                    if (typeof record.deliveryId === "string" && deliveryIds.has(record.deliveryId)
+                        && (typeof record.messageId !== "string" || !messageIds.has(record.messageId))) {
+                        throw new ContextOverflowRecoveryError("delivery_duplicate", "a matching delivery identity is also used by an unrelated Runtime delivery record");
+                    }
+                }
+                const updatedAt = new Date().toISOString();
+                const records = ledgerRecords.map((candidate) => {
+                    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+                        return candidate;
+                    const record = candidate;
+                    if (typeof record.messageId !== "string" || !messageIds.has(record.messageId))
+                        return candidate;
+                    return { ...record, status: "pending", retryable: true, updatedAt,
+                        reason: "context-window recovery rearmed the retained Inbox delivery" };
+                });
+                const committedLedger = { ...ledger, records };
+                let restored = false;
+                const restoreUnlocked = () => {
+                    if (restored)
+                        return;
+                    const current = this.readJson("runtimeDeliveries", { version: 1, records: [] });
+                    if (!Array.isArray(current.records))
+                        throw new Error("Runtime delivery rollback found a malformed ledger");
+                    const originalMatching = ledgerRecords.filter((candidate) => {
+                        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+                            return false;
+                        const record = candidate;
+                        return typeof record.messageId === "string" && messageIds.has(record.messageId);
+                    });
+                    const originalDeliveryIds = new Set(originalMatching.flatMap((candidate) => {
+                        const deliveryId = candidate.deliveryId;
+                        return typeof deliveryId === "string" ? [deliveryId] : [];
+                    }));
+                    const currentMatching = current.records.filter((candidate) => {
+                        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+                            return false;
+                        const record = candidate;
+                        return (typeof record.deliveryId === "string" && originalDeliveryIds.has(record.deliveryId))
+                            || (typeof record.messageId === "string" && messageIds.has(record.messageId));
+                    });
+                    const matchingRestored = currentMatching.length === originalMatching.length
+                        && currentMatching.every((candidate, index) => JSON.stringify(candidate) === JSON.stringify(originalMatching[index]));
+                    if (!matchingRestored) {
+                        const unrelated = current.records.filter((candidate) => {
+                            if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+                                return true;
+                            const record = candidate;
+                            return !((typeof record.deliveryId === "string" && originalDeliveryIds.has(record.deliveryId))
+                                || (typeof record.messageId === "string" && messageIds.has(record.messageId)));
+                        });
+                        const restoredRecords = [...unrelated];
+                        for (const candidate of originalMatching) {
+                            const originalIndex = ledgerRecords.indexOf(candidate);
+                            restoredRecords.splice(Math.min(originalIndex, restoredRecords.length), 0, candidate);
+                        }
+                        this.writeJson("runtimeDeliveries", { ...current, records: restoredRecords });
+                    }
+                    restored = true;
+                };
+                const rollback = () => {
+                    if (lockActive)
+                        restoreUnlocked();
+                    else
+                        this.withInboxTransaction(restoreUnlocked);
+                };
+                try {
+                    this.writeJson("runtimeDeliveries", committedLedger);
+                    onCommit?.([...messageIds], rollback);
+                }
+                catch (error) {
+                    try {
+                        rollback();
+                    }
+                    catch {
+                        throw new Error("context-window recovery ledger rollback failed");
+                    }
+                    throw error;
+                }
+                return { rearmedCount: messageIds.size, remainingPendingCount: rows.length };
+            });
+        }
+        finally {
+            lockActive = false;
+        }
+    }
     /**
      * Recoverably bridge an outbox wake into the canonical Inbox. A durable
      * Runtime ledger is authoritative after the Inbox has been drained, so a
@@ -601,6 +894,7 @@ export class AgentStateStore {
         const messageId = value.message_id;
         if (typeof messageId !== "string" || !messageId)
             throw new Error("Inbox envelope requires message_id");
+        targetKeyOfInboxEnvelope(value);
         const file = this.file("inbox");
         return this.withInboxLock(file, () => {
             const ledger = this.readJson("runtimeDeliveries", { version: 1, records: [] });
@@ -649,6 +943,9 @@ export class AgentStateStore {
      * this transaction is active waits and becomes part of the next batch.
      */
     pollInbox(options = {}) {
+        if (options.target && !isCanonicalInboxTarget(options.target)) {
+            throw new Error(`Invalid canonical Inbox poll target ${JSON.stringify(options.target)}`);
+        }
         const file = this.file("inbox");
         return this.withInboxLock(file, () => {
             let rawRows;
@@ -667,7 +964,7 @@ export class AgentStateStore {
             const envelopes = [];
             const remaining = [];
             for (const row of rows) {
-                const selectedTarget = typeof row.target === "string" ? row.target : targetKeyOfInboxEnvelope(row);
+                const selectedTarget = targetKeyOfInboxEnvelope(row);
                 if (envelopes.length < limit && (!options.target || options.target === selectedTarget))
                     envelopes.push(row);
                 else
@@ -676,7 +973,7 @@ export class AgentStateStore {
             const pendingCount = remaining.reduce((count, row) => {
                 if (!options.target)
                     return count + 1;
-                const rowTarget = typeof row.target === "string" ? row.target : targetKeyOfInboxEnvelope(row);
+                const rowTarget = targetKeyOfInboxEnvelope(row);
                 return count + (rowTarget === options.target ? 1 : 0);
             }, 0);
             if (!envelopes.length)
@@ -710,7 +1007,7 @@ export class AgentStateStore {
             }
             let seenThroughSeq = null;
             for (const envelope of envelopes) {
-                const target = String(envelope.target || targetKeyOfInboxEnvelope(envelope));
+                const target = targetKeyOfInboxEnvelope(envelope);
                 const targetSeq = Number(envelope.target_seq);
                 const targetState = state.targets[target] ?? { latest_received_seq: targetSeq, model_seen_seq: 0 };
                 if (validSequence(targetSeq)) {
@@ -731,11 +1028,12 @@ export class AgentStateStore {
     resolveInboxMessageTarget(messageId) {
         return this.withInboxLock(this.file("inbox"), () => {
             const state = this.inboxState();
-            const known = state.messages[messageId]?.target;
+            const known = state.messages[messageId];
             if (known)
-                return known;
+                return targetKeyOfInboxEnvelope({ message_id: messageId, target: known.target,
+                    ...(known.kind ? { kind: known.kind } : {}) });
             const row = this.readNdjson("inbox").find((candidate) => candidate.message_id === messageId);
-            return row ? (typeof row.target === "string" ? row.target : targetKeyOfInboxEnvelope(row)) : null;
+            return row ? targetKeyOfInboxEnvelope(row) : null;
         });
     }
     listInboxDrafts() {

package/dist/agent/agent-transport.cjs

@@ -87,12 +87,14 @@ function createAgentTransport(env = process.env) {
         // —— legacy events/inbox characterization：从 host 写的 inbox 文件读入站正文（读后清空=已读）——
         //    必须严格对齐 agentApiEventsResponseSchema，否则 CLI 报 INVALID_JSON_RESPONSE，Claude 读不到消息。
         if (p.includes("/events") || p.includes("/inbox")) {
-            let envelopes = [];
             try {
-                envelopes = stateStore.pollInbox().envelopes;
+                const envelopes = stateStore.pollInbox().envelopes;
+                return { ok: true, status: 200, data: projectInboxEvents(envelopes) };
+            }
+            catch (error) {
+                return { ok: false, status: 409,
+                    error: `Inbox consumption rejected; persisted rows were left unchanged: ${error instanceof Error ? error.message : String(error)}` };
             }
-            catch { /* preserve legacy: malformed/unreadable inbox returns empty and is not cleared */ }
-            return { ok: true, status: 200, data: projectInboxEvents(envelopes) };
         }
         // —— legacy history characterization：接飞书群历史 im +chat-messages-list ——
         //    需 bot 有 im:message:readonly；缺 scope 则优雅降级为空（不让 Claude 崩）。

package/dist/agent/agent-transport.mjs

@@ -80,12 +80,14 @@ export function createAgentTransport(env = process.env) {
         // —— legacy events/inbox characterization：从 host 写的 inbox 文件读入站正文（读后清空=已读）——
         //    必须严格对齐 agentApiEventsResponseSchema，否则 CLI 报 INVALID_JSON_RESPONSE，Claude 读不到消息。
         if (p.includes("/events") || p.includes("/inbox")) {
-            let envelopes = [];
             try {
-                envelopes = stateStore.pollInbox().envelopes;
+                const envelopes = stateStore.pollInbox().envelopes;
+                return { ok: true, status: 200, data: projectInboxEvents(envelopes) };
+            }
+            catch (error) {
+                return { ok: false, status: 409,
+                    error: `Inbox consumption rejected; persisted rows were left unchanged: ${error instanceof Error ? error.message : String(error)}` };
             }
-            catch { /* preserve legacy: malformed/unreadable inbox returns empty and is not cleared */ }
-            return { ok: true, status: 200, data: projectInboxEvents(envelopes) };
         }
         // —— legacy history characterization：接飞书群历史 im +chat-messages-list ——
         //    需 bot 有 im:message:readonly；缺 scope 则优雅降级为空（不让 Claude 崩）。

package/dist/agent/host-reminder-orchestrator.cjs

@@ -37,6 +37,12 @@ exports.HostReminderOrchestrator = void 0;
 const fs = __importStar(require("node:fs"));
 const host_business_state_js_1 = require("../feishu/host-business-state.cjs");
 const defaultReminderStore = __importStar(require("./reminder-store.cjs"));
+const inbox_projection_js_1 = require("./inbox-projection.cjs");
+function withCanonicalTarget(envelope) {
+    const input = envelope;
+    const target = (0, inbox_projection_js_1.targetKeyOfInboxEnvelope)(input);
+    return input.target === target ? envelope : { ...envelope, target };
+}
 class HostReminderOrchestrator {
     options;
     lastSnapshot = new Map();
@@ -99,14 +105,14 @@ class HostReminderOrchestrator {
     }
     deliver(agent, reminder, overdueMs) {
         const recurrence = reminder.repeat ? this.store.parseRepeat(reminder.repeat, reminder.tz) : null;
-        const envelope = this.options.envelopeProjector.createReminderEnvelope(agent.agentId, {
+        const envelope = withCanonicalTarget(this.options.envelopeProjector.createReminderEnvelope(agent.agentId, {
             reminderId: reminder.reminderId,
             title: reminder.title,
             repeat: reminder.repeat ? String(reminder.repeat) : null,
             fireAt: reminder.fireAt,
             msgRef: reminder.msgRef,
             channel: reminder.channel ? String(reminder.channel) : null,
-        }, overdueMs, reminder.repeat && recurrence && !("error" in recurrence) ? (recurrence.description || null) : null);
+        }, overdueMs, reminder.repeat && recurrence && !("error" in recurrence) ? (recurrence.description || null) : null));
         try {
             this.options.stateStore(agent).appendNdjson("inbox", envelope);
         }
@@ -268,7 +274,7 @@ class HostReminderOrchestrator {
                 this.redelivered.add(agent.agentId);
             return;
         }
-        const envelope = existing ?? this.options.envelopeProjector.createRedeliveryEnvelope(agent.agentId, wakeCount);
+        const envelope = withCanonicalTarget(existing ?? this.options.envelopeProjector.createRedeliveryEnvelope(agent.agentId, wakeCount));
         if (!existing) {
             try {
                 this.options.stateStore(agent).appendNdjson("inbox", envelope);

package/dist/agent/host-reminder-orchestrator.mjs

@@ -1,6 +1,12 @@
 import * as fs from "node:fs";
 import { countWakeEnvelopes } from "../feishu/host-business-state.mjs";
 import * as defaultReminderStore from "./reminder-store.mjs";
+import { targetKeyOfInboxEnvelope } from "./inbox-projection.mjs";
+function withCanonicalTarget(envelope) {
+    const input = envelope;
+    const target = targetKeyOfInboxEnvelope(input);
+    return input.target === target ? envelope : { ...envelope, target };
+}
 export class HostReminderOrchestrator {
     options;
     lastSnapshot = new Map();
@@ -63,14 +69,14 @@ export class HostReminderOrchestrator {
     }
     deliver(agent, reminder, overdueMs) {
         const recurrence = reminder.repeat ? this.store.parseRepeat(reminder.repeat, reminder.tz) : null;
-        const envelope = this.options.envelopeProjector.createReminderEnvelope(agent.agentId, {
+        const envelope = withCanonicalTarget(this.options.envelopeProjector.createReminderEnvelope(agent.agentId, {
             reminderId: reminder.reminderId,
             title: reminder.title,
             repeat: reminder.repeat ? String(reminder.repeat) : null,
             fireAt: reminder.fireAt,
             msgRef: reminder.msgRef,
             channel: reminder.channel ? String(reminder.channel) : null,
-        }, overdueMs, reminder.repeat && recurrence && !("error" in recurrence) ? (recurrence.description || null) : null);
+        }, overdueMs, reminder.repeat && recurrence && !("error" in recurrence) ? (recurrence.description || null) : null));
         try {
             this.options.stateStore(agent).appendNdjson("inbox", envelope);
         }
@@ -232,7 +238,7 @@ export class HostReminderOrchestrator {
                 this.redelivered.add(agent.agentId);
             return;
         }
-        const envelope = existing ?? this.options.envelopeProjector.createRedeliveryEnvelope(agent.agentId, wakeCount);
+        const envelope = withCanonicalTarget(existing ?? this.options.envelopeProjector.createRedeliveryEnvelope(agent.agentId, wakeCount));
         if (!existing) {
             try {
                 this.options.stateStore(agent).appendNdjson("inbox", envelope);