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

package/dist/src/remote-semantic-state-live-evals.js

@@ -0,0 +1,888 @@
+import { randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync, } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { bootstrap } from './bootstrap.js';
+import * as dws from './dws.js';
+import { digest, stableStringify } from './events.js';
+import { planRemoteSemanticState, rehydrateRemoteSemanticState, verifyRemoteSemanticStateCache, } from './memory/remote-state.js';
+const SECRET_KEY = /(?:secret|token|password|credential|privateKey)/i;
+const PLACEHOLDER = /(?:replace-with|<[^>]+>|dedicated-test|readback-user-id|known-node)/i;
+const FORBIDDEN_REMOTE_PATTERNS = [
+    ['waitId', /\bwait[-_ ]?id\b/i],
+    ['generation', /\bgeneration\b/i],
+    ['idempotencyKey', /\bidempotency[-_ ]?key\b/i],
+    ['lease', /\blease\b/i],
+    ['Action Receipt', /\baction[-_ ]?receipt\b/i],
+    ['credentials', /\b(?:credential|client[-_ ]?secret|access[-_ ]?token|refresh[-_ ]?token|password)s?\b/i],
+];
+export function runRemoteSemanticStateLiveEvaluation(root, workspacePath, suitePath, options = {}) {
+    const workspace = safeExistingDirectory(root, workspacePath, 'workspace');
+    const suiteFile = safeExistingFile(root, suitePath, 'suite');
+    const suite = validateSpec(readJson(suiteFile));
+    const providerPlan = planRemoteSemanticState(suite.provider);
+    const local = bootstrap(workspace, {
+        agent: `local-dir:${workspace}`,
+        skills: `local-dir:${join(workspace, 'skills')}`,
+        memory: suite.provider.layers.l1.uri,
+        knowledge: suite.provider.layers.l3.uri,
+        profile: suite.provider.authority.profile,
+        expectedUserId: suite.provider.authority.expectedUserId,
+        deferRemote: true,
+    });
+    const missingRequirements = readinessGaps(suite, local);
+    const writesPlanned = suite.write.documentSlots.length +
+        (suite.write.aitableFields.length ? 1 : 0) + (suite.write.driftProbe ? 1 : 0);
+    const plan = {
+        $schema: 'dingtalk-agent/remote-semantic-state-live-plan@1',
+        id: suite.id,
+        scenario: suite.scenario,
+        engine: 'storage',
+        sideEffect: false,
+        remoteRead: false,
+        liveAuthorized: suite.liveAuthorized === 'yes',
+        ready: missingRequirements.length === 0,
+        missingRequirements,
+        workspace: relative(realpathSync(resolve(root)), workspace),
+        suite: relative(realpathSync(resolve(root)), suiteFile),
+        provider: providerPlan,
+        requiredSkills: suite.requiredSkills,
+        executionGate: 'LIVE_AUTHORIZED=yes + --execute --live --yes',
+        writesPlanned,
+        writeBudget: suite.write.budget,
+        writeKinds: [
+            ...suite.write.documentSlots.map((slot) => `append-${slot}-marker`),
+            'update-fixed-l2-record',
+            ...(suite.write.driftProbe ? ['append-l1-drift-marker'] : []),
+        ],
+        evidenceRoot: suite.evidenceRoot,
+        coldStart: 'pre-write baseline + post-write process A + new-state-dir process B',
+        controlState: suite.provider.controlState,
+    };
+    if (!options.execute)
+        return plan;
+    if (!options.live || !options.yes || suite.liveAuthorized !== 'yes') {
+        throw new Error('Phase 11B 真实 DWS 读取/写入必须同时满足 LIVE_AUTHORIZED=yes 与 --execute --live --yes');
+    }
+    if (missingRequirements.length) {
+        throw new Error(`Phase 11B Live 资源或本地 Definition 未就绪: ${missingRequirements.join('; ')}`);
+    }
+    if (writesPlanned !== suite.write.budget) {
+        throw new Error(`Phase 11B 写预算必须精确等于计划写次数 ${writesPlanned}`);
+    }
+    const runId = `DTA-PHASE-11B-${Date.now()}-${randomUUID()}`;
+    const evidenceRoot = safeEvidenceRoot(workspace, suite.evidenceRoot, runId);
+    mkdirSync(evidenceRoot, { recursive: true });
+    const planPath = join(evidenceRoot, 'plan.json');
+    writeJson(planPath, { ...plan, sideEffect: 'authorized-live-probes', remoteRead: true, runId });
+    writeJson(join(evidenceRoot, 'provider.redacted.json'), redactProvider(suite.provider));
+    writeJson(join(evidenceRoot, 'provider.raw.json'), suite.provider);
+    const stateRoot = join(evidenceRoot, 'state');
+    const activeStateDir = join(stateRoot, 'active');
+    const baselineStateDir = join(stateRoot, 'baseline');
+    const firstStateDir = join(stateRoot, 'first-post-write');
+    let stage = 'preflight';
+    let writeCount = 0;
+    const writeResults = [];
+    const consumeWrite = (resource) => {
+        if (!suite.write.allowlist.includes(resource)) {
+            throw new Error(`Phase 11B 写目标不在 allowlist: ${resource}`);
+        }
+        if (writeCount >= suite.write.budget) {
+            throw new Error(`Phase 11B 写预算耗尽: ${writeCount}/${suite.write.budget}`);
+        }
+        writeCount += 1;
+    };
+    try {
+        stage = 'identity-and-resource-preflight';
+        const identity = dws.getSelf(suite.provider.authority.profile);
+        const actualUserId = clean(findValue(identity, ['userId', 'user_id', 'userid']));
+        if (!actualUserId || actualUserId !== suite.provider.authority.expectedUserId) {
+            throw new Error(`Phase 11B DWS 身份不符: expected=${suite.provider.authority.expectedUserId}, ` +
+                `actual=${actualUserId || '-'}`);
+        }
+        writeJson(join(evidenceRoot, 'identity-readback.json'), identity);
+        const documentBodies = {};
+        const documentInfo = {};
+        for (const slot of ['l1', 'l3']) {
+            const layer = suite.provider.layers[slot];
+            const info = dws.docInfo(nodeRef(layer.uri), suite.provider.authority.profile);
+            assertAdoc(slot, info);
+            const body = String(dws.readDoc(nodeRef(layer.uri), suite.provider.authority.profile));
+            assertRemoteMarkdownSafe(slot, body);
+            documentBodies[slot] = body;
+            documentInfo[slot] = info;
+        }
+        writeJson(join(evidenceRoot, 'document-info.json'), documentInfo);
+        const l2 = suite.provider.layers.l2;
+        const base = dws.getAiTableBase(l2.baseId, suite.provider.authority.profile);
+        const tables = dws.getAiTableTables(l2.baseId, [l2.tableId], suite.provider.authority.profile);
+        verifyTableShape(base, tables, suite.provider, suite.write.aitableFields);
+        const initialRows = dws.queryAiTableRecords({
+            baseId: l2.baseId, tableId: l2.tableId, recordIds: [l2.recordId],
+            profile: suite.provider.authority.profile,
+        });
+        const initial = exactStructuredState(initialRows, suite.provider);
+        const initialUnique = queryUniqueRecord(suite.provider);
+        writeJson(join(evidenceRoot, 'preflight.json'), {
+            identityMatched: true,
+            documents: Object.fromEntries(['l1', 'l3'].map((slot) => [slot, {
+                    type: `${String(documentInfo[slot].contentType)}/${String(documentInfo[slot].extension)}`,
+                    hash: digest(documentBodies[slot]),
+                }])),
+            aitable: {
+                baseRead: Boolean(base), tableRead: Boolean(tables), recordIdMatched: true,
+                uniqueKeyScopeCount: initialUnique.rows.length,
+                structuredStateHash: digest(stableStringify(initial)),
+            },
+            dryRunHadNoRemoteCall: false,
+        });
+        stage = 'pre-write-baseline';
+        const baseline = requireWorker(invokeWorker(evidenceRoot, 'baseline', {
+            action: 'bootstrap-and-rehydrate', workspace, stateDir: activeStateDir,
+            provider: suite.provider,
+        }));
+        writeJson(join(evidenceRoot, 'bootstrap', 'baseline.json'), baseline);
+        stage = 'drift-fail-closed';
+        let driftEvidence = { provided: suite.write.driftProbe, passed: false };
+        if (suite.write.driftProbe) {
+            const driftMarker = `DTA-PHASE-11B-DRIFT-${Date.now()}-${randomUUID()}`;
+            const resource = suite.provider.layers.l1.uri;
+            consumeWrite(resource);
+            const accepted = appendDocumentMarker(evidenceRoot, 'drift', resource, driftMarker, suite.provider.authority.profile);
+            const readback = String(dws.readDoc(nodeRef(resource), suite.provider.authority.profile));
+            const markerCount = semanticMarkerCount(readback, driftMarker);
+            const stale = invokeWorker(evidenceRoot, 'drift-stale-bootstrap', {
+                action: 'rehydrate-from-bootstrap', workspace, stateDir: activeStateDir,
+                provider: suite.provider, bootstrap: baseline.bootstrap,
+            });
+            driftEvidence = {
+                provided: true, accepted, marker: driftMarker, markerCount,
+                workerStatus: stale.status, error: stale.stderr.trim(),
+                passed: markerCount === 1 && stale.status !== 0 && stale.stderr.includes('发生漂移'),
+            };
+            writeResults.push({ kind: 'l1-drift', resource, ...driftEvidence });
+            if (!driftEvidence.passed)
+                throw new Error('Phase 11B drift fail-closed 探针未按预期失败');
+        }
+        renameSync(activeStateDir, baselineStateDir);
+        stage = 'authorized-write-probes';
+        for (const slot of suite.write.documentSlots) {
+            const resource = suite.provider.layers[slot].uri;
+            consumeWrite(resource);
+            const accepted = appendDocumentMarker(evidenceRoot, slot, resource, runId, suite.provider.authority.profile);
+            const readback = String(dws.readDoc(nodeRef(resource), suite.provider.authority.profile));
+            const markerCount = semanticMarkerCount(readback, runId);
+            const verified = markerCount === 1;
+            writeResults.push({
+                kind: 'document-append', slot, resource, commandAccepted: accepted,
+                marker: runId, markerCount, verified,
+                verification: 'independent-full-document-readback',
+            });
+            if (!verified)
+                throw new Error(`Phase 11B ${slot} marker 回读必须恰好一次`);
+        }
+        const currentRows = dws.queryAiTableRecords({
+            baseId: l2.baseId, tableId: l2.tableId, recordIds: [l2.recordId],
+            profile: suite.provider.authority.profile,
+        });
+        const current = exactStructuredState(currentRows, suite.provider);
+        const cells = {};
+        for (const field of suite.write.aitableFields) {
+            cells[l2.fields[field]] = appendTextMarker(current[field], runId);
+        }
+        const l2Resource = l2ResourceRef(suite.provider);
+        consumeWrite(l2Resource);
+        const update = dws.updateAiTableRecord(l2.baseId, l2.tableId, l2.recordId, cells, suite.provider.authority.profile);
+        const updatedRows = dws.queryAiTableRecords({
+            baseId: l2.baseId, tableId: l2.tableId, recordIds: [l2.recordId],
+            profile: suite.provider.authority.profile,
+        });
+        const updated = exactStructuredState(updatedRows, suite.provider);
+        const uniqueAfter = queryUniqueRecord(suite.provider);
+        const l2MarkerCounts = Object.fromEntries(suite.write.aitableFields.map((field) => [
+            field, semanticMarkerCount(updated[field], runId),
+        ]));
+        const l2Verified = suite.write.aitableFields.every((field) => updated[field] === cells[l2.fields[field]] && l2MarkerCounts[field] === 1) &&
+            uniqueAfter.rows.length === 1 && uniqueAfter.rows[0]?.recordId === l2.recordId;
+        writeResults.push({
+            kind: 'aitable-record-update', resource: l2Resource,
+            commandAccepted: update.accepted, recordId: l2.recordId,
+            fields: suite.write.aitableFields, markerCounts: l2MarkerCounts,
+            keyScopeCount: uniqueAfter.rows.length, verified: l2Verified,
+            verification: 'record-id-readback-plus-key-scope-unique-query',
+        });
+        writeJson(join(evidenceRoot, 'write-results.json'), writeResults);
+        if (!l2Verified)
+            throw new Error('Phase 11B L2 固定 recordId 写后回读不一致');
+        if (writeCount !== suite.write.budget) {
+            throw new Error(`Phase 11B 实际写次数 ${writeCount} 与预算 ${suite.write.budget} 不一致`);
+        }
+        stage = 'independent-readback';
+        const independent = independentReadback(suite.provider);
+        writeFile(join(evidenceRoot, 'remote-readback', 'l1.md'), independent.documents.l1.body);
+        writeFile(join(evidenceRoot, 'remote-readback', 'l3.md'), independent.documents.l3.body);
+        writeJson(join(evidenceRoot, 'remote-readback', 'l2.json'), independent.l2.state);
+        writeJson(join(evidenceRoot, 'independent-readback.json'), independent);
+        stage = 'post-write-process-a';
+        const first = requireWorker(invokeWorker(evidenceRoot, 'first-post-write', {
+            action: 'bootstrap-and-rehydrate', workspace, stateDir: activeStateDir,
+            provider: suite.provider,
+        }));
+        writeJson(join(evidenceRoot, 'first-rehydrate.json'), first);
+        renameSync(activeStateDir, firstStateDir);
+        stage = 'post-write-process-b';
+        const second = requireWorker(invokeWorker(evidenceRoot, 'second-post-write', {
+            action: 'bootstrap-and-rehydrate', workspace, stateDir: activeStateDir,
+            provider: suite.provider,
+        }));
+        writeJson(join(evidenceRoot, 'second-rehydrate.json'), second);
+        const coldStart = compareColdStart(baseline, first, second, independent);
+        if (!coldStart.passed)
+            throw new Error('Phase 11B 两进程冷启动 hash/nextAction 不一致');
+        stage = 'local-fail-closed-matrix';
+        const localFailClosed = runLocalFailClosedChecks(workspace, activeStateDir, second, suite.provider);
+        const liveFailClosed = runLiveReadFailClosedChecks(evidenceRoot, workspace, suite, driftEvidence, second);
+        const failClosed = { ...localFailClosed, ...liveFailClosed };
+        if (Object.values(failClosed).some((item) => item.required && !item.passed)) {
+            throw new Error('Phase 11B fail-closed 必选矩阵未全部通过');
+        }
+        stage = 'teardown-readback';
+        const teardown = independentReadback(suite.provider);
+        const teardownPassed = semanticMarkerCount(teardown.documents.l1.body, runId) === 1 &&
+            semanticMarkerCount(teardown.documents.l3.body, runId) === 1 &&
+            suite.write.aitableFields.every((field) => semanticMarkerCount(teardown.l2.state[field], runId) === 1) &&
+            teardown.l2.uniqueCount === 1 &&
+            !teardown.documents.l1.forbidden.length && !teardown.documents.l3.forbidden.length;
+        writeJson(join(evidenceRoot, 'teardown.json'), {
+            passed: teardownPassed,
+            policy: 'retain-authorized-markers; no delete, overwrite, or cleanup',
+            writeCount,
+            markerCounts: {
+                l1: semanticMarkerCount(teardown.documents.l1.body, runId),
+                l3: semanticMarkerCount(teardown.documents.l3.body, runId),
+                l2: Object.fromEntries(suite.write.aitableFields.map((field) => [
+                    field, semanticMarkerCount(teardown.l2.state[field], runId),
+                ])),
+            },
+            uniqueKeyScopeCount: teardown.l2.uniqueCount,
+        });
+        if (!teardownPassed)
+            throw new Error('Phase 11B 最终回读不一致');
+        const assertions = {
+            $schema: 'dingtalk-agent/remote-semantic-state-live-assertions@1',
+            runId,
+            passed: true,
+            identityMatched: true,
+            writes: { planned: suite.write.budget, attempted: writeCount, verified: writeResults.length },
+            coldStart,
+            failClosed,
+            controlState: {
+                provider: second.state.manifest.controlState.provider,
+                remoteProjection: second.state.manifest.controlState.remoteProjection,
+                remoteMarkdownSafe: true,
+            },
+            evidenceRoot,
+            limitations: [
+                suite.nonAdocNegativeTestUri
+                    ? 'non-adoc dedicated resource was checked'
+                    : 'no dedicated non-adoc Live resource; deterministic contract 49 remains the negative type proof',
+                'no duplicate-row resource was created; uniqueness was enforced against the authorized key/scope',
+                'no control-state or credential marker was written remotely; absence was scanned and contract 49 retains injection coverage',
+            ],
+        };
+        writeJson(join(evidenceRoot, 'assertions.json'), assertions);
+        return {
+            $schema: 'dingtalk-agent/remote-semantic-state-live-report@1',
+            passed: true,
+            runId,
+            evidenceRoot,
+            plan: { ...plan, sideEffect: 'authorized-live-probes', remoteRead: true },
+            writes: assertions.writes,
+            coldStart,
+            failClosed,
+            controlState: assertions.controlState,
+            nextAction: second.state.nextAction,
+            teardown: { passed: true, retainedMarkers: true },
+            limitations: assertions.limitations,
+        };
+    }
+    catch (error) {
+        writeJson(join(evidenceRoot, 'failure.json'), {
+            $schema: 'dingtalk-agent/remote-semantic-state-live-failure@1',
+            runId, stage, error: error.message, writeCount, writeResults,
+            reconciliationRequired: writeCount > 0,
+            instruction: '先按固定资源独立回读；禁止盲目重试或扩大 allowlist',
+        });
+        throw error;
+    }
+}
+function readinessGaps(suite, local) {
+    const gaps = [];
+    if (suite.liveAuthorized !== 'yes')
+        gaps.push('LIVE_AUTHORIZED 必须为 yes');
+    if (containsPlaceholder(suite.provider) || containsPlaceholder(suite.write.allowlist)) {
+        gaps.push('Provider/allowlist 仍含占位符');
+    }
+    if (local.scopeId !== suite.provider.scopeId) {
+        gaps.push(`Provider scopeId 必须绑定当前 Agent scope ${local.scopeId}`);
+    }
+    if (!local.mounts.some((item) => item.slot === 'body' && item.provider === 'local-dir')) {
+        gaps.push('本地 Agent Definition 缺少 AGENTS.md body');
+    }
+    const skills = new Set(local.definition.skills.map((item) => item.name));
+    if (!skills.has('dingtalk-basic-behavior')) {
+        gaps.push('Definition 必须包含 dingtalk-basic-behavior');
+    }
+    const missingSkills = suite.requiredSkills.filter((item) => !skills.has(item));
+    if (missingSkills.length)
+        gaps.push(`缺少 Role Skills: ${missingSkills.join(', ')}`);
+    const expectedAllowlist = [
+        suite.provider.layers.l1.uri, suite.provider.layers.l3.uri, l2ResourceRef(suite.provider),
+    ].sort();
+    if (stableStringify([...suite.write.allowlist].sort()) !== stableStringify(expectedAllowlist)) {
+        gaps.push('write allowlist 必须精确等于 L1/L3/L2 三个专用资源');
+    }
+    const writes = suite.write.documentSlots.length + (suite.write.aitableFields.length ? 1 : 0) +
+        (suite.write.driftProbe ? 1 : 0);
+    if (suite.write.budget !== writes)
+        gaps.push(`write budget 必须精确为 ${writes}`);
+    return gaps;
+}
+function validateSpec(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Phase 11B suite 必须是 JSON object');
+    }
+    const input = value;
+    assertKeys(input, [
+        '$schema', 'id', 'scenario', 'liveAuthorized', 'provider', 'requiredSkills',
+        'evidenceRoot', 'write', 'nonAdocNegativeTestUri',
+    ], 'suite');
+    if (input.$schema !== 'dingtalk-agent/remote-semantic-state-live-eval@1' ||
+        !/^[a-z0-9][a-z0-9._-]*$/.test(clean(input.id)) ||
+        input.scenario !== 'memory-and-storage' ||
+        !['yes', 'no'].includes(input.liveAuthorized)) {
+        throw new Error('Phase 11B suite schema/id/scenario/liveAuthorized 非法');
+    }
+    planRemoteSemanticState(input.provider);
+    assertNoSecretKeys(input);
+    const requiredSkills = stringList(input.requiredSkills, 'requiredSkills', true);
+    if (!requiredSkills.includes('dingtalk-basic-behavior') ||
+        !requiredSkills.some((item) => item !== 'dingtalk-basic-behavior')) {
+        throw new Error('Phase 11B requiredSkills 必须包含 Basic 和至少一个 Role Skill');
+    }
+    if (!clean(input.evidenceRoot) || resolve(input.evidenceRoot) === resolve('.')) {
+        throw new Error('Phase 11B evidenceRoot 非法');
+    }
+    assertKeys(input.write, [
+        'allowlist', 'budget', 'documentSlots', 'aitableFields', 'driftProbe', 'retainMarkers',
+    ], 'write');
+    const allowlist = stringList(input.write?.allowlist, 'write.allowlist', true);
+    const documentSlots = stringList(input.write?.documentSlots, 'write.documentSlots', true);
+    if (documentSlots.length !== 2 || !documentSlots.includes('l1') || !documentSlots.includes('l3')) {
+        throw new Error('Phase 11B documentSlots 必须精确包含 l1 和 l3');
+    }
+    const aitableFields = stringList(input.write?.aitableFields, 'write.aitableFields', true);
+    if (aitableFields.some((item) => !['summary', 'nextAction'].includes(item)) ||
+        new Set(aitableFields).size !== aitableFields.length) {
+        throw new Error('Phase 11B aitableFields 只允许 summary/nextAction 且不能重复');
+    }
+    if (!Number.isInteger(input.write?.budget) || input.write.budget < 1 ||
+        input.write.budget > 10 || input.write?.driftProbe !== true ||
+        input.write?.retainMarkers !== true) {
+        throw new Error('Phase 11B write 必须固定正整数预算、启用 driftProbe 并保留 marker');
+    }
+    if (input.nonAdocNegativeTestUri !== undefined && !clean(input.nonAdocNegativeTestUri)) {
+        throw new Error('Phase 11B nonAdocNegativeTestUri 不能为空');
+    }
+    return JSON.parse(JSON.stringify({
+        ...input, requiredSkills, write: {
+            ...input.write, allowlist, documentSlots, aitableFields,
+        },
+    }));
+}
+function verifyTableShape(base, tableResult, provider, writable) {
+    const l2 = provider.layers.l2;
+    const baseTables = findArray(base, 'tables');
+    if (!baseTables.length || !baseTables.some((item) => clean(item?.tableId) === l2.tableId)) {
+        throw new Error('Phase 11B Base 回读不包含声明的 tableId');
+    }
+    const tables = findArray(tableResult, 'tables');
+    const table = tables.find((item) => clean(item?.tableId) === l2.tableId);
+    if (!table)
+        throw new Error('Phase 11B table get 未精确返回声明的 tableId');
+    const fields = Array.isArray(table.fields) ? table.fields : [];
+    const ids = new Set(fields.map((item) => clean(item?.fieldId)));
+    const missing = Object.entries(l2.fields).filter(([, id]) => !ids.has(id)).map(([name]) => name);
+    if (missing.length)
+        throw new Error(`Phase 11B table 缺少 fieldId: ${missing.join(', ')}`);
+    for (const name of writable) {
+        const field = fields.find((item) => clean(item?.fieldId) === l2.fields[name]);
+        const type = clean(field?.type).toLowerCase();
+        if (['formula', 'creator', 'lastmodifier', 'createdtime', 'lastmodifiedtime'].includes(type)) {
+            throw new Error(`Phase 11B ${name} 不能绑定只读 field type=${type}`);
+        }
+    }
+}
+function queryUniqueRecord(provider) {
+    const l2 = provider.layers.l2;
+    const rows = dws.queryAiTableRecords({
+        baseId: l2.baseId,
+        tableId: l2.tableId,
+        filters: {
+            operator: 'and',
+            operands: [
+                { operator: 'eq', operands: [l2.fields.key, l2.expected.key] },
+                { operator: 'eq', operands: [l2.fields.scopeId, l2.expected.scopeId] },
+            ],
+        },
+        profile: provider.authority.profile,
+    });
+    if (rows.length !== 1 || clean(rows[0]?.recordId) !== l2.recordId) {
+        throw new Error(`Phase 11B L2 key+scope 必须唯一命中声明 recordId；实际 count=${rows.length}`);
+    }
+    return { rows, state: exactStructuredState(rows, provider) };
+}
+function exactStructuredState(rows, provider) {
+    const l2 = provider.layers.l2;
+    if (rows.length !== 1 || clean(rows[0]?.recordId) !== l2.recordId) {
+        throw new Error(`Phase 11B L2 recordId=${l2.recordId} 必须精确回读一条记录`);
+    }
+    const cells = rows[0]?.cells;
+    if (!cells || typeof cells !== 'object' || Array.isArray(cells)) {
+        throw new Error('Phase 11B L2 回读缺少 cells');
+    }
+    const state = {
+        recordId: l2.recordId,
+        key: textCell(cells[l2.fields.key]),
+        scopeId: textCell(cells[l2.fields.scopeId]),
+        status: textCell(cells[l2.fields.status]),
+        nextAction: textCell(cells[l2.fields.nextAction]),
+        summary: textCell(cells[l2.fields.summary]),
+        sourceRefs: textCell(cells[l2.fields.sourceRefs]),
+    };
+    if (state.key !== l2.expected.key || state.scopeId !== l2.expected.scopeId) {
+        throw new Error('Phase 11B L2 recordId/key/scopeId 绑定不一致');
+    }
+    for (const key of ['status', 'nextAction', 'summary', 'sourceRefs']) {
+        if (!state[key])
+            throw new Error(`Phase 11B L2 缺少 ${key}`);
+    }
+    return state;
+}
+function independentReadback(provider) {
+    const documents = {};
+    for (const slot of ['l1', 'l3']) {
+        const layer = provider.layers[slot];
+        const info = dws.docInfo(nodeRef(layer.uri), provider.authority.profile);
+        assertAdoc(slot, info);
+        const body = String(dws.readDoc(nodeRef(layer.uri), provider.authority.profile));
+        const forbidden = forbiddenRemoteFields(body);
+        if (forbidden.length) {
+            throw new Error(`Phase 11B ${slot} 远端 Markdown 含控制状态/凭据: ${forbidden.join(', ')}`);
+        }
+        documents[slot] = { info, body, hash: digest(body), forbidden };
+    }
+    const unique = queryUniqueRecord(provider);
+    return {
+        documents,
+        l2: {
+            state: unique.state,
+            hash: digest(stableStringify(unique.state)),
+            uniqueCount: unique.rows.length,
+        },
+    };
+}
+function compareColdStart(baseline, first, second, readback) {
+    const fields = [
+        'definitionHash', 'providerHash', 'memoryHash', 'structuredStateHash',
+        'knowledgeHash', 'stateHash', 'nextAction',
+    ];
+    const comparisons = Object.fromEntries(fields.map((field) => [field, {
+            first: first.state[field], second: second.state[field],
+            matched: first.state[field] === second.state[field],
+        }]));
+    const remoteMatched = first.state.memoryHash === readback.documents.l1.hash &&
+        first.state.knowledgeHash === readback.documents.l3.hash &&
+        first.state.structuredStateHash === readback.l2.hash;
+    return {
+        passed: baseline.state.definitionHash === first.state.definitionHash &&
+            baseline.state.providerHash === first.state.providerHash &&
+            first.pid !== second.pid && fields.every((field) => comparisons[field].matched) && remoteMatched,
+        baselinePid: baseline.pid,
+        firstPid: first.pid,
+        secondPid: second.pid,
+        distinctProcesses: first.pid !== second.pid,
+        freshStateDir: true,
+        baselineDefinitionStable: baseline.state.definitionHash === first.state.definitionHash,
+        baselineProviderStable: baseline.state.providerHash === first.state.providerHash,
+        comparisons,
+        independentRemoteHashesMatched: remoteMatched,
+    };
+}
+function runLocalFailClosedChecks(workspace, activeStateDir, second, provider) {
+    const manifestPath = second.state.manifestPath;
+    const originalManifest = readFileSync(manifestPath, 'utf8');
+    const manifest = JSON.parse(originalManifest);
+    manifest.layers.l1.cachePath = manifest.layers.l3.cachePath;
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    let slotError = '';
+    try {
+        verifyRemoteSemanticStateCache(workspace, second.bootstrap, provider);
+    }
+    catch (error) {
+        slotError = error.message;
+    }
+    writeFileSync(manifestPath, originalManifest);
+    const memoryMount = second.bootstrap.mounts.find((item) => item.slot === 'memory');
+    if (!memoryMount)
+        throw new Error('Phase 11B 第二进程缺少 memory mount');
+    const originalCache = readFileSync(memoryMount.path, 'utf8');
+    writeFileSync(memoryMount.path, `${originalCache}\nDTA_PHASE_11B_LOCAL_TAMPER\n`);
+    let cacheError = '';
+    try {
+        verifyRemoteSemanticStateCache(workspace, second.bootstrap, provider);
+    }
+    catch (error) {
+        cacheError = error.message;
+    }
+    writeFileSync(memoryMount.path, originalCache);
+    const restored = verifyRemoteSemanticStateCache(workspace, second.bootstrap, provider);
+    return {
+        slotSwap: { required: true, passed: slotError.includes('slot/source/cachePath 串线'), error: slotError },
+        cacheTamper: { required: true, passed: cacheError.includes('mount/cache hash 不一致'), error: cacheError },
+        restoredCache: {
+            required: true, passed: restored.stateHash === second.state.stateHash,
+            activeStateDir,
+        },
+    };
+}
+function runLiveReadFailClosedChecks(evidenceRoot, workspace, suite, drift, second) {
+    const provider = suite.provider;
+    const mutate = (patch) => {
+        const value = JSON.parse(JSON.stringify(provider));
+        patch(value);
+        return value;
+    };
+    const identity = invokeWorker(evidenceRoot, 'negative-identity', {
+        action: 'bootstrap-and-rehydrate', workspace,
+        stateDir: join(evidenceRoot, 'state', 'negative-identity'),
+        provider: mutate((value) => { value.authority.expectedUserId += '-mismatch'; }),
+    });
+    const recordProvider = mutate((value) => { value.layers.l2.recordId += '-mismatch'; });
+    let recordError = '';
+    try {
+        verifyRemoteSemanticStateCache(workspace, second.bootstrap, recordProvider);
+    }
+    catch (error) {
+        recordError = error.message;
+    }
+    const key = invokeWorker(evidenceRoot, 'negative-key', {
+        action: 'bootstrap-and-rehydrate', workspace,
+        stateDir: join(evidenceRoot, 'state', 'negative-key'),
+        provider: mutate((value) => { value.layers.l2.expected.key += '-mismatch'; }),
+    });
+    const scope = invokeWorker(evidenceRoot, 'negative-scope', {
+        action: 'bootstrap-and-rehydrate', workspace,
+        stateDir: join(evidenceRoot, 'state', 'negative-scope'),
+        provider: mutate((value) => {
+            value.scopeId += '-mismatch';
+            value.layers.l2.expected.scopeId = value.scopeId;
+        }),
+    });
+    let nonAdoc;
+    if (suite.nonAdocNegativeTestUri) {
+        const info = dws.docInfo(nodeRef(suite.nonAdocNegativeTestUri), provider.authority.profile);
+        const rejected = String(info.contentType || '').toUpperCase() !== 'ALIDOC' ||
+            String(info.extension || '').toLowerCase() !== 'adoc';
+        nonAdoc = { required: true, provided: true, passed: rejected, info };
+    }
+    else {
+        nonAdoc = {
+            required: false, provided: false, passed: true,
+            proof: 'Live resource not provided; deterministic contract 49 retains non-adoc rejection',
+        };
+    }
+    return {
+        identityMismatch: {
+            required: true, passed: identity.status !== 0 && identity.stderr.includes('身份不符'),
+            error: identity.stderr.trim(),
+        },
+        recordIdMismatch: {
+            required: true,
+            passed: recordError.includes('manifest Provider/Definition/scope 绑定不一致'),
+            error: recordError,
+            proof: 'local manifest binding mutation; no unlisted recordId was requested from DWS',
+        },
+        keyMismatch: {
+            required: true, passed: key.status !== 0 && key.stderr.includes('recordId/key/scopeId 绑定不一致'),
+            error: key.stderr.trim(),
+        },
+        scopeMismatch: {
+            required: true, passed: scope.status !== 0 && scope.stderr.includes('Definition/authority/storage/scope'),
+            error: scope.stderr.trim(),
+        },
+        remoteDrift: { required: true, ...drift },
+        nonAdoc,
+        duplicateKeyScope: {
+            required: true, passed: true,
+            proof: 'authorized key+scope query returned exactly one declared recordId before and after write',
+        },
+        forbiddenRemoteControlState: {
+            required: true, passed: true, liveInjected: false,
+            proof: 'both authorized documents scanned clean; deterministic contract 49 retains injection rejection',
+        },
+    };
+}
+function invokeWorker(evidenceRoot, name, input) {
+    const inputPath = join(evidenceRoot, 'bootstrap', `${name}.input.json`);
+    writeJson(inputPath, input);
+    const workerPath = fileURLToPath(new URL('./remote-semantic-state-worker.js', import.meta.url));
+    const run = spawnSync(process.execPath, [workerPath, inputPath], {
+        encoding: 'utf8', timeout: 300_000, maxBuffer: 64 * 1024 * 1024,
+    });
+    writeFile(join(evidenceRoot, 'bootstrap', `${name}.stdout.json`), run.stdout || '');
+    writeFile(join(evidenceRoot, 'bootstrap', `${name}.stderr.log`), run.stderr || '');
+    let result = null;
+    if (run.status === 0 && run.stdout) {
+        try {
+            result = JSON.parse(run.stdout);
+        }
+        catch {
+            result = null;
+        }
+    }
+    return { status: run.status, stderr: run.stderr || '', result };
+}
+function requireWorker(invocation) {
+    if (invocation.status !== 0 || !invocation.result) {
+        throw new Error(`Phase 11B worker 失败: ${invocation.stderr.trim() || 'invalid output'}`);
+    }
+    return invocation.result;
+}
+function appendDocumentMarker(evidenceRoot, label, uri, marker, profile) {
+    const path = join(evidenceRoot, 'write-intent', `${label}.md`);
+    writeFile(path, `\n\nPhase 11B semantic state validation marker: ${marker}\n`);
+    return Boolean(dws.appendDoc(nodeRef(uri), path, profile));
+}
+function appendTextMarker(value, marker) {
+    return `${value.trimEnd()}\nPhase 11B semantic state validation marker: ${marker}`;
+}
+function assertAdoc(slot, info) {
+    const contentType = String(info?.contentType || '').toUpperCase();
+    const extension = String(info?.extension || '').toLowerCase();
+    if (contentType !== 'ALIDOC' || extension !== 'adoc') {
+        throw new Error(`Phase 11B ${slot} 只接受在线文档 adoc；` +
+            `实际 contentType=${contentType || '?'} extension=${extension || '?'}`);
+    }
+}
+function assertRemoteMarkdownSafe(slot, body) {
+    const found = forbiddenRemoteFields(body);
+    if (found.length) {
+        throw new Error(`Phase 11B ${slot} 远端 Markdown 含控制状态/凭据: ${found.join(', ')}`);
+    }
+}
+function forbiddenRemoteFields(body) {
+    return FORBIDDEN_REMOTE_PATTERNS.filter(([, pattern]) => pattern.test(body)).map(([name]) => name);
+}
+function semanticMarkerCount(body, marker) {
+    const normalizedBody = dws.words(body);
+    const normalizedMarker = dws.words(marker);
+    if (!normalizedMarker)
+        return 0;
+    return normalizedBody.split(normalizedMarker).length - 1;
+}
+function nodeRef(uri) {
+    return uri.startsWith('dingtalk-doc:') ? uri.slice('dingtalk-doc:'.length) : uri;
+}
+function l2ResourceRef(provider) {
+    const l2 = provider.layers.l2;
+    return `dingtalk-aitable:${l2.baseId}/${l2.tableId}/${l2.recordId}`;
+}
+function redactProvider(provider) {
+    const ref = (value) => ({ hash: digest(value), redacted: true });
+    return {
+        $schema: provider.$schema,
+        id: provider.id,
+        scopeIdHash: digest(provider.scopeId),
+        authority: { profileHash: digest(provider.authority.profile), expectedUserIdHash: digest(provider.authority.expectedUserId) },
+        layers: {
+            l1: { provider: 'dingtalk-doc', mode: provider.layers.l1.mode, uri: ref(provider.layers.l1.uri) },
+            l2: {
+                provider: 'dingtalk-aitable', mode: provider.layers.l2.mode,
+                baseId: ref(provider.layers.l2.baseId), tableId: ref(provider.layers.l2.tableId),
+                recordId: ref(provider.layers.l2.recordId),
+                expected: { keyHash: digest(provider.layers.l2.expected.key), scopeIdHash: digest(provider.layers.l2.expected.scopeId) },
+                fields: Object.fromEntries(Object.entries(provider.layers.l2.fields).map(([name, id]) => [name, ref(id)])),
+            },
+            l3: { provider: 'dingtalk-doc', mode: provider.layers.l3.mode, uri: ref(provider.layers.l3.uri) },
+        },
+        controlState: provider.controlState,
+    };
+}
+function safeEvidenceRoot(workspace, input, runId) {
+    if (resolve(input) === resolve('.') || input.split(/[\\/]/).includes('..')) {
+        throw new Error('Phase 11B evidenceRoot 非法');
+    }
+    const base = resolve(workspace, input);
+    assertInside(workspace, base, 'evidenceRoot');
+    assertNoSymlinkAncestors(workspace, base, 'evidenceRoot');
+    const rel = relative(workspace, base).split('\\').join('/');
+    if (!rel.startsWith('.dingtalk-agent/')) {
+        throw new Error('Phase 11B 原始证据必须位于 Workspace 的 gitignored .dingtalk-agent/ 下');
+    }
+    if (existsSync(base) && lstatSync(base).isSymbolicLink()) {
+        throw new Error('Phase 11B evidenceRoot 不能是 symlink');
+    }
+    const path = join(base, runId);
+    if (existsSync(path))
+        throw new Error('Phase 11B evidence run directory 已存在');
+    return path;
+}
+function safeExistingDirectory(root, input, label) {
+    const candidate = resolve(root, input);
+    if (lstatSync(candidate).isSymbolicLink())
+        throw new Error(`Phase 11B ${label} 不能是 symlink`);
+    const path = realpathSync(candidate);
+    assertInside(realpathSync(resolve(root)), path, label);
+    if (!lstatSync(path).isDirectory() || lstatSync(path).isSymbolicLink()) {
+        throw new Error(`Phase 11B ${label} 必须是普通目录`);
+    }
+    return path;
+}
+function safeExistingFile(root, input, label) {
+    const candidate = resolve(root, input);
+    if (lstatSync(candidate).isSymbolicLink())
+        throw new Error(`Phase 11B ${label} 不能是 symlink`);
+    const path = realpathSync(candidate);
+    assertInside(realpathSync(resolve(root)), path, label);
+    if (!lstatSync(path).isFile() || lstatSync(path).isSymbolicLink()) {
+        throw new Error(`Phase 11B ${label} 必须是普通文件`);
+    }
+    return path;
+}
+function assertInside(root, path, label) {
+    const rel = relative(resolve(root), resolve(path));
+    if (rel === '..' || rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`)) {
+        throw new Error(`Phase 11B ${label} 越界`);
+    }
+}
+function assertNoSymlinkAncestors(root, path, label) {
+    const rel = relative(resolve(root), resolve(path));
+    let current = resolve(root);
+    for (const part of rel.split(/[\\/]/).filter(Boolean)) {
+        current = join(current, part);
+        if (!existsSync(current))
+            break;
+        if (lstatSync(current).isSymbolicLink()) {
+            throw new Error(`Phase 11B ${label} 不能穿过 symlink`);
+        }
+    }
+}
+function findArray(value, key) {
+    if (!value || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findArray(item, key);
+            if (found.length)
+                return found;
+        }
+        return [];
+    }
+    const input = value;
+    if (Array.isArray(input[key]))
+        return input[key];
+    for (const item of Object.values(input)) {
+        const found = findArray(item, key);
+        if (found.length)
+            return found;
+    }
+    return [];
+}
+function findValue(value, keys) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findValue(item, keys);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    const input = value;
+    for (const key of keys)
+        if (input[key] !== undefined)
+            return input[key];
+    for (const item of Object.values(input)) {
+        const found = findValue(item, keys);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function textCell(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const input = value;
+        return clean(input.name ?? input.text ?? input.value);
+    }
+    return clean(value);
+}
+function assertNoSecretKeys(value, path = 'suite') {
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => assertNoSecretKeys(item, `${path}[${index}]`));
+        return;
+    }
+    for (const [key, item] of Object.entries(value)) {
+        if (SECRET_KEY.test(key))
+            throw new Error(`Phase 11B suite 禁止凭据字段: ${path}.${key}`);
+        assertNoSecretKeys(item, `${path}.${key}`);
+    }
+}
+function containsPlaceholder(value) {
+    if (typeof value === 'string')
+        return PLACEHOLDER.test(value);
+    if (Array.isArray(value))
+        return value.some(containsPlaceholder);
+    if (value && typeof value === 'object')
+        return Object.values(value).some(containsPlaceholder);
+    return false;
+}
+function assertKeys(value, allowed, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Phase 11B ${label} 必须是 JSON object`);
+    }
+    const extra = Object.keys(value).filter((key) => !allowed.includes(key));
+    if (extra.length)
+        throw new Error(`Phase 11B ${label} 含未知字段: ${extra.join(', ')}`);
+}
+function stringList(value, label, nonEmpty = false) {
+    if (!Array.isArray(value) || value.some((item) => !clean(item))) {
+        throw new Error(`Phase 11B ${label} 必须是非空字符串数组`);
+    }
+    const out = value.map((item) => clean(item));
+    if (nonEmpty && !out.length)
+        throw new Error(`Phase 11B ${label} 不能为空`);
+    if (new Set(out).size !== out.length)
+        throw new Error(`Phase 11B ${label} 不能重复`);
+    return out;
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(value, null, 2) + '\n');
+}
+function writeFile(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, value);
+}
+function clean(value) {
+    return String(value ?? '').trim();
+}
+//# sourceMappingURL=remote-semantic-state-live-evals.js.map