@xdxer/dingtalk-agent 0.1.1 → 0.1.4-beta.0

package/dist/src/waits.js

@@ -0,0 +1,945 @@
+// 单链 Durable Wait（TypeScript source）。
+//
+// v1 只解决一件事：ask 之后，下一条来自同一 Field/tenant/conversation/actor
+// 的 DM 或直接 @，恢复原 Session 并创建新 Run。这里不实现通用 workflow/stack。
+import { existsSync, linkSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+import { hostname } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { digest, stableStringify } from './events.js';
+const OPEN_CHAIN = new Set([
+    'arming', 'active', 'uncertain', 'claimed', 'cancel-pending',
+]);
+const RESUMABLE = new Set(['active', 'uncertain']);
+const DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+export function armWait(root, cfg, input) {
+    const scope = scopeFromTarget(input.fieldId, input.event, input.target);
+    if (!scope) {
+        throw new Error('ask 无法建立 Wait：必须有 tenant、conversation、actor，且事件是 DM 或直接 @');
+    }
+    const rootPath = waitRoot(root, cfg);
+    const scopeHash = digest(stableStringify(scope));
+    const path = join(rootPath, `${scopeHash}.json`);
+    const waitId = `wait_${digest(`${input.sessionId}\0${input.actionId}`).slice(0, 20)}`;
+    const history = join(rootPath, 'history', `${waitId}.json`);
+    mkdirSync(rootPath, { recursive: true });
+    // 旧 ask 的 Receipt 可能在同一 scope 已进入下一轮 Wait 后重放；历史记录存在时
+    // 只返回原 Wait，不能用旧 Receipt 覆盖当前正在等待的新问题。
+    if (existsSync(history)) {
+        const recorded = readJson(history);
+        assertScope(recorded, scope, scopeHash);
+        if (recorded.id === waitId && recorded.actionId === input.actionId &&
+            recorded.sessionId === input.sessionId)
+            return recorded;
+    }
+    return withLock(path, () => {
+        let existing = existsSync(path) ? readJson(path) : null;
+        if (existing) {
+            assertScope(existing, scope, scopeHash);
+            existing = repairFromReceipt(root, cfg, path, existing);
+        }
+        if (existing?.id === waitId && existing.actionId === input.actionId)
+            return existing;
+        const ownedClaim = existing?.status === 'claimed' &&
+            existing.sessionId === input.sessionId &&
+            existing.claim?.runId === input.sourceRunId;
+        if (existing && OPEN_CHAIN.has(existing.status) && !expired(existing) &&
+            !ownedClaim) {
+            throw new Error(`同一人员/会话已有未完成 Wait ${existing.id}（Session ${existing.sessionId}）；` +
+                '单链 v1 拒绝并行追问');
+        }
+        if (ownedClaim) {
+            persistHistory(path, {
+                ...existing, status: 'continued', continuedAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        const now = new Date().toISOString();
+        const ttl = positiveNumber(cfg.runtime?.waitTtlMs, DEFAULT_TTL_MS);
+        const record = {
+            $schema: 'dingtalk-agent/wait@1',
+            id: waitId,
+            scopeHash,
+            scope,
+            fieldId: input.fieldId,
+            sessionId: input.sessionId,
+            sessionPath: resolve(input.sessionPath),
+            sourceRunId: input.sourceRunId,
+            actionId: input.actionId,
+            questionText: String(input.questionText || ''),
+            status: 'arming',
+            version: Number(existing?.version || 0) + 1,
+            createdAt: now,
+            updatedAt: now,
+            expiresAt: new Date(Date.now() + ttl).toISOString(),
+            delivery: null,
+            claim: null,
+        };
+        persistWait(path, record);
+        return record;
+    });
+}
+/** Receipt 是真值；重放 Receipt 也能幂等补齐 active/uncertain Wait。 */
+export function reconcileWaitFromReceipt(root, cfg, wait, receipt) {
+    if (!wait)
+        return null;
+    if (wait.actionId !== receipt.actionId) {
+        throw new Error(`Wait/Receipt actionId 不一致: ${wait.actionId}/${receipt.actionId}`);
+    }
+    if (wait.lastAppliedReceiptActionId === receipt.actionId)
+        return wait;
+    const path = join(waitRoot(root, cfg), `${wait.scopeHash}.json`);
+    return withLock(path, () => {
+        if (!existsSync(path))
+            throw new Error(`Wait 索引丢失: ${wait.id}`);
+        const current = readJson(path);
+        if (current.id === wait.id && current.actionId === receipt.actionId) {
+            if (current.lastAppliedReceiptActionId === receipt.actionId)
+                return current;
+            const next = applyReceipt(current, receipt);
+            persistWait(path, next);
+            return next;
+        }
+        // 该链可能已经进入下一轮 Wait；旧 Receipt 只补自己的历史，不得覆盖 scope head。
+        const history = join(waitRoot(root, cfg), 'history', `${wait.id}.json`);
+        if (!existsSync(history)) {
+            throw new Error(`Wait/Receipt 身份冲突: wait=${current.id}, action=${receipt.actionId}`);
+        }
+        const recorded = readJson(history);
+        if (recorded.id !== wait.id || recorded.actionId !== receipt.actionId) {
+            throw new Error(`Wait 历史与 Receipt 身份冲突: wait=${wait.id}, action=${receipt.actionId}`);
+        }
+        if (recorded.lastAppliedReceiptActionId === receipt.actionId)
+            return recorded;
+        const next = applyReceipt(recorded, receipt);
+        persistHistory(path, next);
+        return next;
+    });
+}
+/** DWS 已返回可查询结果后立即开放 Wait；平台回读可以随后完成。 */
+export function markWaitTransportAccepted(root, cfg, wait, result) {
+    if (!wait)
+        return null;
+    const path = join(waitRoot(root, cfg), `${wait.scopeHash}.json`);
+    return withLock(path, () => {
+        if (!existsSync(path))
+            throw new Error(`Wait 索引丢失: ${wait.id}`);
+        const current = readJson(path);
+        if (current.id === wait.id) {
+            const next = applyTransportResult(current, result);
+            persistWait(path, next);
+            return next;
+        }
+        const history = join(waitRoot(root, cfg), 'history', `${wait.id}.json`);
+        if (!existsSync(history))
+            throw new Error(`Wait 已被其他链替换: ${wait.id}`);
+        const recorded = readJson(history);
+        if (recorded.id !== wait.id || recorded.actionId !== wait.actionId) {
+            throw new Error(`Wait 历史与 transport-result 身份冲突: ${wait.id}`);
+        }
+        const next = applyTransportResult(recorded, result);
+        persistHistory(path, next);
+        return next;
+    });
+}
+/** resumed Run 给出最终 reply/silence 后，释放单链 scope。 */
+export function completeWaitFromReceipt(root, cfg, resume, receipt) {
+    if (resume?.mode !== 'resume' || !resume.waitId)
+        return null;
+    const rootPath = waitRoot(root, cfg);
+    const historyPath = join(rootPath, 'history', `${resume.waitId}.json`);
+    let recorded = existsSync(historyPath) ? readJson(historyPath) : null;
+    let scopeHash = recorded?.scopeHash || resume.waitScopeHash || '';
+    if (!scopeHash && existsSync(rootPath)) {
+        const matches = readdirSync(rootPath)
+            .filter((name) => name.endsWith('.json'))
+            .map((name) => readJson(join(rootPath, name)))
+            .filter((candidate) => candidate.id === resume.waitId);
+        if (matches.length === 1) {
+            recorded = matches[0];
+            scopeHash = recorded.scopeHash;
+        }
+    }
+    if (!scopeHash)
+        throw new Error(`Wait 历史丢失且无法从 scope head 修复: ${resume.waitId}`);
+    const path = join(rootPath, `${scopeHash}.json`);
+    return withLock(path, () => {
+        if (!recorded) {
+            const current = existsSync(path) ? readJson(path) : null;
+            if (!current || current.id !== resume.waitId) {
+                throw new Error(`Wait 历史丢失且 scope head 不匹配: ${resume.waitId}`);
+            }
+            recorded = current;
+            persistHistory(path, recorded);
+        }
+        const now = new Date().toISOString();
+        const current = existsSync(path) ? readJson(path) : null;
+        if (current?.id === recorded.id) {
+            if (current.status === 'cancelled') {
+                persistHistory(path, current);
+                return current;
+            }
+            const next = {
+                ...current,
+                status: current.status === 'cancel-pending' ? 'cancel-pending' : 'completed',
+                updatedAt: now, completedAt: now,
+                completedByReceiptActionId: receipt.actionId,
+            };
+            persistWait(path, next);
+            return next;
+        }
+        const next = {
+            ...recorded, status: recorded.status === 'cancelled' ? 'cancelled' : 'completed',
+            updatedAt: now, completedAt: now, completedByReceiptActionId: receipt.actionId,
+        };
+        persistHistory(path, next);
+        return next;
+    });
+}
+/**
+ * 显式 /stop、/cancel 是宿主控制面：不依赖当前 Field/Behavior/Skill。
+ * 先写 cancel-pending，再在线性化锁内提升 Session generation，最后写 cancelled。
+ */
+export function cancelWaitForEvent(root, cfg, event) {
+    if (!isCancelCommand(event.message?.text))
+        return null;
+    const eventScope = scopeWithoutField(event);
+    if (!eventScope)
+        return null;
+    const rootPath = waitRoot(root, cfg);
+    const replay = readEventBinding(rootPath, event.id);
+    if (replay) {
+        assertEventBinding(replay, event, 'cancel', eventScope);
+        if (replay.outcome === 'no-match')
+            return null;
+        if (replay.outcome === 'ambiguous') {
+            throw new Error(`取消命中多个 Wait，已固化为 ambiguous: ${(replay.candidates || []).join(', ')}`);
+        }
+        return cancelBoundWait(root, cfg, event, replay);
+    }
+    if (!existsSync(rootPath)) {
+        createNoMatchBinding(rootPath, event, 'cancel', eventScope);
+        return null;
+    }
+    const candidates = [];
+    for (const name of readdirSync(rootPath)) {
+        if (!name.endsWith('.json'))
+            continue;
+        const path = join(rootPath, name);
+        const record = readJson(path);
+        const sameCancel = record.claim?.eventId === event.id &&
+            record.claim?.cancelRequested === true;
+        if (sameEventScope(record.scope, eventScope) &&
+            (OPEN_CHAIN.has(record.status) || sameCancel ||
+                (record.status === 'cancelled' && record.claim?.eventId === event.id))) {
+            candidates.push({ path, record });
+        }
+    }
+    if (candidates.length > 1) {
+        createNoMatchBinding(rootPath, event, 'cancel', eventScope, {
+            outcome: 'ambiguous', candidates: candidates.map((x) => x.record.id).sort(),
+        });
+        throw new Error(`取消命中多个 Wait，拒绝猜测: ${candidates.map((x) => x.record.id).join(', ')}`);
+    }
+    if (!candidates.length) {
+        createNoMatchBinding(rootPath, event, 'cancel', eventScope);
+        return null;
+    }
+    const { path } = candidates[0];
+    const bound = withLock(path, () => {
+        let current = readJson(path);
+        if (!sameEventScope(current.scope, eventScope)) {
+            throw new Error(`取消 Wait 作用域漂移: ${current.id}`);
+        }
+        current = repairFromReceipt(root, cfg, path, current);
+        if (current.status === 'cancelled' && current.claim?.eventId === event.id) {
+            return createEventBinding(rootPath, event, 'cancel', current);
+        }
+        if (!OPEN_CHAIN.has(current.status)) {
+            createNoMatchBinding(rootPath, event, 'cancel', eventScope);
+            return null;
+        }
+        // 先把 head 置为 pending，再写 ledger。两者之间即使 SIGKILL，重放也会从
+        // pending 的 eventId 恢复；Action 无法趁 binding→effect-lock 窗口建立 W2。
+        const now = new Date().toISOString();
+        const sameCancel = current.claim?.eventId === event.id &&
+            current.claim?.cancelRequested === true;
+        ensureClaimBinding(rootPath, current);
+        const pending = {
+            ...current,
+            status: 'cancel-pending',
+            updatedAt: now,
+            previousClaim: sameCancel ? current.previousClaim || null : current.claim || null,
+            claim: {
+                eventId: event.id, eventKind: event.kind, claimedAt: now,
+                runId: '', cancelRequested: true,
+            },
+        };
+        persistWait(path, pending);
+        const binding = createEventBinding(rootPath, event, 'cancel', pending);
+        return binding;
+    });
+    return bound ? cancelBoundWait(root, cfg, event, bound) : null;
+}
+/** Action 与 cancel 共用这一把锁；先拿到锁的一方定义副作用先后。 */
+export function acquireSessionEffectLock(root, sessionPath) {
+    const dir = resolve(root, '.dingtalk-agent/session-effect-locks');
+    mkdirSync(dir, { recursive: true });
+    return acquireLock(join(dir, `${digest(resolve(sessionPath))}.lock`), 30 * 60_000, 3 * 60_000);
+}
+/**
+ * incoming Event 在创建新 Session 前调用。显式 sessionKey/correlation 由调用方优先处理。
+ * claimed/cancelled + 同 eventId 可重入，覆盖 materialize 过程中崩溃后的恢复窗口。
+ */
+export function claimWait(root, cfg, fieldId, event) {
+    const scope = scopeFromEvent(fieldId, event);
+    if (!scope)
+        return null;
+    const rootPath = waitRoot(root, cfg);
+    const scopeHash = digest(stableStringify(scope));
+    const path = join(rootPath, `${scopeHash}.json`);
+    const replay = readEventBinding(rootPath, event.id);
+    if (replay) {
+        assertEventBinding(replay, event, 'claim', scope);
+        if (replay.outcome === 'no-match')
+            return null;
+        return claimBoundWait(root, cfg, event, replay);
+    }
+    return withLock(path, () => {
+        if (!existsSync(path)) {
+            createNoMatchBinding(rootPath, event, 'claim', scope);
+            return null;
+        }
+        let current = readJson(path);
+        assertScope(current, scope, scopeHash);
+        current = repairFromReceipt(root, cfg, path, current);
+        if (current.status === 'claimed' && current.claim?.eventId === event.id &&
+            current.claim?.cancelRequested !== true) {
+            createEventBinding(rootPath, event, 'claim', current);
+            return current;
+        }
+        if (expired(current)) {
+            ensureClaimBinding(rootPath, current);
+            if (OPEN_CHAIN.has(current.status)) {
+                const next = { ...current, status: 'expired', updatedAt: new Date().toISOString() };
+                persistWait(path, next);
+            }
+            createNoMatchBinding(rootPath, event, 'claim', scope);
+            return null;
+        }
+        if (!RESUMABLE.has(current.status)) {
+            createNoMatchBinding(rootPath, event, 'claim', scope);
+            return null;
+        }
+        const now = new Date().toISOString();
+        const next = {
+            ...current,
+            status: 'claimed',
+            updatedAt: now,
+            claim: {
+                eventId: event.id,
+                eventKind: event.kind,
+                claimedAt: now,
+                runId: '',
+                cancelRequested: false,
+            },
+        };
+        persistWait(path, next);
+        createEventBinding(rootPath, event, 'claim', next);
+        return next;
+    });
+}
+export function attachClaimedRun(root, cfg, wait, eventId, runId) {
+    if (!wait)
+        return null;
+    const path = join(waitRoot(root, cfg), `${wait.scopeHash}.json`);
+    return withLock(path, () => {
+        const loaded = readBoundWait(path, wait.id);
+        if (!loaded || loaded.record.claim?.eventId !== eventId) {
+            throw new Error(`Wait claim 身份冲突: wait=${wait.id}, event=${eventId}`);
+        }
+        const current = loaded.record;
+        if (current.claim.runId && current.claim.runId !== runId) {
+            throw new Error(`Wait ${wait.id} 已绑定其他 Run: ${current.claim.runId}`);
+        }
+        if (current.claim.runId === runId) {
+            // head 已写而 history 未写时，幂等重试必须顺手补齐历史真值。
+            persistBoundWait(path, current, loaded.isHead);
+            return current;
+        }
+        const next = {
+            ...current,
+            updatedAt: new Date().toISOString(),
+            claim: { ...current.claim, runId },
+        };
+        persistBoundWait(path, next, loaded.isHead);
+        return next;
+    });
+}
+export function waitRoot(root, cfg) {
+    return resolve(root, cfg.runtime?.waitRoot || '.dingtalk-agent/waits');
+}
+export function readWaitForEvent(root, cfg, fieldId, event) {
+    const scope = scopeFromEvent(fieldId, event);
+    if (!scope)
+        return null;
+    const path = join(waitRoot(root, cfg), `${digest(stableStringify(scope))}.json`);
+    return existsSync(path) ? readJson(path) : null;
+}
+export function isCancelCommand(text) {
+    return /^\/(?:stop|cancel|停止|取消)$/i.test(String(text || '').trim());
+}
+/** eventId 一旦绑定 Wait，重放永远解析原 Wait，不能重新扫描当前 scope head。 */
+function createEventBinding(rootPath, event, operation, wait) {
+    const path = eventBindingPath(rootPath, event.id);
+    const binding = {
+        $schema: 'dingtalk-agent/wait-event-binding@1',
+        eventId: event.id,
+        eventKind: event.kind,
+        operation,
+        outcome: 'matched',
+        waitId: wait.id,
+        scopeHash: wait.scopeHash,
+        scope: wait.scope,
+        fieldId: wait.fieldId,
+        sessionId: wait.sessionId,
+        sessionPath: wait.sessionPath,
+        sourceRunId: wait.sourceRunId,
+        actionId: wait.actionId,
+        boundAt: new Date().toISOString(),
+    };
+    if (!writeJsonCreateAtomic(path, binding)) {
+        const existing = readJson(path);
+        if (stableStringify(bindingIdentity(existing)) !== stableStringify(bindingIdentity(binding))) {
+            throw new Error(`Event ${event.id} 已绑定其他 Wait，拒绝 ABA 重解释`);
+        }
+        return existing;
+    }
+    return binding;
+}
+function createNoMatchBinding(rootPath, event, operation, scope, options = {}) {
+    const path = eventBindingPath(rootPath, event.id);
+    const binding = {
+        $schema: 'dingtalk-agent/wait-event-binding@1',
+        eventId: event.id,
+        eventKind: event.kind,
+        operation,
+        outcome: options.outcome || 'no-match',
+        candidates: options.candidates || [],
+        waitId: '',
+        scopeHash: digest(stableStringify(scope)),
+        scope,
+        fieldId: '',
+        sessionId: '',
+        sessionPath: '',
+        sourceRunId: '',
+        actionId: '',
+        boundAt: new Date().toISOString(),
+    };
+    if (!writeJsonCreateAtomic(path, binding)) {
+        const existing = readJson(path);
+        if (stableStringify(bindingIdentity(existing)) !== stableStringify(bindingIdentity(binding))) {
+            throw new Error(`Event ${event.id} 的 Wait 路由决策已固化，拒绝重新解释`);
+        }
+        return existing;
+    }
+    return binding;
+}
+function readEventBinding(rootPath, eventId) {
+    const path = eventBindingPath(rootPath, eventId);
+    return existsSync(path) ? readJson(path) : null;
+}
+function eventBindingPath(rootPath, eventId) {
+    return join(rootPath, 'events', `${digest(eventId)}.json`);
+}
+function bindingIdentity(value) {
+    return {
+        eventId: value.eventId,
+        eventKind: value.eventKind,
+        operation: value.operation,
+        outcome: value.outcome,
+        candidates: value.candidates || [],
+        waitId: value.waitId,
+        scopeHash: value.scopeHash,
+        scope: value.scope,
+        fieldId: value.fieldId,
+        sessionId: value.sessionId,
+        sessionPath: value.sessionPath,
+        sourceRunId: value.sourceRunId,
+        actionId: value.actionId,
+    };
+}
+function assertEventBinding(binding, event, operation, expectedScope) {
+    if (binding.eventId !== event.id || binding.eventKind !== event.kind ||
+        binding.operation !== operation) {
+        throw new Error(`Event ${event.id} 的 Wait binding 类型冲突`);
+    }
+    const scopeMatches = operation === 'cancel'
+        ? sameEventScope(binding.scope, expectedScope)
+        : stableStringify(binding.scope) === stableStringify(expectedScope);
+    if (!scopeMatches || binding.scopeHash !== digest(stableStringify(binding.scope))) {
+        throw new Error(`Event ${event.id} 的 Wait binding 作用域漂移`);
+    }
+}
+function assertWaitBinding(record, binding) {
+    const actual = {
+        waitId: record.id,
+        scopeHash: record.scopeHash,
+        fieldId: record.fieldId,
+        sessionId: record.sessionId,
+        sessionPath: record.sessionPath,
+        sourceRunId: record.sourceRunId,
+        actionId: record.actionId,
+    };
+    const expected = {
+        waitId: binding.waitId,
+        scopeHash: binding.scopeHash,
+        fieldId: binding.fieldId,
+        sessionId: binding.sessionId,
+        sessionPath: binding.sessionPath,
+        sourceRunId: binding.sourceRunId,
+        actionId: binding.actionId,
+    };
+    if (stableStringify(actual) !== stableStringify(expected)) {
+        throw new Error(`Wait event binding 身份漂移: ${binding.waitId}`);
+    }
+}
+function cancelBoundWait(root, cfg, event, binding) {
+    const path = join(waitRoot(root, cfg), `${binding.scopeHash}.json`);
+    let pending = withLock(path, () => {
+        const loaded = readBoundWait(path, binding.waitId);
+        if (!loaded)
+            throw new Error(`取消绑定的 Wait 不存在: ${binding.waitId}`);
+        let current = loaded.record;
+        assertWaitBinding(current, binding);
+        if (loaded.isHead)
+            current = repairFromReceipt(root, cfg, path, current);
+        if (current.status === 'cancelled' && current.claim?.eventId === event.id)
+            return current;
+        if (['cancel-pending', 'cancelled'].includes(current.status) &&
+            current.claim?.cancelRequested === true && current.claim?.eventId !== event.id) {
+            // 两个 stop 同时到达时只让先行者提升 generation；后来者成为同 Session 的安全 no-op。
+            return suppressedClaim(current, event.id);
+        }
+        const sameCancel = current.claim?.eventId === event.id &&
+            current.claim?.cancelRequested === true;
+        if (!OPEN_CHAIN.has(current.status) && !sameCancel) {
+            throw new Error(`取消绑定的 Wait 已进入 ${current.status}: ${binding.waitId}`);
+        }
+        const now = new Date().toISOString();
+        ensureClaimBinding(waitRoot(root, cfg), current);
+        const next = {
+            ...current,
+            status: 'cancel-pending',
+            updatedAt: now,
+            previousClaim: sameCancel ? current.previousClaim || null : current.claim || null,
+            claim: {
+                eventId: event.id, eventKind: event.kind, claimedAt: now,
+                runId: '', cancelRequested: true,
+            },
+        };
+        persistBoundWait(path, next, loaded.isHead);
+        return next;
+    });
+    if (pending.suppressed)
+        return pending;
+    applyCancelFence(root, pending, event.id);
+    pending = withLock(path, () => {
+        const loaded = readBoundWait(path, binding.waitId);
+        if (!loaded)
+            throw new Error(`取消完成时 Wait 丢失: ${binding.waitId}`);
+        const current = loaded.record;
+        assertWaitBinding(current, binding);
+        if (current.claim?.eventId !== event.id) {
+            throw new Error(`取消 Wait 身份漂移: ${binding.waitId}`);
+        }
+        if (current.status === 'cancelled') {
+            persistBoundWait(path, current, loaded.isHead);
+            return current;
+        }
+        const next = { ...current, status: 'cancelled', updatedAt: new Date().toISOString() };
+        persistBoundWait(path, next, loaded.isHead);
+        return next;
+    });
+    return pending;
+}
+function claimBoundWait(root, cfg, event, binding) {
+    const path = join(waitRoot(root, cfg), `${binding.scopeHash}.json`);
+    return withLock(path, () => {
+        const loaded = readBoundWait(path, binding.waitId);
+        if (!loaded)
+            throw new Error(`回复绑定的 Wait 不存在: ${binding.waitId}`);
+        let current = loaded.record;
+        assertWaitBinding(current, binding);
+        if (loaded.isHead)
+            current = repairFromReceipt(root, cfg, path, current);
+        if (current.status === 'claimed' && current.claim?.eventId === event.id) {
+            if (!loaded.isHead)
+                throw new Error(`已 claim 的 Wait 不再是 scope head: ${binding.waitId}`);
+            return current;
+        }
+        if (['cancel-pending', 'cancelled'].includes(current.status) &&
+            current.claim?.cancelRequested === true) {
+            return suppressedClaim(current, event.id);
+        }
+        if (!loaded.isHead || !RESUMABLE.has(current.status) || expired(current)) {
+            throw new Error(`回复事件已绑定 Wait ${binding.waitId}，但当前状态为 ${current.status}；拒绝回退成新事项`);
+        }
+        const now = new Date().toISOString();
+        const next = {
+            ...current,
+            status: 'claimed',
+            updatedAt: now,
+            claim: {
+                eventId: event.id, eventKind: event.kind, claimedAt: now,
+                runId: '', cancelRequested: false,
+            },
+        };
+        persistWait(path, next);
+        return next;
+    });
+}
+function suppressedClaim(record, eventId) {
+    const cancelEventId = record.claim?.eventId || '';
+    return {
+        ...record,
+        suppressed: true,
+        cancelEventId,
+        claim: {
+            eventId,
+            claimedAt: new Date().toISOString(),
+            runId: '',
+            cancelRequested: true,
+            supersededByEventId: cancelEventId,
+        },
+    };
+}
+function ensureClaimBinding(rootPath, record) {
+    const claim = record.claim?.cancelRequested !== true
+        ? record.claim
+        : record.previousClaim?.cancelRequested !== true ? record.previousClaim : null;
+    if (!claim?.eventId)
+        return null;
+    if (!claim.eventKind) {
+        throw new Error(`Wait ${record.id} 的 claim 缺少 eventKind，无法安全修复 event ledger`);
+    }
+    return createEventBinding(rootPath, {
+        id: claim.eventId,
+        kind: claim.eventKind,
+    }, 'claim', record);
+}
+function readBoundWait(scopePath, waitId) {
+    if (existsSync(scopePath)) {
+        const current = readJson(scopePath);
+        if (current.id === waitId)
+            return { record: current, isHead: true };
+    }
+    const history = join(dirname(scopePath), 'history', `${waitId}.json`);
+    return existsSync(history) ? { record: readJson(history), isHead: false } : null;
+}
+function persistBoundWait(scopePath, record, isHead) {
+    if (isHead)
+        persistWait(scopePath, record);
+    else
+        persistHistory(scopePath, record);
+}
+function scopeFromTarget(fieldId, event, target) {
+    if (!['im.message.dm', 'im.message.mentioned'].includes(event.kind))
+        return null;
+    return completeScope({
+        fieldId,
+        tenantId: target?.tenantId || event.tenant?.id,
+        conversationId: target?.conversationId || event.conversation?.id,
+        actorId: target?.senderOpenDingTalkId || event.actor?.openDingTalkId,
+    });
+}
+function scopeFromEvent(fieldId, event) {
+    if (!['im.message.dm', 'im.message.mentioned'].includes(event.kind))
+        return null;
+    return completeScope({
+        fieldId,
+        tenantId: event.tenant?.id,
+        conversationId: event.conversation?.id,
+        actorId: event.actor?.openDingTalkId,
+    });
+}
+function scopeWithoutField(event) {
+    if (!['im.message.dm', 'im.message.mentioned'].includes(event.kind))
+        return null;
+    return completeScope({
+        tenantId: event.tenant?.id,
+        conversationId: event.conversation?.id,
+        actorId: event.actor?.openDingTalkId,
+    });
+}
+function sameEventScope(scope, expected) {
+    return scope?.tenantId === expected.tenantId &&
+        scope?.conversationId === expected.conversationId &&
+        scope?.actorId === expected.actorId;
+}
+function completeScope(value) {
+    const scope = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, String(v || '').trim()]));
+    return Object.values(scope).every(Boolean) ? scope : null;
+}
+function assertScope(record, scope, scopeHash) {
+    if (record.scopeHash !== scopeHash || stableStringify(record.scope) !== stableStringify(scope)) {
+        throw new Error(`Wait scope hash 碰撞或内容漂移: ${scopeHash}`);
+    }
+}
+function expired(record) {
+    const deadline = Date.parse(record.expiresAt || '');
+    return Number.isFinite(deadline) && deadline <= Date.now();
+}
+function positiveNumber(value, fallback) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function applyReceipt(record, receipt) {
+    const keepLifecycle = new Set([
+        'claimed', 'cancel-pending', 'cancelled', 'completed', 'continued', 'expired',
+    ]).has(record.status);
+    const transportAccepted = Boolean(record.delivery?.transportAccepted);
+    return {
+        ...record,
+        status: keepLifecycle
+            ? record.status
+            : (receipt.outcome === 'uncertain' && !transportAccepted ? 'uncertain' : 'active'),
+        updatedAt: new Date().toISOString(),
+        lastAppliedReceiptActionId: receipt.actionId,
+        delivery: {
+            ...(record.delivery || {}),
+            outcome: receipt.outcome,
+            verified: Boolean(receipt.verified),
+            verification: receipt.verification || '',
+            questionMessageId: findValue(receipt, ['openMessageId', 'openMsgId', 'open_message_id']) ||
+                record.delivery?.questionMessageId || '',
+        },
+    };
+}
+function applyTransportResult(record, result) {
+    return {
+        ...record,
+        status: record.status === 'arming' || record.status === 'uncertain'
+            ? 'active' : record.status,
+        updatedAt: new Date().toISOString(),
+        delivery: {
+            ...(record.delivery || {}),
+            transportAccepted: true,
+            questionMessageId: findValue(result, ['openMessageId', 'openMsgId', 'open_message_id']) ||
+                record.delivery?.questionMessageId || '',
+        },
+    };
+}
+/** 在 incoming Event 路由时修复 Receipt/transport-result 已落盘但 Wait 仍 arming 的窗口。 */
+function repairFromReceipt(root, cfg, path, record) {
+    if (record.status !== 'arming')
+        return record;
+    const actionPath = join(resolve(root, cfg.runtime?.eventIndexRoot || '.dingtalk-agent/event-index'), 'actions', record.sourceRunId, record.actionId);
+    const receiptPath = join(actionPath, 'receipt.json');
+    const resultPath = join(actionPath, 'transport-result.json');
+    if (!existsSync(receiptPath) && !existsSync(resultPath))
+        return record;
+    const receipt = existsSync(receiptPath) ? readJson(receiptPath) : null;
+    const result = existsSync(resultPath) ? readJson(resultPath) : null;
+    const next = {
+        ...record,
+        status: (result || receipt?.outcome !== 'uncertain') ? 'active' : 'uncertain',
+        updatedAt: new Date().toISOString(),
+        lastAppliedReceiptActionId: receipt?.actionId || record.lastAppliedReceiptActionId,
+        delivery: {
+            ...(record.delivery || {}),
+            transportAccepted: Boolean(result),
+            outcome: receipt?.outcome || 'transport-accepted',
+            verified: Boolean(receipt?.verified),
+            verification: receipt?.verification || '',
+            questionMessageId: findValue(receipt, ['openMessageId', 'openMsgId', 'open_message_id']) ||
+                findValue(result, ['openMessageId', 'openMsgId', 'open_message_id']) ||
+                record.delivery?.questionMessageId || '',
+        },
+    };
+    persistWait(path, next);
+    return next;
+}
+function applyCancelFence(root, wait, eventId) {
+    const releaseEffect = acquireSessionEffectLock(root, wait.sessionPath);
+    try {
+        const lockRoot = resolve(root, '.dingtalk-agent/session-locks');
+        mkdirSync(lockRoot, { recursive: true });
+        const releaseState = acquireLock(join(lockRoot, `${digest(resolve(wait.sessionPath))}.lock`), 2 * 60_000);
+        try {
+            const sessionPath = join(resolve(wait.sessionPath), 'session.json');
+            if (!existsSync(sessionPath))
+                throw new Error(`取消目标 Session 不存在: ${wait.sessionId}`);
+            const session = readJson(sessionPath);
+            if (session.id !== wait.sessionId || session.fieldId !== wait.fieldId) {
+                throw new Error(`取消目标 Session 身份不一致: ${wait.sessionId}`);
+            }
+            if (session.lastCancelEventId === eventId)
+                return;
+            const generation = validGeneration(session.generation);
+            persist(sessionPath, {
+                ...session,
+                generation: generation + 1,
+                lastCancelEventId: eventId,
+                cancelledAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        finally {
+            releaseState();
+        }
+    }
+    finally {
+        releaseEffect();
+    }
+}
+function validGeneration(value) {
+    const n = Number(value ?? 1);
+    if (!Number.isInteger(n) || n < 1)
+        throw new Error('Session generation 非法，拒绝取消');
+    return n;
+}
+function persist(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temp = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+    writeFileSync(temp, JSON.stringify(value, null, 2) + '\n', { flag: 'wx' });
+    renameSync(temp, path);
+}
+function writeJsonCreateAtomic(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temp = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+    writeFileSync(temp, JSON.stringify(value, null, 2) + '\n', { flag: 'wx' });
+    try {
+        linkSync(temp, path);
+        return true;
+    }
+    catch (e) {
+        if (e.code === 'EEXIST')
+            return false;
+        throw e;
+    }
+    finally {
+        rmSync(temp, { force: true });
+    }
+}
+function persistWait(scopePath, record) {
+    persist(scopePath, record);
+    persistHistory(scopePath, record);
+}
+function persistHistory(scopePath, record) {
+    persist(join(dirname(scopePath), 'history', `${record.id}.json`), record);
+    mirror(record);
+}
+function mirror(record) {
+    try {
+        const dir = join(record.sessionPath, 'waits');
+        mkdirSync(dir, { recursive: true });
+        persist(join(dir, `${record.id}.json`), record);
+    }
+    catch (e) {
+        console.error(`  ⚠️ Wait 审计镜像写入失败（waitRoot 权威真值已保留）: ${e.message}`);
+    }
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+const LOCK_HOST = hostname();
+const sleep = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+function withLock(path, fn) {
+    const lockPath = `${path}.lock`;
+    mkdirSync(dirname(path), { recursive: true });
+    const release = acquireLock(lockPath);
+    try {
+        return fn();
+    }
+    finally {
+        release();
+    }
+}
+function acquireLock(path, staleAfterMs = 60_000, waitMs = 5_000) {
+    const token = randomUUID();
+    const deadline = Date.now() + waitMs;
+    while (true) {
+        try {
+            mkdirSync(path);
+            try {
+                persist(join(path, 'owner.json'), {
+                    token, pid: process.pid, host: LOCK_HOST, acquiredAt: new Date().toISOString(),
+                });
+            }
+            catch (e) {
+                rmSync(path, { recursive: true, force: true });
+                throw e;
+            }
+            return () => {
+                try {
+                    const owner = readJson(join(path, 'owner.json'));
+                    if (owner.token === token)
+                        rmSync(path, { recursive: true, force: true });
+                }
+                catch { }
+            };
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+            if (staleLock(path, staleAfterMs)) {
+                const tomb = `${path}.stale.${process.pid}.${randomUUID()}`;
+                try {
+                    renameSync(path, tomb);
+                    rmSync(tomb, { recursive: true, force: true });
+                    continue;
+                }
+                catch (moveError) {
+                    if (moveError.code === 'ENOENT' || moveError.code === 'EEXIST')
+                        continue;
+                    throw moveError;
+                }
+            }
+            if (Date.now() >= deadline)
+                throw new Error(`Wait 正在被其他事件更新: ${path}`);
+            sleep(50);
+        }
+    }
+}
+function staleLock(path, staleAfterMs) {
+    let age;
+    try {
+        age = Date.now() - statSync(path).mtimeMs;
+    }
+    catch {
+        return true;
+    }
+    let owner;
+    try {
+        owner = readJson(join(path, 'owner.json'));
+    }
+    catch { }
+    if (!owner)
+        return age >= 2_000;
+    if (owner.host === LOCK_HOST && Number.isInteger(Number(owner.pid))) {
+        try {
+            process.kill(Number(owner.pid), 0);
+            return false;
+        }
+        catch (e) {
+            if (e.code === 'ESRCH')
+                return true;
+        }
+    }
+    return age >= staleAfterMs;
+}
+function findValue(value, keys) {
+    if (!value || typeof value !== 'object')
+        return '';
+    for (const key of keys)
+        if (value[key])
+            return String(value[key]);
+    for (const child of Object.values(value)) {
+        const found = findValue(child, keys);
+        if (found)
+            return found;
+    }
+    return '';
+}
+//# sourceMappingURL=waits.js.map