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

package/dist/src/actions.js

@@ -0,0 +1,562 @@
+// Basic Behavior 的四个原子动作（TypeScript source）。
+// Sandbox 中的 context/ 是可读投影；真正的 target/profile/policy/state 来自 sandbox 外 event index。
+import { existsSync, mkdirSync, realpathSync, readdirSync } from 'node:fs';
+import { dirname, join, resolve, parse, basename } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { digest, stableStringify } from './events.js';
+import { acquireControlLock, acquireExecutionLock, readJson, writeJsonAtomic, } from './sessions.js';
+import * as cfgmod from './config.js';
+import * as dws from './dws.js';
+import { verifySkillSnapshot } from './skills.js';
+import { acquireSessionEffectLock, armWait, completeWaitFromReceipt, markWaitTransportAccepted, reconcileWaitFromReceipt, } from './waits.js';
+const OUTWARD = new Set(['ack', 'reply', 'ask']);
+const TERMINAL = new Set(['reply', 'ask', 'silence']);
+const KINDS = new Set(['ack', 'reply', 'ask', 'silence']);
+const SILENCE_REASONS = new Set([
+    'unmentioned', 'already_answered', 'no_value', 'policy_denied', 'unsupported',
+    'heartbeat_noop',
+]);
+class ActionUncertainError extends Error {
+    receipt;
+    constructor(message, receipt) {
+        super(message);
+        this.name = 'ActionUncertainError';
+        this.receipt = receipt;
+    }
+}
+export function findRun(start = process.cwd(), explicit = '') {
+    const picked = explicit || process.env.DTA_RUN || start;
+    let dir = resolve(picked);
+    while (true) {
+        if (existsSync(join(dir, 'run.json')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir || dir === parse(dir).root)
+            break;
+        dir = parent;
+    }
+    throw new Error('找不到当前 Run；请在 prepare 返回的 cwd 中执行，或设置 DTA_RUN/--run');
+}
+export function previewAction(runPath, kind, options = {}) {
+    const context = loadContext(runPath);
+    const payload = normalizePayload(kind, options, context.policy);
+    const nextState = validate(context, kind);
+    return {
+        type: 'dingtalk-agent.action.preview',
+        runId: context.run.id,
+        kind,
+        fromState: context.run.state,
+        toState: nextState,
+        transport: transportName(kind),
+        target: kind === 'silence' ? null : context.target,
+        profile: context.field.dws.profile || '',
+        expectedUserId: context.field.dws.expectedUserId || '',
+        transportMode: context.field.transport.mode || '',
+        egressOwner: context.field.transport.egressOwner || '',
+        payload,
+        authorityHash: context.index.authorityHash,
+        persisted: false,
+        sideEffect: false,
+    };
+}
+export function executeAction(runPath, kind, options = {}) {
+    if (!KINDS.has(kind))
+        throw new Error(`原子动作只能是: ${[...KINDS].join(' / ')}`);
+    let context = loadContext(runPath);
+    const payload = normalizePayload(kind, options, context.policy);
+    const actionId = `act_${digest(`${context.run.id}\0${kind}\0${JSON.stringify(payload)}`).slice(0, 20)}`;
+    let actionPath = join(context.controlActionRoot, actionId);
+    let receiptPath = join(actionPath, 'receipt.json');
+    // Session effect lock 把 cancel 与外部副作用线性化；先拿到锁的一方定义先后。
+    // event execution lock 仍负责同一个 Run 的 Action 幂等，control lock 只做短时 RMW。
+    const releaseSessionEffect = acquireSessionEffectLock(context.root, context.sessionPath);
+    try {
+        const release = acquireExecutionLock(context.indexPath);
+        try {
+            context = loadContext(runPath);
+            reconcileReceipts(context);
+            context = loadContext(runPath);
+            actionPath = join(context.controlActionRoot, actionId);
+            receiptPath = join(actionPath, 'receipt.json');
+            if (existsSync(receiptPath)) {
+                const receipt = readJson(receiptPath);
+                reconcileReceiptWait(context, receipt);
+                return replayReceipt(context, receipt);
+            }
+            assertNoOtherUnresolvedAttempt(context, actionId);
+            const nextState = validate(context, kind);
+            mkdirSync(actionPath, { recursive: true });
+            const intentPath = join(actionPath, 'intent.json');
+            const attemptPath = join(actionPath, 'attempt.json');
+            let intent;
+            if (existsSync(intentPath)) {
+                intent = readJson(intentPath);
+                if (intent.kind !== kind || JSON.stringify(intent.payload) !== JSON.stringify(payload)) {
+                    throw new Error(`Action intent 碰撞: ${actionId}`);
+                }
+            }
+            else {
+                intent = {
+                    $schema: 'dingtalk-agent/action-intent@1',
+                    id: actionId,
+                    runId: context.run.id,
+                    kind,
+                    createdAt: new Date().toISOString(),
+                    transport: transportName(kind),
+                    target: kind === 'silence' ? null : context.target,
+                    dwsProfile: context.field.dws.profile || '',
+                    expectedUserId: context.field.dws.expectedUserId || '',
+                    transportMode: context.field.transport.mode || '',
+                    egressOwner: context.field.transport.egressOwner || '',
+                    uuid: OUTWARD.has(kind) ? randomUUID() : null,
+                    payload,
+                    authorityHash: context.index.authorityHash,
+                };
+                persistArtifact(context, actionPath, 'intent.json', intent);
+            }
+            if (kind === 'silence') {
+                const receipt = finish(context, intent, nextState, {
+                    outcome: 'confirmed', verified: true, verification: 'local-no-side-effect',
+                });
+                persistReceipt(context, actionPath, receipt);
+                completeWaitFromReceipt(context.root, cfgmod.must(context.root), context.run.resume, receipt);
+                projectReceipt(context, receipt);
+                return receipt;
+            }
+            verifyExecutionIdentity(context, intent, actionPath);
+            const wait = kind === 'ask' ? ensureAskWait(context, actionId, payload.text) : null;
+            if (kind === 'ack' && existsSync(attemptPath)) {
+                const receipt = uncertain(context, intent, 'ack 已有 attempt 但没有 receipt；表情动作无服务端幂等键，拒绝盲重试');
+                persistReceipt(context, actionPath, receipt);
+                projectReceipt(context, receipt);
+                return receipt;
+            }
+            if (!existsSync(attemptPath)) {
+                persistArtifact(context, actionPath, 'attempt.json', {
+                    actionId, startedAt: new Date().toISOString(),
+                });
+            }
+            let result;
+            let checked;
+            try {
+                const transportResultPath = join(actionPath, 'transport-result.json');
+                if (existsSync(transportResultPath)) {
+                    // DWS 已返回且结果已落盘时，从本地继续验证；绝不为了补 Receipt 再发一次。
+                    result = readJson(transportResultPath);
+                }
+                else {
+                    result = kind === 'ack'
+                        ? dws.ackMessage(context.target, {
+                            emoji: payload.emoji, profile: intent.dwsProfile,
+                        })
+                        : dws.replyMessage(context.target, payload.text, {
+                            uuid: intent.uuid, profile: intent.dwsProfile,
+                        });
+                    persistArtifact(context, actionPath, 'transport-result.json', result);
+                }
+                if (kind === 'ask')
+                    markWaitTransportAccepted(context.root, cfgmod.must(context.root), wait, result);
+                checked = verify(kind, context.target, result, intent.dwsProfile);
+                if (checked.data !== undefined) {
+                    persistArtifact(context, actionPath, 'verification.json', checked.data);
+                }
+            }
+            catch (e) {
+                const receipt = uncertain(context, intent, String(e.message || e));
+                persistReceipt(context, actionPath, receipt);
+                if (kind === 'ask')
+                    reconcileWaitFromReceipt(context.root, cfgmod.must(context.root), wait, receipt);
+                projectReceipt(context, receipt);
+                throw new ActionUncertainError(`动作结果不确定，禁止自动重发；action=${actionId}: ${e.message || e}`, receipt);
+            }
+            const receipt = finish(context, intent, nextState, checked);
+            persistReceipt(context, actionPath, receipt); // 事实先落盘
+            if (kind === 'ask')
+                reconcileWaitFromReceipt(context.root, cfgmod.must(context.root), wait, receipt);
+            if (kind === 'reply')
+                completeWaitFromReceipt(context.root, cfgmod.must(context.root), context.run.resume, receipt);
+            projectReceipt(context, receipt); // 再更新 control/run 投影
+            return receipt;
+        }
+        finally {
+            release();
+        }
+    }
+    finally {
+        releaseSessionEffect();
+    }
+}
+/**
+ * 权威数据只从 event index 读取。Run 目录里的静态上下文发生漂移时 fail closed；
+ * 动态 run.json 只是可修复投影，不能反过来阻塞已落盘的 Receipt。
+ * 这也让 --run /任意伪造目录 无法获得 DWS 外发能力。
+ */
+function loadContext(runPath) {
+    const actualRunPath = realpathSync(resolve(runPath));
+    const projection = readJson(join(actualRunPath, 'run.json'));
+    const root = process.env.DTA_ROOT
+        ? resolve(process.env.DTA_ROOT)
+        : cfgmod.findRoot(actualRunPath);
+    if (!root)
+        throw new Error('找不到 control store；act 必须由能访问 DTA_ROOT 的宿主侧执行');
+    const cfg = cfgmod.must(root);
+    const indexRoot = resolve(root, cfg.runtime?.eventIndexRoot || '.dingtalk-agent/event-index');
+    const indexPath = join(indexRoot, `${digest(projection.eventId)}.json`);
+    if (!existsSync(indexPath))
+        throw new Error('当前 Run 不在 event index 中；拒绝任意/伪造 --run');
+    const index = readJson(indexPath);
+    if (!index.authority || !index.control ||
+        digest(stableStringify(index.authority)) !== index.authorityHash) {
+        throw new Error('event index 的权威快照损坏，禁止执行');
+    }
+    if (realpathSync(index.runPath) !== actualRunPath ||
+        index.runId !== index.control.id || index.eventId !== projection.eventId) {
+        throw new Error('Run 与 event index 身份不一致，拒绝执行');
+    }
+    if (stableStringify(projection) !== stableStringify(index.control)) {
+        mirrorJson(join(actualRunPath, 'run.json'), index.control);
+    }
+    const drift = [];
+    const targetProjection = readJson(join(actualRunPath, 'context', 'reply-target.json'));
+    if (stableStringify(targetProjection) !== stableStringify(index.authority.replyTarget))
+        drift.push('reply-target.json');
+    const policyProjection = readJson(join(actualRunPath, 'policy', 'allowed-actions.json'));
+    if (stableStringify(policyProjection) !== stableStringify(index.authority.policy))
+        drift.push('allowed-actions.json');
+    const fieldProjection = readJson(join(actualRunPath, 'context', 'field.json'));
+    if (stableStringify(fieldProjection.dws || {}) !== stableStringify(index.authority.dws || {}))
+        drift.push('field.dws');
+    if (stableStringify(fieldProjection.transport || {}) !== stableStringify(index.authority.transport || {}))
+        drift.push('field.transport');
+    const behaviorProjection = readJson(join(actualRunPath, 'context', 'behavior.json'));
+    if (behaviorProjection.hash !== index.authority.behaviorHash)
+        drift.push('behavior.json');
+    const eventProjection = readJson(join(actualRunPath, 'event.json'));
+    if (digest(stableStringify(eventProjection)) !== index.authority.eventHash)
+        drift.push('event.json');
+    if (index.authority.resume) {
+        const resumeProjection = readJson(join(actualRunPath, 'context', 'resume.json'));
+        if (stableStringify(resumeProjection) !== stableStringify(index.authority.resume)) {
+            drift.push('resume.json');
+        }
+    }
+    try {
+        verifySkillSnapshot(actualRunPath, index.authority.skillManifestHash);
+    }
+    catch (e) {
+        drift.push(`skill-snapshot(${e.message})`);
+    }
+    if (drift.length)
+        throw new Error(`Sandbox 权威投影被修改: ${drift.join(', ')}；禁止执行`);
+    const session = readJson(join(index.sessionPath, 'session.json'));
+    const currentGeneration = validGeneration(session.generation, 'session.json');
+    const runGeneration = validGeneration(index.authority.sessionGeneration ?? index.control.sessionGeneration, 'event index');
+    if (currentGeneration !== runGeneration) {
+        throw new Error(`Session generation 已失效：run=${runGeneration}, current=${currentGeneration}；` +
+            '该事项已被 /stop 或 /cancel 取消，禁止继续副作用');
+    }
+    const controlActionRoot = join(indexRoot, 'actions', index.runId);
+    mkdirSync(controlActionRoot, { recursive: true });
+    return {
+        run: index.control,
+        field: { dws: index.authority.dws || {}, transport: index.authority.transport || {} },
+        policy: index.authority.policy,
+        target: index.authority.replyTarget,
+        authority: index.authority,
+        index,
+        indexPath,
+        controlActionRoot,
+        runPath: actualRunPath,
+        sessionPath: index.sessionPath,
+        event: eventProjection,
+        root,
+    };
+}
+function ensureAskWait(context, actionId, questionText = '') {
+    return armWait(context.root, cfgmod.must(context.root), {
+        fieldId: context.run.fieldId,
+        sessionId: context.run.sessionId,
+        sessionPath: context.sessionPath,
+        sourceRunId: context.run.id,
+        actionId,
+        questionText,
+        event: context.event,
+        target: context.target,
+    });
+}
+function reconcileAskWait(context, actionId, receipt, questionText = '') {
+    const wait = ensureAskWait(context, actionId, questionText);
+    return reconcileWaitFromReceipt(context.root, cfgmod.must(context.root), wait, receipt);
+}
+function reconcileReceiptWait(context, receipt) {
+    if (receipt.kind === 'ask') {
+        const intentPath = join(context.controlActionRoot, receipt.actionId, 'intent.json');
+        const intent = existsSync(intentPath) ? readJson(intentPath) : null;
+        return reconcileAskWait(context, receipt.actionId, receipt, intent?.payload?.text || '');
+    }
+    if ((receipt.kind === 'reply' || receipt.kind === 'silence') &&
+        receipt.outcome !== 'uncertain') {
+        return completeWaitFromReceipt(context.root, cfgmod.must(context.root), context.run.resume, receipt);
+    }
+    return null;
+}
+function normalizePayload(kind, options, policy) {
+    if (!KINDS.has(kind))
+        throw new Error(`原子动作只能是: ${[...KINDS].join(' / ')}`);
+    if (kind === 'ack')
+        return { emoji: '收到' };
+    if (kind === 'silence') {
+        const reason = String(options.reason || 'no_value').trim();
+        if (!SILENCE_REASONS.has(reason)) {
+            throw new Error(`silence reason 必须是: ${[...SILENCE_REASONS].join(' / ')}`);
+        }
+        return { reason };
+    }
+    const text = String(options.text || '').trim();
+    if (!text)
+        throw new Error(`${kind} 需要 --text 或 --text-file`);
+    const max = Number(policy.limits?.maxTextCharacters || 4000);
+    if (text.length > max)
+        throw new Error(`正文 ${text.length} 字，超过 Basic Behavior 上限 ${max}`);
+    return { text };
+}
+function validate(context, kind) {
+    const { run, policy, target } = context;
+    if (!(policy.allowedActions || []).includes(kind)) {
+        throw new Error(`事件 ${run.eventKind} 不允许 ${kind}；允许: ${(policy.allowedActions || []).join(', ')}`);
+    }
+    if (OUTWARD.has(kind) && (!target?.conversationId || !target?.messageId || !target?.senderOpenDingTalkId)) {
+        throw new Error('Run 没有完整固定回复目标，禁止外发');
+    }
+    if (OUTWARD.has(kind)) {
+        if (context.field.transport.egressOwner !== 'dingtalk-agent') {
+            throw new Error(`Field 的出口属于 ${context.field.transport.egressOwner || 'unknown'}，禁止 act 外发以避免双发`);
+        }
+        const profile = context.field.dws.profile || '';
+        const expected = context.field.dws.expectedUserId || '';
+        if (!profile)
+            throw new Error('Workspace 没有固定 dws.profile，禁止依赖“当前登录身份”外发');
+        if (profile.includes(','))
+            throw new Error('一个 Run 只能固定一个 dws.profile，禁止多组织广播式执行');
+        if (!expected)
+            throw new Error('Workspace 没有 expectedUserId，无法核对 DWS 实际执行身份');
+    }
+    const transition = policy.stateMachine?.transitions?.[run.state]?.[kind];
+    if (!transition)
+        throw new Error(`状态 ${run.state} 不接受动作 ${kind}`);
+    const counts = run.actionCounts || {};
+    const limits = policy.limits || {};
+    if (kind === 'ack' && Number(counts.ack || 0) >= Number(limits.maxAckPerRun || 1)) {
+        throw new Error('本 Run 已 ack，禁止重复刷表情');
+    }
+    if (OUTWARD.has(kind) && Number(counts.outward || 0) >= Number(limits.maxOutwardActionsPerRun || 2)) {
+        throw new Error('本 Run 的外发预算已用完');
+    }
+    if (TERMINAL.has(kind) && Number(counts.terminal || 0) >= Number(limits.maxTerminalMessagesPerRun || 1)) {
+        throw new Error('本 Run 已产生终态动作');
+    }
+    return transition;
+}
+function verifyExecutionIdentity(context, intent, actionPath) {
+    // profile 同名重新登录会换掉真实凭据身份；因此每个外发 Action 都现查，不跨 Action 缓存。
+    const data = dws.getSelf(intent.dwsProfile);
+    const userId = String(findValue(data, ['userId', 'user_id', 'userid']) || '');
+    if (!userId)
+        throw new Error('dws contact user get-self 没有返回 userId，禁止外发');
+    if (userId !== String(intent.expectedUserId)) {
+        throw new Error(`DWS 执行身份不符：expected=${intent.expectedUserId}, actual=${userId}`);
+    }
+    const verified = { profile: intent.dwsProfile, userId, verifiedAt: new Date().toISOString(), data };
+    persistArtifact(context, actionPath, 'identity.json', verified);
+    return verified;
+}
+function verify(kind, target, result, profile) {
+    if (kind === 'ack') {
+        const data = dws.readMessageEmotions(target.messageId, profile);
+        return { outcome: 'accepted-unverified', verified: false,
+            verification: 'reaction-readback-cannot-prove-current-actor', data };
+    }
+    const taskId = findValue(result, ['openTaskId', 'open_task_id']);
+    if (taskId) {
+        const data = dws.querySendStatus(taskId, profile);
+        const sentId = findValue(data, ['openMessageId', 'openMsgId', 'open_message_id']);
+        return sentId
+            ? { outcome: 'confirmed', verified: true, verification: 'query-send-status', data }
+            : { outcome: 'accepted-unverified', verified: false,
+                verification: 'query-send-status-without-message-id', data };
+    }
+    const messageId = findValue(result, ['openMessageId', 'openMsgId', 'open_message_id']);
+    if (messageId) {
+        const data = dws.readMessagesByIds(messageId, profile);
+        const seen = data && JSON.stringify(data).includes(String(messageId));
+        return seen
+            ? { outcome: 'confirmed', verified: true, verification: 'message-readback', data }
+            : { outcome: 'accepted-unverified', verified: false,
+                verification: 'message-readback-miss', data };
+    }
+    return { outcome: 'accepted-unverified', verified: false,
+        verification: 'reply-result-has-no-queryable-id', data: result };
+}
+function finish(context, intent, nextState, checked) {
+    return {
+        $schema: 'dingtalk-agent/action-receipt@1',
+        actionId: intent.id,
+        runId: intent.runId,
+        kind: intent.kind,
+        completedAt: new Date().toISOString(),
+        fromState: context.run.state,
+        toState: nextState,
+        ...checked,
+    };
+}
+function uncertain(context, intent, reason) {
+    return finish(context, intent, 'needs-reconciliation', {
+        outcome: 'uncertain', verified: false, verification: reason,
+    });
+}
+function replayReceipt(context, receipt) {
+    projectReceipt(context, receipt);
+    return { ...receipt, duplicate: true };
+}
+function projectReceipt(context, receipt) {
+    const release = acquireControlLock(context.indexPath);
+    try {
+        const latest = readJson(context.indexPath);
+        if (digest(stableStringify(latest.authority)) !== latest.authorityHash) {
+            throw new Error('投影 Receipt 时 authority hash 不一致');
+        }
+        const current = latest.control;
+        const applied = new Set(current.appliedActionIds || []);
+        if (applied.has(receipt.actionId)) {
+            mirrorJson(join(context.runPath, 'run.json'), current);
+            context.index = latest;
+            context.run = current;
+            return current;
+        }
+        // 兼容旧 control：若计数已表明该 kind 投影过，只回填 actionId，不重复计数/转移。
+        if (Number(current.actionCounts?.[receipt.kind] || 0) > 0) {
+            const next = { ...current, appliedActionIds: [...applied, receipt.actionId] };
+            const updated = { ...latest, control: next, updatedAt: new Date().toISOString() };
+            writeJsonAtomic(context.indexPath, updated);
+            context.index = updated;
+            context.run = next;
+            mirrorJson(join(context.runPath, 'run.json'), next);
+            return next;
+        }
+        if (current.state !== receipt.fromState) {
+            throw new Error(`Receipt 状态冲突: control=${current.state}, receipt=${receipt.fromState}→${receipt.toState}`);
+        }
+        const next = {
+            ...current,
+            updatedAt: receipt.completedAt,
+            state: receipt.toState,
+            appliedActionIds: [...applied, receipt.actionId],
+        };
+        bump(next, receipt.kind);
+        if (receipt.toState === 'needs-reconciliation')
+            next.status = 'blocked';
+        else if (receipt.toState === 'waiting-input')
+            next.status = receipt.verified ? 'waiting-input' : 'waiting-input-unverified';
+        else if (receipt.toState === 'ignored')
+            next.status = 'completed';
+        else if (receipt.toState === 'completed')
+            next.status = receipt.verified ? 'completed' : 'completed-unverified';
+        else
+            next.status = 'active';
+        const updated = { ...latest, control: next, updatedAt: new Date().toISOString() };
+        writeJsonAtomic(context.indexPath, updated);
+        context.index = updated;
+        context.run = next;
+        mirrorJson(join(context.runPath, 'run.json'), next);
+        return next;
+    }
+    finally {
+        release();
+    }
+}
+/** 已有 Receipt 是真值；新动作前先把“Receipt 已落盘、control 未更新”的窗口收敛。 */
+function reconcileReceipts(context) {
+    const receipts = [];
+    for (const entry of readdirSync(context.controlActionRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const path = join(context.controlActionRoot, entry.name, 'receipt.json');
+        if (existsSync(path))
+            receipts.push(readJson(path));
+    }
+    receipts.sort((a, b) => String(a.completedAt).localeCompare(String(b.completedAt)));
+    for (const receipt of receipts) {
+        reconcileReceiptWait(context, receipt);
+        projectReceipt(context, receipt);
+    }
+}
+/** 旧 Action 可能已命中 DWS 但尚无 Receipt；此时换文本会生成新 actionId，必须 fail closed。 */
+function assertNoOtherUnresolvedAttempt(context, currentActionId) {
+    for (const entry of readdirSync(context.controlActionRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name === currentActionId)
+            continue;
+        const path = join(context.controlActionRoot, entry.name);
+        if (existsSync(join(path, 'attempt.json')) && !existsSync(join(path, 'receipt.json'))) {
+            throw new Error(`Run 存在未对账 Action ${entry.name}；禁止更换正文再外发，请先 reconcile`);
+        }
+    }
+}
+function bump(run, kind) {
+    run.actionCounts = { ack: 0, reply: 0, ask: 0, silence: 0, outward: 0, terminal: 0,
+        ...(run.actionCounts || {}) };
+    run.actionCounts[kind]++;
+    if (OUTWARD.has(kind))
+        run.actionCounts.outward++;
+    if (TERMINAL.has(kind))
+        run.actionCounts.terminal++;
+}
+function persistArtifact(context, actionPath, name, value) {
+    writeJsonAtomic(join(actionPath, name), value);
+    const mirrorDir = join(context.runPath, 'actions', basename(actionPath));
+    try {
+        mkdirSync(mirrorDir, { recursive: true });
+        writeJsonAtomic(join(mirrorDir, name), value);
+    }
+    catch (e) {
+        console.error(`  ⚠️ sandbox 投影写入失败（control store 已保留真值）: ${e.message}`);
+    }
+}
+function persistReceipt(context, actionPath, receipt) {
+    persistArtifact(context, actionPath, 'receipt.json', receipt);
+    mirrorJson(join(context.runPath, 'receipts', `${receipt.actionId}.json`), receipt);
+}
+function mirrorJson(path, value) {
+    try {
+        writeJsonAtomic(path, value);
+    }
+    catch (e) {
+        console.error(`  ⚠️ sandbox 投影写入失败（control store 已保留真值）: ${e.message}`);
+    }
+}
+function transportName(kind) {
+    if (kind === 'ack')
+        return 'dws.chat.message.add-emoji';
+    if (kind === 'reply' || kind === 'ask')
+        return 'dws.chat.message.reply';
+    return 'local.silence';
+}
+function findValue(value, keys) {
+    if (!value || typeof value !== 'object')
+        return '';
+    for (const key of keys)
+        if (value[key])
+            return value[key];
+    for (const child of Object.values(value)) {
+        const found = findValue(child, keys);
+        if (found)
+            return found;
+    }
+    return '';
+}
+function validGeneration(value, label) {
+    const n = Number(value ?? 1);
+    if (!Number.isInteger(n) || n < 1)
+        throw new Error(`${label} 的 Session generation 非法`);
+    return n;
+}
+//# sourceMappingURL=actions.js.map