@epoint-testtech/ep-stage-skill 0.0.10 → 0.5.0-alpha.2

package/dist/test/generalization.test.js

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import { compareObservableRuns, summarizeGeneralizationRun, } from '../src/index.js';
+/**
+ * 泛化评估测试。
+ *
+ * 验证 summarizeGeneralizationRun 把单次 run 汇总为可对比指标，
+ * compareObservableRuns 计算两个系统的场景差异/coverage delta/物料解析分歧。
+ */
+describe('generalization evaluation', () => {
+    it('summarizes a single run into comparable metrics', () => {
+        const metricsA = summarizeGeneralizationRun({
+            moduleId: 'zwplace',
+            resolvedInputs: {
+                moduleId: { status: 'resolved', value: 'zwplace', evidence: '' },
+                docsDir: { status: 'resolved', path: '/a/docs', evidence: '' },
+                webappDir: { status: 'resolved', path: '/a/webapp', evidence: '' },
+                javaActionsDir: { status: 'resolved', path: '/a/java', evidence: '' },
+                hintsPath: { status: 'resolved', path: '/a/hints.json', evidence: '' },
+                menu: { status: 'resolved', value: 'm', evidence: '' },
+            },
+            scenario: {
+                moduleId: 'zwplace',
+                candidates: [
+                    { scenario: 'crud.single-page', confidence: 'high', evidenceRefs: [], matchedSkeletonCapabilities: [], unresolved: [] },
+                    { scenario: 'crud.nested', confidence: 'medium', evidenceRefs: [], matchedSkeletonCapabilities: [], unresolved: [] },
+                ],
+                gate: { status: 'confirmed', confirmedBy: 'human', reason: 'ok' },
+                reasoningSummary: { conclusion: '', evidenceChain: [], alternatives: [], confidence: 'high', risks: [], needsHumanReview: false },
+            },
+            coverageDiff: {
+                moduleId: 'zwplace',
+                skeletonCoverageId: 'crud-plus-export/v1',
+                baseline: { plannedWorkflows: ['w1'], candidateWorkflows: ['w2'], unresolvedWorkflows: [] },
+                covered: [{ actionId: 'a', label: 'l', pageId: 'p', status: 'covered', reason: '' }],
+                partiallyCovered: [],
+                gapCandidates: [],
+                unresolved: [],
+                nestedCrudCandidates: [{ pageId: 'p', evidence: [], supportedActions: [], unresolvedReason: 'r' }],
+                comparison: { both: [], onlyBaseline: [], onlyGeneralized: [] },
+                reasoningSummary: { conclusion: '', evidenceChain: [], alternatives: [], confidence: 'medium', risks: [], needsHumanReview: true },
+            },
+        });
+        expect(metricsA).toMatchObject({
+            moduleId: 'zwplace',
+            scenarios: ['crud.single-page', 'crud.nested'],
+            coverage: { covered: 1, gapCandidate: 0, nestedCrud: 1 },
+            baselineWorkflowCount: 2,
+            materialResolution: { docsDir: 'resolved', webappDir: 'resolved', javaActionsDir: 'resolved', hintsPath: 'resolved' },
+        });
+    });
+    it('compares two systems by observability metrics', () => {
+        const metricsA = {
+            moduleId: 'zwplace',
+            materialResolution: { docsDir: 'resolved', webappDir: 'resolved', javaActionsDir: 'resolved', hintsPath: 'resolved' },
+            scenarios: ['crud.single-page', 'crud.nested'],
+            coverage: { covered: 1, gapCandidate: 0, nestedCrud: 1 },
+            baselineWorkflowCount: 2,
+        };
+        const metricsB = {
+            moduleId: 'other',
+            materialResolution: { docsDir: 'missing', webappDir: 'resolved', javaActionsDir: 'resolved', hintsPath: 'missing' },
+            scenarios: ['crud.single-page', 'export'],
+            coverage: { covered: 3, gapCandidate: 2, nestedCrud: 0 },
+            baselineWorkflowCount: 5,
+        };
+        const cmp = compareObservableRuns(metricsA, metricsB);
+        expect(cmp.scenariosOnlyInA).toEqual(['crud.nested']);
+        expect(cmp.scenariosOnlyInB).toEqual(['export']);
+        expect(cmp.coverageDelta).toEqual({ covered: -2, gapCandidate: -2, nestedCrud: 1 });
+        expect(cmp.materialResolutionDivergence).toContain('docsDir');
+        expect(cmp.materialResolutionDivergence).toContain('hintsPath');
+    });
+});

package/dist/test/material-inventory.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=material-inventory.test.d.ts.map

package/dist/test/material-inventory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material-inventory.test.d.ts","sourceRoot":"","sources":["../../test/material-inventory.test.ts"],"names":[],"mappings":""}

package/dist/test/material-inventory.test.js

@@ -0,0 +1,155 @@
+import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { extractCodeListSummary, resolveMaterialInventory, } from '../src/index.js';
+describe('material inventory resolver', () => {
+    it('maps code_list material refs to contract generation inputs', () => {
+        const root = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-material-'));
+        const codeListPath = path.join(root, '_docs', 'code_list.md');
+        const specPath = path.join(root, '_docs', '003-场所窗口信息管理-20260518', 'spec.yaml');
+        const htmlPath = path.join(root, 'src/main/webapp/perpage/zwplace/gxhzwplacelist.html');
+        const javaPath = path.join(root, 'src/main/java/com/epoint/zwplace/action/GxhZwPlaceListAction.java');
+        const hintsPath = path.join(root, '_docs', 'zwplace.module-hints.json');
+        mkdirSync(path.dirname(specPath), { recursive: true });
+        mkdirSync(path.dirname(htmlPath), { recursive: true });
+        mkdirSync(path.dirname(javaPath), { recursive: true });
+        writeFileSync(specPath, 'module:\n  id: zwplace\n');
+        writeFileSync(htmlPath, '<html></html>');
+        writeFileSync(javaPath, 'class GxhZwPlaceListAction {}');
+        writeFileSync(hintsPath, '{}');
+        writeFileSync(codeListPath, [
+            '# 场所窗口信息管理代码清单',
+            `> 整理目录：\`${root}\``,
+            'menu: 场所窗口信息管理>场所窗口信息列表',
+            '`_docs/003-场所窗口信息管理-20260518/spec.yaml`',
+            '`src/main/webapp/perpage/zwplace/gxhzwplacelist.html`',
+            '`src/main/java/com/epoint/zwplace/action/GxhZwPlaceListAction.java`',
+            '`_docs/zwplace.module-hints.json`',
+        ].join('\n'), 'utf8');
+        const codeList = extractCodeListSummary(codeListPath);
+        const result = resolveMaterialInventory({
+            codeListPath,
+            codeList,
+            debugOverrides: {},
+            stageContext: {
+                projectName: 'glue-project',
+                projectDir: root,
+                mode: 'glue',
+                envPath: '.env',
+                envFilePath: path.join(root, '.env'),
+                knowledgeRoot: root,
+                codeListPaths: [codeListPath],
+                stageContextPath: path.join(root, 'stage-context.md'),
+            },
+        });
+        expect(result.resolvedInputs).toMatchObject({
+            moduleId: { status: 'resolved', value: 'zwplace' },
+            docsDir: { status: 'resolved', path: path.dirname(specPath) },
+            webappDir: { status: 'resolved', path: path.dirname(htmlPath) },
+            javaActionsDir: { status: 'resolved', path: path.dirname(javaPath) },
+            hintsPath: { status: 'resolved', path: hintsPath },
+            menu: { status: 'resolved', value: '场所窗口信息管理>场所窗口信息列表' },
+        });
+        expect(result.gate.status).toBe('confirmed');
+    });
+    it('does not infer knowledgeRoot from _docs hierarchy when code_list lacks structured root info', () => {
+        const root = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-material-no-root-'));
+        const codeListPath = path.join(root, '_docs', '014-测试需求10-20260622', 'code_list.md');
+        mkdirSync(path.dirname(codeListPath), { recursive: true });
+        writeFileSync(codeListPath, [
+            '# 场所窗口信息管理代码清单',
+            '`src/main/webapp/perpage/zwplace/gxhzwplacelist.html`',
+        ].join('\n'), 'utf8');
+        const codeList = extractCodeListSummary(codeListPath);
+        expect(codeList.knowledgeRoot).toBeUndefined();
+        expect(codeList.knowledgeRootSource).toBe('none');
+    });
+    it('stops at material gate when webapp or java actions cannot be resolved', () => {
+        const root = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-material-missing-'));
+        const codeListPath = path.join(root, 'code_list.md');
+        writeFileSync(codeListPath, '# 空代码清单\n');
+        const result = resolveMaterialInventory({
+            codeListPath,
+            codeList: extractCodeListSummary(codeListPath),
+            debugOverrides: {},
+        });
+        expect(result.gate).toMatchObject({
+            status: 'needs_review',
+        });
+        expect(result.resolvedInputs.webappDir.status).toBe('missing');
+        expect(result.resolvedInputs.javaActionsDir.status).toBe('missing');
+    });
+    it('supports a writable external code_list that already contains write-back fields', () => {
+        const root = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-material-writeback-'));
+        const knowledgeRoot = path.join(root, 'knowledge-project', 'zwplace');
+        const writableDir = path.join(root, 'agent-input');
+        const docsPath = path.join(writableDir, 'zwplace-observable-docs', 'zwplace.context.md');
+        const hintsPath = path.join(writableDir, 'zwplace.module-hints.json');
+        const htmlPath = path.join(knowledgeRoot, 'src', 'main', 'webapp', 'perpage', 'zwplace', 'gxhzwplacelist.html');
+        const javaPath = path.join(knowledgeRoot, 'src', 'main', 'java', 'com', 'epoint', 'zwplace', 'action', 'GxhZwPlaceListAction.java');
+        const codeListPath = path.join(writableDir, 'zwplace.observable.code_list.md');
+        mkdirSync(path.dirname(docsPath), { recursive: true });
+        mkdirSync(path.dirname(htmlPath), { recursive: true });
+        mkdirSync(path.dirname(javaPath), { recursive: true });
+        writeFileSync(docsPath, '# zwplace context\n');
+        writeFileSync(hintsPath, '{}');
+        writeFileSync(htmlPath, '<html></html>');
+        writeFileSync(javaPath, 'class GxhZwPlaceListAction {}');
+        writeFileSync(codeListPath, [
+            '# 场所窗口信息管理代码清单',
+            `knowledgeRoot: ${knowledgeRoot}`,
+            'menu: 场所窗口信息管理>场所窗口信息列表',
+            '`./zwplace-observable-docs/zwplace.context.md`',
+            '`src/main/webapp/perpage/zwplace/gxhzwplacelist.html`',
+            '`src/main/java/com/epoint/zwplace/action/GxhZwPlaceListAction.java`',
+            '`./zwplace.module-hints.json`',
+        ].join('\n'), 'utf8');
+        const codeList = extractCodeListSummary(codeListPath);
+        const result = resolveMaterialInventory({
+            codeListPath,
+            codeList,
+            debugOverrides: {},
+        });
+        expect(codeList.knowledgeRoot).toBe(knowledgeRoot);
+        expect(codeList.knowledgeRootSource).toBe('code_list');
+        expect(codeList.menu).toBe('场所窗口信息管理>场所窗口信息列表');
+        expect(result.resolvedInputs).toMatchObject({
+            docsDir: { status: 'resolved', path: path.dirname(docsPath) },
+            webappDir: { status: 'resolved', path: path.dirname(htmlPath) },
+            javaActionsDir: { status: 'resolved', path: path.dirname(javaPath) },
+            hintsPath: { status: 'resolved', path: hintsPath },
+            menu: { status: 'resolved', value: '场所窗口信息管理>场所窗口信息列表' },
+        });
+    });
+    // 本用例依赖 knowledge-project/epoint-web-v9.5.2 submodule 的真实框架源码；CI 不拉取 submodule，检出后只留空目录，因此按实际内容目录判断，缺席时跳过，仅在本机全量验证。
+    it.skipIf(!existsSync(path.resolve(path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'examples'), '../../../knowledge-project/epoint-web-v9.5.2/src/main/java/com/epoint/schemeresource/action')))('resolves the checked-in writable schemeresource code_list example', () => {
+        const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+        const examplesDir = path.join(packageRoot, 'examples');
+        const codeListPath = path.join(examplesDir, 'schemeresource.observable.code_list.md');
+        const knowledgeRoot = path.resolve(examplesDir, '../../../knowledge-project/epoint-web-v9.5.2');
+        const docsDir = path.join(examplesDir, 'schemeresource-observable-docs');
+        const webappDir = path.join(knowledgeRoot, 'src', 'main', 'webapp', 'perpage', 'schemeresource');
+        const javaActionsDir = path.join(knowledgeRoot, 'src', 'main', 'java', 'com', 'epoint', 'schemeresource', 'action');
+        const hintsPath = path.join(examplesDir, 'schemeresource.module-hints.json');
+        const codeList = extractCodeListSummary(codeListPath);
+        const result = resolveMaterialInventory({
+            codeListPath,
+            codeList,
+            debugOverrides: {},
+        });
+        expect(codeList.knowledgeRoot).toBe(knowledgeRoot);
+        expect(codeList.knowledgeRootSource).toBe('code_list');
+        expect(codeList.menu).toBe('方案资源文档>方案资源文档列表');
+        expect(result.resolvedInputs).toMatchObject({
+            moduleId: { status: 'resolved', value: 'schemeresource' },
+            docsDir: { status: 'resolved', path: docsDir },
+            webappDir: { status: 'resolved', path: webappDir },
+            javaActionsDir: { status: 'resolved', path: javaActionsDir },
+            hintsPath: { status: 'resolved', path: hintsPath },
+            menu: { status: 'resolved', value: '方案资源文档>方案资源文档列表' },
+        });
+        expect(result.gate.status).toBe('confirmed');
+    });
+});

package/dist/test/observable-chain.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=observable-chain.test.d.ts.map

package/dist/test/observable-chain.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable-chain.test.d.ts","sourceRoot":"","sources":["../../test/observable-chain.test.ts"],"names":[],"mappings":""}

package/dist/test/observable-chain.test.js

@@ -0,0 +1,123 @@
+import { mkdtempSync, readFileSync, existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { createTraceWriter, renderReviewSummary, } from '../src/index.js';
+describe('observable glue chain trace writer', () => {
+    function createScenarioPayload() {
+        return {
+            stage: 'scenario-inference',
+            stageLabel: '场景推理追踪',
+            inputs: [{ kind: 'code_list', path: '/repo/knowledge/_docs/code_list.md' }],
+            outputs: [{ kind: 'scenario', path: 'scenario-inference.json' }],
+            reasoningSummary: {
+                conclusion: '当前页面是嵌套 CRUD 候选。',
+                evidenceChain: [
+                    {
+                        source: 'html',
+                        path: '/repo/webapp/gxhzwplaceadd.html',
+                        text: '弹窗页面中存在 mini-datagrid 与 添加窗口 按钮',
+                    },
+                ],
+                alternatives: ['crud.single-page', 'crud.nested'],
+                confidence: 'medium',
+                risks: ['子表保存后断言未确认'],
+                needsHumanReview: true,
+            },
+            candidateCount: 1,
+            unresolvedCount: 1,
+            gate: {
+                status: 'needs_review',
+                reason: '需要人工确认嵌套 CRUD 是否进入 testcase。',
+            },
+        };
+    }
+    it('writes stage json and summary markdown with reviewable reasoning', () => {
+        const projectDir = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-trace-'));
+        const writer = createTraceWriter({
+            projectDir,
+            runId: '20260616T120000Z-demo',
+            codeListPath: '/repo/knowledge/_docs/code_list.md',
+        });
+        const payload = createScenarioPayload();
+        const stagePath = writer.writeStage('scenario-inference', payload);
+        const summaryPath = writer.writeSummary([
+            {
+                stage: 'scenario-inference',
+                stageLabel: '场景推理追踪',
+                status: 'needs_review',
+                conclusion: payload.reasoningSummary?.conclusion ?? '',
+                needsHumanReview: true,
+            },
+        ]);
+        const traceDir = path.join(projectDir, '.stage', 'trace', '20260616T120000Z-demo');
+        expect(writer.runId).toBe('20260616T120000Z-demo');
+        expect(stagePath).toBe(path.join(traceDir, 'scenario-inference.json'));
+        expect(summaryPath).toBe(path.join(traceDir, 'summary.md'));
+        expect(existsSync(path.join(traceDir, 'scenario-inference.json'))).toBe(true);
+        expect(JSON.parse(readFileSync(path.join(traceDir, 'scenario-inference.json'), 'utf8'))).toMatchObject({
+            stage: 'scenario-inference',
+            reasoningSummary: {
+                confidence: 'medium',
+                needsHumanReview: true,
+            },
+        });
+        expect(readFileSync(path.join(traceDir, 'summary.md'), 'utf8')).toContain('场景推理追踪');
+        expect(readFileSync(path.join(traceDir, 'summary.md'), 'utf8')).toContain('需要人工确认');
+    });
+    it('rejects stage write when file stage does not match payload stage', () => {
+        const projectDir = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-trace-'));
+        const writer = createTraceWriter({
+            projectDir,
+            runId: '20260616T120000Z-demo',
+            codeListPath: '/repo/knowledge/_docs/code_list.md',
+        });
+        expect(() => writer.writeStage('coverage-diff', createScenarioPayload())).toThrow('trace stage mismatch');
+    });
+    it('rejects unsafe run id path segments', () => {
+        const projectDir = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-trace-'));
+        const unsafeRunIds = ['../escape', 'nested/run', '/tmp/escape', 'trace..escape', '.', ''];
+        for (const runId of unsafeRunIds) {
+            expect(() => createTraceWriter({
+                projectDir,
+                runId,
+                codeListPath: '/repo/knowledge/_docs/code_list.md',
+            })).toThrow('invalid trace runId');
+        }
+    });
+    it('renders human-readable review summary for conversation output', () => {
+        const text = renderReviewSummary({
+            title: '场景推理需要确认',
+            reasoningSummary: {
+                conclusion: '当前页面是嵌套 CRUD 候选。',
+                evidenceChain: [
+                    { source: 'html', path: 'gxhzwplaceadd.html', text: 'mini-datagrid + 添加窗口' },
+                ],
+                alternatives: ['crud.single-page', 'crud.nested'],
+                confidence: 'medium',
+                risks: ['子表保存后断言未确认'],
+                needsHumanReview: true,
+            },
+            nextAction: 'confirm / correct / add-evidence / skip',
+        });
+        expect(text).toContain('结论：当前页面是嵌套 CRUD 候选。');
+        expect(text).toContain('证据链：');
+        expect(text).toContain('待确认项：子表保存后断言未确认');
+        expect(text).toContain('下一步：confirm / correct / add-evidence / skip');
+    });
+    it('renders empty evidence chain explicitly for review summary', () => {
+        const text = renderReviewSummary({
+            title: '场景推理需要确认',
+            reasoningSummary: {
+                conclusion: '当前证据不足。',
+                evidenceChain: [],
+                alternatives: [],
+                confidence: 'low',
+                risks: [],
+                needsHumanReview: true,
+            },
+            nextAction: 'add-evidence',
+        });
+        expect(text).toContain('证据链：\n- 无');
+    });
+});

package/dist/test/page-structure.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=page-structure.test.d.ts.map

package/dist/test/page-structure.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-structure.test.d.ts","sourceRoot":"","sources":["../../test/page-structure.test.ts"],"names":[],"mappings":""}

package/dist/test/page-structure.test.js

@@ -0,0 +1,45 @@
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { extractHtmlPage, summarizePageStructure } from '../src/index.js';
+/**
+ * 页面结构信号抽取与场景归纳测试。
+ *
+ * 验证 extractHtmlPage 能从 HTML 静态结构钻探出 mini-datagrid / fui-condition /
+ * mini-grid-pager 等结构信号，且 summarizePageStructure 能据此识别嵌套 CRUD 候选。
+ */
+describe('page structure signals', () => {
+    it('extracts MiniUI grid, condition, pager and nested crud signals', () => {
+        const dir = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-html-'));
+        const htmlPath = path.join(dir, 'gxhzwplaceadd.html');
+        writeFileSync(htmlPath, [
+            '<html><head><title>新增场所信息管理</title></head><body>',
+            '<div class="fui-condition"><input /></div>',
+            '<a class="mini-button" onclick="addWindow()">添加窗口</a>',
+            '<a class="mini-button" onclick="deleteWindow()">删除选中</a>',
+            '<div id="windowGrid" class="mini-datagrid">',
+            '  <div property="columns">',
+            '    <div type="checkcolumn"></div>',
+            '    <div type="indexcolumn">序</div>',
+            '    <div field="windowname">窗口名称</div>',
+            '    <div field="windowtype">窗口类型</div>',
+            '    <div field="windowaddr">窗口地址</div>',
+            '  </div>',
+            '</div>',
+            '<div class="mini-grid-pager"></div>',
+            '<script>function openChild(){ epoint.openTopDialog("新增窗口", "gxhwindowadd.html"); }</script>',
+            '</body></html>',
+        ].join('\n'), 'utf8');
+        const page = extractHtmlPage(htmlPath);
+        expect(page.pageStructureSignals).toMatchObject({
+            dataGrid: { staticPresent: true, selector: "div[class*='mini-datagrid']" },
+            searchCondition: { staticPresent: true, selector: "div[class*='fui-condition']" },
+            pager: { staticPresent: true, selector: "div[class*='mini-grid-pager']" },
+        });
+        const summary = summarizePageStructure(page);
+        expect(summary.nestedCrudCandidate).toBe(true);
+        expect(summary.evidenceLabels).toContain('可见 mini-datagrid 结构存在');
+        expect(summary.evidenceLabels).toContain('可见 mini-grid-pager 结构存在');
+    });
+});

package/dist/test/runtime/ai-runtime-trace.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ai-runtime-trace.test.d.ts.map

package/dist/test/runtime/ai-runtime-trace.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-runtime-trace.test.d.ts","sourceRoot":"","sources":["../../../test/runtime/ai-runtime-trace.test.ts"],"names":[],"mappings":""}

package/dist/test/runtime/ai-runtime-trace.test.js

@@ -0,0 +1,78 @@
+import { existsSync, mkdtempSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import JSON5 from 'json5';
+import { describe, expect, it } from 'vitest';
+import { classifyRunFailure, createInitialAiRuntimeTrace, nextRepairRound, writeAiRuntimeTrace, writeRepairReport, } from '../../src/runtime/ai-runtime-trace.js';
+describe('ai runtime trace', () => {
+    it('writes minimal trace with tasks and no repair rounds', () => {
+        const dir = mkdtempSync(path.join(os.tmpdir(), 'ai-trace-'));
+        const trace = createInitialAiRuntimeTrace({
+            testcasePath: path.join(dir, 'testcase.json5'),
+            tasks: [
+                {
+                    caseId: 'syncWindowSystem',
+                    title: '同步窗口管理系统按钮',
+                    role: '业务管理员',
+                    businessIntent: '验证同步',
+                    assertionExpectation: '返回同步结果',
+                    entryContext: {
+                        loginUrl: 'http://example/login',
+                        username: 'yz',
+                        password: 'secret',
+                        directUrl: 'http://example/page',
+                    },
+                    knownContext: {
+                        queryKey: '不适用',
+                        precondition: '使用业务管理员登录',
+                        steps: '点击同步按钮',
+                        assertion: '返回同步结果',
+                    },
+                    codingRules: {
+                        devRulesPath: 'docs/00-memory/dev-rules.md',
+                    },
+                    status: 'pending',
+                },
+            ],
+        });
+        const tracePath = path.join(dir, 'ai-runtime-trace.json5');
+        writeAiRuntimeTrace(tracePath, trace);
+        const parsed = JSON5.parse(readFileSync(tracePath, 'utf8'));
+        expect(parsed.tasks[0].caseId).toBe('syncWindowSystem');
+        expect(parsed.repairRounds).toEqual([]);
+    });
+    it('classifies common Playwright run failures for human repair', () => {
+        expect(classifyRunFailure('frame was detached while resolving iframe')).toMatchObject({
+            failureType: 'iframe_context_error',
+            needsHumanDirection: true,
+        });
+        expect(classifyRunFailure('Timeout 30000ms exceeded for locator')).toMatchObject({
+            failureType: 'locator_or_wait_error',
+            needsHumanDirection: true,
+        });
+        expect(classifyRunFailure('403 unauthorized permission denied')).toMatchObject({
+            failureType: 'permission_blocked',
+            needsHumanDirection: true,
+        });
+        expect(classifyRunFailure('unexpected browser crash')).toMatchObject({
+            failureType: 'unknown_failure',
+            needsHumanDirection: true,
+        });
+    });
+    it('writes repair report into the next repair round directory', () => {
+        const caseDir = mkdtempSync(path.join(os.tmpdir(), 'ai-repair-'));
+        expect(nextRepairRound(caseDir)).toBe(1);
+        const reportPath = writeRepairReport({
+            caseDir,
+            round: nextRepairRound(caseDir),
+            failureType: 'locator_or_wait_error',
+            summary: '疑似定位或等待时机错误',
+            output: 'Timeout 30000ms exceeded for locator(".submit")',
+        });
+        expect(reportPath).toBe(path.join(caseDir, '.ep-stage', 'repair-runs', '001', 'repair-report.md'));
+        expect(existsSync(reportPath)).toBe(true);
+        expect(readFileSync(reportPath, 'utf8')).toContain('失败用例');
+        expect(readFileSync(reportPath, 'utf8')).toContain('需要你确认');
+        expect(nextRepairRound(caseDir)).toBe(2);
+    });
+});

package/dist/test/scenario-inference.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scenario-inference.test.d.ts.map

package/dist/test/scenario-inference.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenario-inference.test.d.ts","sourceRoot":"","sources":["../../test/scenario-inference.test.ts"],"names":[],"mappings":""}

package/dist/test/scenario-inference.test.js

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import { applyScenarioHumanCorrection, inferPageScenarios, } from '../src/index.js';
+/**
+ * 场景推理门禁测试。
+ *
+ * 验证 inferPageScenarios 能从页面结构候选推出嵌套 CRUD 候选并停在 needs_review gate，
+ * 且 applyScenarioHumanCorrection 能记录人工纠偏并要求重跑。
+ */
+describe('scenario inference gate', () => {
+    it('infers nested CRUD candidate and requires human confirmation', () => {
+        const pages = [
+            {
+                pageId: 'gxhzwplacelist',
+                readSearchCandidate: true,
+                createCandidate: true,
+                deleteCandidate: true,
+                updateOrDetailCandidate: true,
+                nestedCrudCandidate: false,
+                evidenceLabels: ['可见 mini-datagrid 结构存在', '可见 mini-grid-pager 结构存在'],
+                risks: [],
+            },
+            {
+                pageId: 'gxhzwplaceadd',
+                readSearchCandidate: true,
+                createCandidate: true,
+                deleteCandidate: true,
+                updateOrDetailCandidate: false,
+                nestedCrudCandidate: true,
+                evidenceLabels: ['弹窗页面存在 mini-datagrid', '按钮 添加窗口', '按钮 删除选中'],
+                risks: ['嵌套 CRUD 断言和保存边界需要人工确认'],
+            },
+        ];
+        const result = inferPageScenarios({
+            moduleId: 'zwplace',
+            pages,
+            skeletonCapabilities: ['crud.create', 'crud.read', 'crud.update', 'crud.delete', 'export.run'],
+        });
+        expect(result.candidates[0]).toMatchObject({
+            scenario: 'crud.nested',
+            confidence: 'medium',
+            matchedSkeletonCapabilities: ['crud.create', 'crud.read', 'crud.delete'],
+            unresolved: ['嵌套 CRUD 断言和保存边界需要人工确认'],
+        });
+        expect(result.gate.status).toBe('needs_review');
+        expect(result.reasoningSummary.needsHumanReview).toBe(true);
+    });
+    it('records human correction and requires rerun', () => {
+        const corrected = applyScenarioHumanCorrection({
+            inference: {
+                moduleId: 'zwplace',
+                candidates: [],
+                gate: { status: 'needs_review', reason: '未识别到场景' },
+                reasoningSummary: {
+                    conclusion: '未识别到稳定场景。',
+                    evidenceChain: [],
+                    alternatives: ['unknown'],
+                    confidence: 'low',
+                    risks: ['证据不足'],
+                    needsHumanReview: true,
+                },
+            },
+            correction: '弹窗 iframe 中存在窗口明细嵌套 CRUD，重点检查添加窗口和删除选中。',
+        });
+        expect(corrected.conversationReview).toMatchObject({
+            status: 'corrected',
+            rerunRequired: true,
+        });
+        expect(corrected.reasoningSummary.evidenceChain[0]).toMatchObject({
+            source: 'human',
+            text: '弹窗 iframe 中存在窗口明细嵌套 CRUD，重点检查添加窗口和删除选中。',
+        });
+    });
+});

package/dist/test/stage-context.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stage-context.test.d.ts.map

package/dist/test/stage-context.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-context.test.d.ts","sourceRoot":"","sources":["../../test/stage-context.test.ts"],"names":[],"mappings":""}