@xdxer/dingtalk-agent 0.1.4-beta.7 → 0.1.4-beta.9

package/dist/src/memory/completion-evidence.js

@@ -0,0 +1,536 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, writeFileSync, } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { digest, stableStringify } from '../events.js';
+import { acquireLease } from '../lease.js';
+export const COMPLETION_EVIDENCE_ID_PATTERN = /^evd_[a-f0-9]{32}$/;
+export const ACTION_RECEIPT_EVIDENCE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+const RUN_ID_PATTERN = /^run_[a-f0-9]{20}$/;
+const ACTION_ID_PATTERN = /^act_[a-f0-9]{20}$/;
+const ARTIFACT_CONDITION = /(?:文件|文档|产物|工作区|保存|创建|写入|file|document|artifact|workspace|write|saved|created)/iu;
+const MESSAGE_DELIVERY_CONDITION = /(?:回复|消息|发送|送达|回读|reply|message|send|sent|deliver|readback)/iu;
+/**
+ * Host-only issuance API. It is intentionally not wired to the public CLI: callers must already
+ * hold a trusted Session/Run or an explicit host identity.
+ */
+export function issueCompletionEvidence(root, cfg, claim, options) {
+    const context = resolveEvidenceContext(root, cfg, options.sessionPath);
+    const issuer = resolveIssuer(context, options);
+    const issuedAt = parseNow(options.now).toISOString();
+    const doneWhen = requireText(claim.doneWhen, 'Completion evidence doneWhen');
+    const conditionHash = digest(doneWhen);
+    let reference;
+    let observed;
+    if (claim.kind === 'artifact') {
+        const artifact = observeArtifact(root, claim.artifact.path);
+        const expected = String(claim.artifact.expectedSha256 || '').trim().toLowerCase();
+        if (expected && (!HASH_PATTERN.test(expected) || expected !== artifact.sha256)) {
+            throw new Error(`Completion Artifact hash 不一致：expected=${expected || '-'}, actual=${artifact.sha256}`);
+        }
+        reference = {
+            type: 'artifact', locator: artifact.locator,
+            sha256: artifact.sha256, bytes: artifact.bytes,
+        };
+        observed = { status: 'verified', hash: artifact.sha256 };
+    }
+    else if (claim.kind === 'action-receipt') {
+        assertReceiptCondition(doneWhen, claim.receipt.action);
+        const receipt = observeActionReceipt(root, cfg, context, claim.receipt.runId, claim.receipt.actionId, claim.receipt.action, new Date(issuedAt));
+        reference = receipt.reference;
+        observed = { status: 'verified', hash: receipt.hash };
+    }
+    else {
+        const confirmation = observeConfirmation(root, cfg, context, issuer, conditionHash, claim.confirmation);
+        reference = confirmation.reference;
+        observed = { status: 'confirmed', hash: confirmation.hash };
+    }
+    const evidence = {
+        $schema: 'dingtalk-agent/task-completion-evidence@1',
+        evidenceId: `evd_${randomUUID().replaceAll('-', '')}`,
+        kind: claim.kind,
+        taskId: context.session.id,
+        scopeId: context.session.contextId,
+        sessionId: context.session.id,
+        issuer,
+        condition: { ref: 'doneWhen', hash: conditionHash },
+        reference,
+        observed,
+        issuedAt,
+    };
+    validateCompletionEvidence(evidence);
+    verifyEvidenceSource(root, cfg, context, evidence, new Date(issuedAt));
+    const registryPath = completionEvidenceRegistryPath(root, cfg, context.session);
+    const release = acquireLease(`${registryPath}.lock`, `Task ${context.session.id} completion evidence 正在签发`, {
+        waitMs: 3_000, staleAfterMs: 2 * 60_000,
+    });
+    try {
+        const current = readRegistry(registryPath, context, true);
+        if (current.evidence.some((item) => item.evidenceId === evidence.evidenceId)) {
+            throw new Error(`Completion evidenceId 碰撞: ${evidence.evidenceId}`);
+        }
+        const next = {
+            ...current,
+            revision: current.revision + 1,
+            evidence: [...current.evidence, evidence],
+            updatedAt: issuedAt,
+        };
+        writeJsonAtomic(registryPath, next);
+        const readback = readRegistry(registryPath, context, false);
+        if (stableStringify(readback) !== stableStringify(next)) {
+            throw new Error('Completion evidence registry 原子写后回读不一致');
+        }
+        return {
+            $schema: 'dingtalk-agent/task-completion-evidence-result@1',
+            evidenceId: evidence.evidenceId,
+            registryRevision: readback.revision,
+            evidence: clone(evidence),
+        };
+    }
+    finally {
+        release();
+    }
+}
+/** Resolve every opaque ID from trusted host state and re-verify its source before completion. */
+export function resolveCompletionEvidence(root, cfg, sessionPath, doneWhen, evidenceIds, options = {}) {
+    const context = resolveEvidenceContext(root, cfg, sessionPath);
+    const conditionHash = digest(requireText(doneWhen, 'Task doneWhen'));
+    if (!Array.isArray(evidenceIds) || !evidenceIds.length) {
+        throw new Error('Task completed 状态必须引用宿主签发的 completion evidenceId');
+    }
+    if (new Set(evidenceIds).size !== evidenceIds.length) {
+        throw new Error('Task completion evidenceId 不能重复');
+    }
+    for (const evidenceId of evidenceIds) {
+        if (!isCompletionEvidenceId(evidenceId)) {
+            throw new Error(`Task evidence 只能引用宿主签发的 evidenceId: ${evidenceId || '-'}`);
+        }
+    }
+    const registryPath = completionEvidenceRegistryPath(root, cfg, context.session);
+    if (!existsSync(registryPath)) {
+        throw new Error(`当前 Session 没有宿主 completion evidence registry`);
+    }
+    const registry = readRegistry(registryPath, context, false);
+    const byId = new Map(registry.evidence.map((item) => [item.evidenceId, item]));
+    const now = parseNow(options.now);
+    return evidenceIds.map((evidenceId) => {
+        const evidence = byId.get(evidenceId);
+        if (!evidence)
+            throw new Error(`找不到宿主签发的 completion evidenceId: ${evidenceId}`);
+        validateCompletionEvidence(evidence);
+        if (evidence.taskId !== context.session.id ||
+            evidence.sessionId !== context.session.id ||
+            evidence.scopeId !== context.session.contextId) {
+            throw new Error(`Completion evidence ${evidenceId} 与当前 Session/Task 作用域不一致`);
+        }
+        if (evidence.condition.ref !== 'doneWhen' || evidence.condition.hash !== conditionHash) {
+            throw new Error(`Completion evidence ${evidenceId} 与当前 doneWhen 不一致`);
+        }
+        verifyEvidenceSource(root, cfg, context, evidence, now);
+        return clone(evidence);
+    });
+}
+export function isCompletionEvidenceId(value) {
+    return COMPLETION_EVIDENCE_ID_PATTERN.test(String(value || ''));
+}
+function verifyEvidenceSource(root, cfg, context, evidence, now) {
+    if (evidence.issuer.type === 'run') {
+        const index = findRunIndex(root, cfg, evidence.issuer.id);
+        assertIndexScope(index, context, `签发 Run ${evidence.issuer.id}`);
+    }
+    if (evidence.kind === 'artifact') {
+        if (evidence.reference.type !== 'artifact')
+            throw new Error('Artifact evidence reference 非法');
+        const actual = observeArtifact(root, evidence.reference.locator);
+        if (actual.sha256 !== evidence.reference.sha256 ||
+            actual.sha256 !== evidence.observed.hash ||
+            actual.bytes !== evidence.reference.bytes) {
+            throw new Error(`Completion Artifact ${evidence.reference.locator} 内容/hash 已漂移`);
+        }
+        if (evidence.observed.status !== 'verified') {
+            throw new Error(`Completion Artifact ${evidence.evidenceId} 尚未 verified`);
+        }
+        return;
+    }
+    if (evidence.kind === 'action-receipt') {
+        if (evidence.reference.type !== 'action-receipt') {
+            throw new Error('Action Receipt evidence reference 非法');
+        }
+        assertReceiptConditionHash(evidence);
+        const receipt = observeActionReceipt(root, cfg, context, evidence.reference.runId, evidence.reference.actionId, evidence.reference.action, now);
+        if (receipt.hash !== evidence.reference.receiptHash ||
+            receipt.hash !== evidence.observed.hash ||
+            receipt.reference.completedAt !== evidence.reference.completedAt ||
+            receipt.reference.validUntil !== evidence.reference.validUntil) {
+            throw new Error(`Action Receipt ${evidence.reference.actionId} 内容/hash 已漂移`);
+        }
+        if (evidence.observed.status !== 'verified') {
+            throw new Error(`Action Receipt ${evidence.reference.actionId} 尚未 verified`);
+        }
+        return;
+    }
+    if (evidence.reference.type !== 'confirmation') {
+        throw new Error('Confirmation evidence reference 非法');
+    }
+    const observed = reobserveConfirmation(root, cfg, context, evidence);
+    if (observed !== evidence.reference.recordHash || observed !== evidence.observed.hash ||
+        evidence.observed.status !== 'confirmed') {
+        throw new Error(`Confirmation ${evidence.reference.confirmationId} 未确认或记录已漂移`);
+    }
+}
+function observeArtifact(root, input) {
+    const locator = requireText(input, 'Completion Artifact locator');
+    if (isAbsolute(locator) || locator.split(/[\\/]/).includes('..')) {
+        throw new Error(`Completion Artifact 必须是 Workspace 内相对路径: ${locator}`);
+    }
+    const workspace = realpathSync(resolve(root));
+    const candidate = resolve(workspace, locator);
+    assertInside(workspace, candidate, 'Completion Artifact');
+    if (!existsSync(candidate))
+        throw new Error(`Completion Artifact 不存在: ${locator}`);
+    const stat = lstatSync(candidate);
+    if (stat.isSymbolicLink())
+        throw new Error(`Completion Artifact 不接受符号链接: ${locator}`);
+    if (!stat.isFile())
+        throw new Error(`Completion Artifact 必须是文件: ${locator}`);
+    const actual = realpathSync(candidate);
+    assertInside(workspace, actual, 'Completion Artifact');
+    const body = readFileSync(actual);
+    return {
+        locator: relative(workspace, actual).split('\\').join('/'),
+        sha256: createHash('sha256').update(body).digest('hex'),
+        bytes: body.byteLength,
+    };
+}
+function observeActionReceipt(root, cfg, context, runId, actionId, action, now) {
+    if (!RUN_ID_PATTERN.test(runId) || !ACTION_ID_PATTERN.test(actionId)) {
+        throw new Error(`Action Receipt reference 非法: run=${runId || '-'}, action=${actionId || '-'}`);
+    }
+    if (action !== 'reply') {
+        throw new Error(`Action Receipt ${action} 不能作为 completed 证据`);
+    }
+    const index = findRunIndex(root, cfg, runId);
+    assertIndexScope(index, context, `Action Receipt Run ${runId}`);
+    const indexRoot = resolve(root, cfg.runtime?.eventIndexRoot || '.dingtalk-agent/event-index');
+    const path = join(indexRoot, 'actions', runId, actionId, 'receipt.json');
+    if (!existsSync(path))
+        throw new Error(`找不到 Action Receipt: ${actionId}`);
+    const receipt = readJson(path);
+    if (receipt.$schema !== 'dingtalk-agent/action-receipt@1' ||
+        receipt.actionId !== actionId || receipt.runId !== runId || receipt.kind !== action) {
+        throw new Error(`Action Receipt ${actionId} 身份或动作类型不一致`);
+    }
+    if (receipt.verified !== true || receipt.outcome !== 'confirmed' ||
+        !String(receipt.verification || '').trim() ||
+        receipt.verification === 'local-no-side-effect') {
+        throw new Error(`Action Receipt ${actionId} 未 verified/confirmed`);
+    }
+    const completedAt = parseTimestamp(receipt.completedAt, `Action Receipt ${actionId} completedAt`);
+    const validUntil = new Date(completedAt.getTime() + ACTION_RECEIPT_EVIDENCE_TTL_MS);
+    if (now.getTime() > validUntil.getTime()) {
+        throw new Error(`Action Receipt ${actionId} 已过期`);
+    }
+    const hash = digest(stableStringify(receipt));
+    return {
+        reference: {
+            type: 'action-receipt', runId, actionId, action,
+            receiptHash: hash,
+            completedAt: completedAt.toISOString(),
+            validUntil: validUntil.toISOString(),
+        },
+        hash,
+    };
+}
+function observeConfirmation(root, cfg, context, issuer, conditionHash, confirmation) {
+    const confirmationId = requireText(confirmation.confirmationId, 'Confirmation ID');
+    if (confirmation.source === 'trusted-event') {
+        const eventId = requireText(confirmation.eventId, 'Confirmation eventId');
+        const index = readEventIndex(root, cfg, eventId);
+        assertIndexScope(index, context, `Confirmation event ${eventId}`);
+        const hash = trustedEventConfirmationHash(index, confirmationId);
+        return {
+            reference: {
+                type: 'confirmation', source: 'trusted-event', confirmationId,
+                eventId, recordHash: hash,
+            },
+            hash,
+        };
+    }
+    if (issuer.type !== 'host') {
+        throw new Error('Host confirmation 必须由显式 host identity 签发');
+    }
+    const hash = hostConfirmationHash(confirmationId, issuer.id, context.session.id, context.session.contextId, conditionHash);
+    return {
+        reference: {
+            type: 'confirmation', source: 'host-record', confirmationId,
+            hostIdentity: issuer.id, recordHash: hash,
+        },
+        hash,
+    };
+}
+function reobserveConfirmation(root, cfg, context, evidence) {
+    if (evidence.reference.type !== 'confirmation')
+        throw new Error('Confirmation reference 非法');
+    if (evidence.reference.source === 'trusted-event') {
+        const index = readEventIndex(root, cfg, evidence.reference.eventId);
+        assertIndexScope(index, context, `Confirmation event ${evidence.reference.eventId}`);
+        return trustedEventConfirmationHash(index, evidence.reference.confirmationId);
+    }
+    if (evidence.issuer.type !== 'host' || evidence.issuer.id !== evidence.reference.hostIdentity) {
+        throw new Error('Host confirmation issuer 身份不一致');
+    }
+    return hostConfirmationHash(evidence.reference.confirmationId, evidence.reference.hostIdentity, evidence.sessionId, evidence.scopeId, evidence.condition.hash);
+}
+function trustedEventConfirmationHash(index, confirmationId) {
+    return digest(stableStringify({
+        confirmationId,
+        eventId: index.eventId,
+        eventHash: index.eventHash,
+        sessionId: index.sessionId,
+        contextId: index.contextId,
+        runId: index.runId,
+    }));
+}
+function hostConfirmationHash(confirmationId, hostIdentity, sessionId, scopeId, conditionHash) {
+    return digest(stableStringify({
+        confirmationId, hostIdentity, sessionId, scopeId, conditionHash,
+    }));
+}
+function assertReceiptCondition(doneWhen, action) {
+    if (action !== 'reply') {
+        throw new Error(`Action Receipt ${action} 不能作为 completed 证据`);
+    }
+    if (ARTIFACT_CONDITION.test(doneWhen) || !MESSAGE_DELIVERY_CONDITION.test(doneWhen)) {
+        throw new Error('reply 的消息送达 Receipt 只能证明回复动作；不能证明文件、文档或 Artifact 已完成');
+    }
+}
+function assertReceiptConditionHash(evidence) {
+    if (evidence.reference.type !== 'action-receipt' || evidence.reference.action !== 'reply') {
+        throw new Error('只有 verified reply Receipt 可作为首批消息动作完成证据');
+    }
+}
+function resolveEvidenceContext(root, cfg, sessionInput) {
+    const configuredRoot = realpathSync(resolve(root, cfg.runtime.sessionRoot || '.dingtalk-agent/sessions'));
+    const input = requireText(sessionInput, 'Completion evidence Session path');
+    const sessionPath = realpathSync(resolve(input));
+    assertInside(configuredRoot, sessionPath, 'Completion evidence Session');
+    const session = readJson(join(sessionPath, 'session.json'));
+    if (!session.id || !session.contextId)
+        throw new Error('Completion evidence Session 缺少 id/contextId');
+    if (session.id !== String(session.id) || !/^ses_[a-f0-9]{20}$/.test(session.id)) {
+        throw new Error(`Completion evidence Session ID 非法: ${session.id || '-'}`);
+    }
+    return { sessionPath, session };
+}
+function resolveIssuer(context, options) {
+    if (options.runPath) {
+        const runPath = realpathSync(resolve(options.runPath));
+        assertInside(join(context.sessionPath, 'runs'), runPath, 'Completion evidence Run');
+        const run = readJson(join(runPath, 'run.json'));
+        if (run.sessionId !== context.session.id || run.contextId !== context.session.contextId ||
+            !RUN_ID_PATTERN.test(String(run.id || ''))) {
+            throw new Error('Completion evidence Run 与 Session 身份不一致');
+        }
+        return { type: 'run', id: run.id };
+    }
+    return { type: 'host', id: requireText(options.hostIdentity, 'Completion evidence host identity') };
+}
+function completionEvidenceRegistryPath(root, cfg, session) {
+    const indexRoot = resolve(root, cfg.runtime.eventIndexRoot || '.dingtalk-agent/event-index');
+    return join(indexRoot, 'completion-evidence', digest(session.id), 'registry.json');
+}
+function readRegistry(path, context, create) {
+    const empty = {
+        $schema: 'dingtalk-agent/task-completion-evidence-registry@1',
+        taskId: context.session.id,
+        scopeId: context.session.contextId,
+        sessionId: context.session.id,
+        revision: 0,
+        evidence: [],
+        updatedAt: '',
+    };
+    if (!existsSync(path)) {
+        if (create)
+            return empty;
+        throw new Error('当前 Session 没有宿主 completion evidence registry');
+    }
+    const input = readJson(path);
+    if (input.$schema !== empty.$schema || input.taskId !== empty.taskId ||
+        input.scopeId !== empty.scopeId || input.sessionId !== empty.sessionId ||
+        !Number.isInteger(input.revision) || input.revision < 1 ||
+        !Array.isArray(input.evidence) || typeof input.updatedAt !== 'string') {
+        throw new Error('Completion evidence registry 身份、revision 或结构非法');
+    }
+    const ids = new Set();
+    for (const value of input.evidence) {
+        validateCompletionEvidence(value);
+        if (value.taskId !== empty.taskId || value.scopeId !== empty.scopeId ||
+            value.sessionId !== empty.sessionId) {
+            throw new Error(`Completion evidence ${value.evidenceId} 与 registry 作用域不一致`);
+        }
+        if (ids.has(value.evidenceId))
+            throw new Error(`Completion evidenceId 重复: ${value.evidenceId}`);
+        ids.add(value.evidenceId);
+    }
+    return clone(input);
+}
+function validateCompletionEvidence(value) {
+    if (!isRecord(value))
+        throw new Error('Completion evidence 必须是 JSON object');
+    const allowed = new Set([
+        '$schema', 'evidenceId', 'kind', 'taskId', 'scopeId', 'sessionId',
+        'issuer', 'condition', 'reference', 'observed', 'issuedAt',
+    ]);
+    assertNoExtra(value, allowed, 'Completion evidence');
+    if (value.$schema !== 'dingtalk-agent/task-completion-evidence@1' ||
+        !isCompletionEvidenceId(String(value.evidenceId || '')) ||
+        !['artifact', 'action-receipt', 'confirmation'].includes(String(value.kind || '')) ||
+        !String(value.taskId || '').trim() || !String(value.scopeId || '').trim() ||
+        !String(value.sessionId || '').trim()) {
+        throw new Error('Completion evidence schema、ID、kind 或作用域非法');
+    }
+    if (!isRecord(value.issuer))
+        throw new Error('Completion evidence issuer 非法');
+    assertNoExtra(value.issuer, new Set(['type', 'id']), 'Completion evidence issuer');
+    if (!['run', 'host'].includes(String(value.issuer.type || '')) ||
+        !String(value.issuer.id || '').trim())
+        throw new Error('Completion evidence issuer 非法');
+    if (!isRecord(value.condition))
+        throw new Error('Completion evidence condition 非法');
+    assertNoExtra(value.condition, new Set(['ref', 'hash']), 'Completion evidence condition');
+    if (value.condition.ref !== 'doneWhen' || !HASH_PATTERN.test(String(value.condition.hash || ''))) {
+        throw new Error('Completion evidence condition hash 非法');
+    }
+    if (!isRecord(value.observed))
+        throw new Error('Completion evidence observed 非法');
+    assertNoExtra(value.observed, new Set(['status', 'hash']), 'Completion evidence observed');
+    if (!['verified', 'confirmed'].includes(String(value.observed.status || '')) ||
+        !HASH_PATTERN.test(String(value.observed.hash || ''))) {
+        throw new Error('Completion evidence observed status/hash 非法');
+    }
+    parseTimestamp(value.issuedAt, 'Completion evidence issuedAt');
+    validateReference(value.kind, value.reference);
+}
+function validateReference(kind, reference) {
+    if (!isRecord(reference))
+        throw new Error('Completion evidence reference 非法');
+    if (kind === 'artifact') {
+        assertNoExtra(reference, new Set(['type', 'locator', 'sha256', 'bytes']), 'Artifact reference');
+        if (reference.type !== 'artifact' || !String(reference.locator || '').trim() ||
+            !HASH_PATTERN.test(String(reference.sha256 || '')) ||
+            !Number.isInteger(reference.bytes) || Number(reference.bytes) < 0) {
+            throw new Error('Artifact reference 非法');
+        }
+        return;
+    }
+    if (kind === 'action-receipt') {
+        assertNoExtra(reference, new Set([
+            'type', 'runId', 'actionId', 'action', 'receiptHash', 'completedAt', 'validUntil',
+        ]), 'Action Receipt reference');
+        if (reference.type !== 'action-receipt' || !RUN_ID_PATTERN.test(String(reference.runId || '')) ||
+            !ACTION_ID_PATTERN.test(String(reference.actionId || '')) || reference.action !== 'reply' ||
+            !HASH_PATTERN.test(String(reference.receiptHash || ''))) {
+            throw new Error('Action Receipt reference 非法');
+        }
+        parseTimestamp(reference.completedAt, 'Action Receipt reference completedAt');
+        parseTimestamp(reference.validUntil, 'Action Receipt reference validUntil');
+        return;
+    }
+    assertNoExtra(reference, new Set([
+        'type', 'source', 'confirmationId', 'eventId', 'hostIdentity', 'recordHash',
+    ]), 'Confirmation reference');
+    if (reference.type !== 'confirmation' ||
+        !['trusted-event', 'host-record'].includes(String(reference.source || '')) ||
+        !String(reference.confirmationId || '').trim() ||
+        !HASH_PATTERN.test(String(reference.recordHash || ''))) {
+        throw new Error('Confirmation reference 非法');
+    }
+    if (reference.source === 'trusted-event' && !String(reference.eventId || '').trim()) {
+        throw new Error('Trusted-event confirmation 缺少 eventId');
+    }
+    if (reference.source === 'host-record' && !String(reference.hostIdentity || '').trim()) {
+        throw new Error('Host confirmation 缺少 hostIdentity');
+    }
+}
+function findRunIndex(root, cfg, runId) {
+    const indexRoot = resolve(root, cfg.runtime.eventIndexRoot || '.dingtalk-agent/event-index');
+    if (!existsSync(indexRoot))
+        throw new Error(`找不到签发 Run: ${runId}`);
+    const matches = readdirSync(indexRoot, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .map((entry) => readJson(join(indexRoot, entry.name)))
+        .filter((index) => index.$schema === 'dingtalk-agent/event-index@1' && index.runId === runId);
+    if (matches.length !== 1)
+        throw new Error(`签发 Run ${runId} 的 event index 数量非法: ${matches.length}`);
+    validateEventIndex(matches[0], `签发 Run ${runId}`);
+    return matches[0];
+}
+function readEventIndex(root, cfg, eventId) {
+    const indexRoot = resolve(root, cfg.runtime.eventIndexRoot || '.dingtalk-agent/event-index');
+    const path = join(indexRoot, `${digest(eventId)}.json`);
+    if (!existsSync(path))
+        throw new Error(`找不到可信 Confirmation event: ${eventId}`);
+    const index = readJson(path);
+    validateEventIndex(index, `Confirmation event ${eventId}`);
+    if (index.eventId !== eventId)
+        throw new Error(`Confirmation event ${eventId} 身份不一致`);
+    return index;
+}
+function validateEventIndex(index, label) {
+    if (index.$schema !== 'dingtalk-agent/event-index@1' ||
+        index.eventHash !== index.authority?.eventHash ||
+        index.runId !== index.control?.id ||
+        digest(stableStringify(index.authority)) !== index.authorityHash) {
+        throw new Error(`${label} 权威 event index 损坏`);
+    }
+}
+function assertIndexScope(index, context, label) {
+    if (index.sessionId !== context.session.id || index.contextId !== context.session.contextId ||
+        realpathSync(resolve(index.sessionPath)) !== context.sessionPath) {
+        throw new Error(`${label} 与当前 Session/Task 作用域不一致`);
+    }
+}
+function assertInside(root, path, label) {
+    const rootPath = existsSync(root) ? realpathSync(resolve(root)) : resolve(root);
+    const rel = relative(rootPath, resolve(path));
+    if (rel === '..' || rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`)) {
+        throw new Error(`${label} 必须位于可信根目录内`);
+    }
+}
+function assertNoExtra(value, allowed, label) {
+    const extra = Object.keys(value).filter((key) => !allowed.has(key));
+    if (extra.length)
+        throw new Error(`${label} 含未知字段: ${extra.join(', ')}`);
+}
+function parseNow(value) {
+    return value === undefined ? new Date() : parseTimestamp(value, 'Completion evidence now');
+}
+function parseTimestamp(value, label) {
+    const text = String(value || '').trim();
+    const time = Date.parse(text);
+    if (!text || !Number.isFinite(time))
+        throw new Error(`${label} 必须是合法时间`);
+    return new Date(time);
+}
+function requireText(value, label) {
+    const text = String(value || '').trim();
+    if (!text)
+        throw new Error(`${label} 不能为空`);
+    return text;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function writeJsonAtomic(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 clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+//# sourceMappingURL=completion-evidence.js.map