@givolt/i3-composer-agent 3.0.0 → 3.1.0

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/styles/workflows.css

@@ -0,0 +1 @@
+.flow-basics{display:grid;grid-template-columns:1.2fr 1fr 1fr;gap:0 20px;background:white;border:1px solid var(--border);border-radius:8px;padding:20px 24px 0;margin-bottom:16px}.flow-basics .ant-form-item:last-child{grid-column:1/-1}.flow-palette{display:flex;gap:8px;flex-wrap:wrap;align-items:center;padding:12px 0 16px}.flow-palette>span{font-weight:600;margin-right:8px}.flow-editor-layout{display:grid;grid-template-columns:minmax(0,1fr) 280px;gap:16px}.flow-canvas{min-width:0;border:1px solid #dfe5ed;border-radius:8px;overflow:hidden;background:#f8fafc}.flow-canvas-tools{padding:12px 14px;display:flex;align-items:center;justify-content:space-between;gap:10px;border-bottom:1px solid #e8ecf2;background:white;font-size:12px;color:#607087;flex-wrap:wrap}.flow-zoom{font-variant-numeric:tabular-nums;display:inline-block;width:36px;text-align:center}.flow-viewport{height:430px;overflow:auto;outline-offset:-3px;background-image:radial-gradient(#cfd7e4 1px,transparent 1px);background-size:16px 16px}.flow-board{position:relative;transform-origin:top left}.flow-edges{position:absolute;inset:0;pointer-events:none}.flow-edges text{font-size:12px;fill:#435371;paint-order:stroke;stroke:#f8fafc;stroke-width:5px}.flow-node{position:absolute;width:200px;height:104px;padding:12px 15px;border:1px solid #d9e0eb;border-radius:8px;background:white;box-shadow:0 2px 6px #2336540a;cursor:grab;touch-action:none;user-select:none;border-top:3px solid #7893ba}.flow-node:focus-visible{outline:3px solid #91caff;outline-offset:3px}.flow-node.selected{border-color:#1677ff;box-shadow:0 0 0 2px #1677ff20}.flow-node strong{display:block;font-size:15px;margin:7px 0 5px;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.flow-node small{font-size:11px;color:#6b7890;display:block;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.flow-node-top{display:flex;align-items:center;justify-content:space-between;font-size:11px}.flow-node-kind{font-weight:600;color:#456287}.flow-lock{color:#62768c;background:#f0f4fa;padding:1px 5px;border-radius:3px}.kind-human{border-top-color:#b59661}.kind-agent,.kind-verify{border-top-color:#597ef7}.kind-branch,.kind-loop{border-top-color:#8a74cf}.kind-publish,.kind-archive{border-top-color:#4b9b81}.flow-canvas-hint{border-top:1px solid #e8ecf2;padding:10px 14px;color:#69758b;font-size:12px;background:white}.flow-properties{border:1px solid #e2e7ef;border-radius:8px;padding:18px;background:white;min-width:0}.flow-properties h2{font-size:15px;margin:0 0 16px}.flow-prop-title{display:flex;justify-content:space-between;gap:8px}.flow-properties h3{font-size:13px;border-top:1px solid #edf0f4;padding-top:16px;margin-top:14px}.flow-properties .ant-form-item{margin-bottom:14px}.flow-properties>.ant-select{width:100%;margin-bottom:8px}.flow-properties>button{margin-bottom:8px}.flow-properties .muted{font-size:12px;line-height:1.7}.flow-connection{display:flex;align-items:center;justify-content:space-between;padding:3px 4px 3px 10px;background:#f7f9fc;border-radius:4px;margin-bottom:6px;gap:8px;font-size:12px}.flow-checks{margin-top:20px}.flow-check{display:flex;gap:12px;align-items:flex-start;border-bottom:1px solid #edf0f4;padding:14px 0}.flow-check>div{flex:1;min-width:0}.flow-check p{margin:5px 0 0;color:#637087;font-size:13px}.flow-submit{background:white;border:1px solid #e2e7ef;border-radius:8px;padding:20px 24px;margin-top:20px;display:flex;gap:24px;align-items:flex-end}.flow-submit>div{flex:1;min-width:0}.flow-submit h2{font-size:16px;margin-top:0}.flow-version-tools{display:flex;justify-content:space-between;gap:10px;align-items:center;margin-bottom:16px;flex-wrap:wrap}.flow-version-history article{display:flex;align-items:center;gap:12px;padding:16px 0;border-bottom:1px solid #edf0f4;flex-wrap:wrap}.flow-version-history article span:not(.ant-tag){color:#77849a;font-size:12px;margin-left:auto}.flow-diff{background:#f7faff;border:1px solid #e0eaff;padding:16px 32px;border-radius:6px;max-height:280px;overflow:auto;font-size:13px;line-height:2}.flow-node-details dt{color:#7c889b;font-size:12px;margin-top:20px}.flow-node-details dd{margin:6px 0 0;overflow-wrap:anywhere}.flow-use{border:1px solid #e5eaf2;border-radius:6px;padding:18px;margin-top:16px}.flow-use.selected{border-color:#91caff;background:#fafcff}.flow-use p{font-size:13px}.flow-modal-actions{display:flex;justify-content:flex-end;margin-top:24px;flex-wrap:wrap}@media(min-width:1600px){.flow-viewport{height:500px}}@media(max-width:1100px){.flow-basics{grid-template-columns:1fr 1fr}.flow-editor-layout{grid-template-columns:minmax(0,1fr) 250px}.flow-canvas-tools .ant-space{gap:4px!important}}@media(max-width:800px){.flow-editor-layout{grid-template-columns:1fr}.flow-properties{max-height:none}.flow-properties .ant-form{display:grid;grid-template-columns:1fr 1fr;gap:0 16px}.flow-submit{flex-direction:column;align-items:stretch}.flow-version-tools{align-items:flex-start}.flow-viewport{height:370px}}@media(max-width:480px){.flow-basics{grid-template-columns:1fr;padding:16px}.flow-properties .ant-form{grid-template-columns:1fr}.flow-canvas-tools{padding:10px}.flow-canvas-tools>.ant-space{width:100%;justify-content:space-between}.flow-viewport{height:340px}.flow-submit{padding:16px}.flow-version-tools .ant-space{flex-wrap:wrap}.flow-palette{gap:6px}.flow-palette .ant-btn{font-size:12px}.flow-palette>span{width:100%}.flow-check{flex-wrap:wrap}.flow-version-history article strong{width:100%}}

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/admin-rules.test.js

@@ -0,0 +1,96 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { actors, can, inScope, metadata } from "../src/shared/policy.js";
+import { assertVersion, assertDelete, requestPublish, finishPublish, authorizedUse } from "../src/models/domain.js";
+import { newIntent, publishVersion, confirmVersion, beginConfirmation, reviseVersion, closeIntent, assertIntentAccess, replanIntent } from "../src/intents/domain.js";
+const at = '2026-09-10T10:00:00.000Z', admin = actors[0], reviewer = actors[1], owner = actors[2], engineer = actors[3], outsider = actors[5];
+function model() {
+    return { ...metadata(admin, at, 'platform'), id: 'test-model', name: '模型', alias: 'model-test', provider: '演示', kind: 'chat',
+        endpoint: 'https://example.invalid', credential: 'vault://demo', capabilities: ['文本'], inputPrice: 1, outputPrice: 2,
+        enabled: true, health: 'normal', projects: ['项目一'], agents: ['Agent一'], quota: 100, version: 2, testedVersion: 2,
+        liveVersion: 1, liveConfig: { name: '原名称' }, publishState: 'draft', references: [],
+        grants: [{ tenantId: 'heating', projects: ['项目一'], agents: ['Agent一'] }, { tenantId: 'north', projects: ['项目二'], agents: ['Agent二'] }] };
+}
+function intent() {
+    const draft = newIntent({ title: '报修分诊', request: '主管需要依据', outcome: '主管可核对后派单', context: '意图池' }, 'intent', 'INT-001', at, owner);
+    draft.answers = { audience: '主管', process: '核对后派单', boundary: '不控制设备', acceptance: '不重复派单' };
+    return publishVersion(draft, at);
+}
+test('identity, editing, confirmation and publishing are distinct permissions', () => {
+    assert.equal(can(admin, 'intent:confirm'), false);
+    assert.equal(can(engineer, 'intent:confirm'), false);
+    assert.equal(can(owner, 'model:grant'), false);
+    assert.equal(can(reviewer, 'model:edit'), false);
+    assert.equal(can(reviewer, 'model:publish'), true);
+    assert.equal(can(actors[6], 'intent:view'), false);
+    assert.equal(inScope(owner, 'north'), false);
+});
+test('model use cannot combine grants from different tenants or projects', () => {
+    const m = model();
+    assert.equal(authorizedUse(m, 'heating', '项目一', 'Agent一'), true);
+    assert.equal(authorizedUse(m, 'heating', '项目二', 'Agent二'), false);
+    assert.equal(authorizedUse(m, 'heating', '项目一', 'Agent二'), false);
+    assert.equal(authorizedUse({ ...m, enabled: false }, 'heating', '项目一', 'Agent一'), false);
+    assert.equal(authorizedUse({ ...m, liveVersion: undefined }, 'heating', '项目一', 'Agent一'), false);
+});
+test('deletion protects references, live use and review state', () => {
+    assert.throws(() => assertDelete(model()), /停用/);
+    assert.throws(() => assertDelete({ ...model(), enabled: false, references: [{ name: '流程', kind: '模板', version: 'v1' }] }), /引用/);
+    assert.throws(() => assertDelete({ ...model(), enabled: false, publishState: 'review' }), /评审/);
+    assert.doesNotThrow(() => assertDelete({ ...model(), enabled: false }));
+});
+test('model stale edits and tests do not qualify for publication', () => {
+    assert.throws(() => assertVersion(model(), 2), /版本已变化/);
+    assert.throws(() => requestPublish({ ...model(), testedVersion: 1 }, admin.id, admin.name), /测试/);
+});
+test('publication requires another reviewer and retains the old live configuration on failure', () => {
+    const m = requestPublish(model(), admin.id, admin.name);
+    assert.throws(() => finishPublish(m, admin.id, admin.name, at, true, true, '同意'), /另一位/);
+    assert.throws(() => finishPublish(m, reviewer.id, reviewer.name, at, true, true, ''), /评审意见/);
+    const failed = finishPublish(m, reviewer.id, reviewer.name, at, true, false, '同意');
+    assert.equal(failed.publishState, 'failed');
+    assert.equal(failed.liveVersion, 1);
+    assert.equal(failed.liveConfig?.name, '原名称');
+    const approved = finishPublish(m, reviewer.id, reviewer.name, at, true, true, '同意');
+    assert.equal(approved.liveVersion, 2);
+    assert.equal(approved.liveConfig?.name, '模型');
+    assert.equal(model().liveVersion, 1);
+});
+test('filled clarification fields do not resolve independent open decisions', () => {
+    const m = intent();
+    m.decisions = [{ id: 'd1', question: '谁复核？', answer: '' }];
+    const candidate = reviseVersion(m, m, m.answers, at, m.decisions);
+    assert.throws(() => confirmVersion(candidate, 2, at, owner), /未决问题/);
+    const next = reviseVersion(candidate, candidate, candidate.answers, at, [{ id: 'd1', question: '谁复核？', answer: '主管', resolvedBy: owner.name, resolvedAt: at }]);
+    assert.equal(confirmVersion(next, 3, at, owner).status, 'confirmed');
+    assert.equal(candidate.versions[1]?.decisions[0]?.answer, '');
+});
+test('intent confirmation enforces action permission, tenant and object version', () => {
+    assert.throws(() => confirmVersion(intent(), 1, at, admin), /权限/);
+    assert.throws(() => confirmVersion(intent(), 1, at, engineer), /权限/);
+    assert.throws(() => confirmVersion(intent(), 1, at, outsider), /权限/);
+    assert.throws(() => assertIntentAccess(intent(), owner, 'intent:edit', 0), /记录已被更新/);
+    assert.equal(confirmVersion(intent(), 1, at, owner).versions[0]?.confirmedBy, owner.name);
+});
+test('pending and unknown confirmation requests block resubmission and edits', () => {
+    const pending = beginConfirmation(intent(), 1, at, owner, 'request-1');
+    for (const confirmation of ['pending', 'unknown']) {
+        const record = { ...pending, confirmation };
+        assert.throws(() => beginConfirmation(record, 1, at, owner, 'request-2'), /核实结果/);
+        assert.throws(() => reviseVersion(record, record, record.answers, at), /核实结果/);
+        assert.throws(() => closeIntent(record, '取消', at, owner), /核实结果/);
+    }
+    const confirmed = confirmVersion(pending, 1, at, owner);
+    assert.equal(confirmed.pendingConfirmation, undefined);
+    assert.throws(() => confirmVersion(confirmed, 1, at, owner), /版本已变化/);
+});
+test('closure retains the document and versions and rejects further writes', () => {
+    assert.throws(() => closeIntent(intent(), ' ', at, owner), /关闭原因/);
+    assert.throws(() => closeIntent(confirmVersion(intent(), 1, at, owner), '取消', at, owner), /确认基线/);
+    const closed = closeIntent(intent(), '需求撤回', at, owner);
+    assert.equal(closed.status, 'closed');
+    assert.equal(closed.versions.length, 1);
+    assert.equal(closed.closedBy, owner.name);
+    assert.throws(() => replanIntent(closed, ['boundary'], '调整', at), /已关闭/);
+    assert.throws(() => reviseVersion(closed, closed, closed.answers, at), /已关闭/);
+});

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/agents.test.js

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { checkConfiguration, assertRemovable, validateBasics } from "../src/agents/domain.js";
+import { actors, metadata, can } from "../src/shared/policy.js";
+const a = { ...metadata(actors[0], '2026-09-10T10:00:00Z', 'heating'), id: 'one', grantKey: 'one', name: '需求规划', code: 'demand-planner', description: '', duty: 'planner', pbcId: 'pbc-0', project: '供热工单', modelRef: 'm', promptRef: 'p', skillRefs: ['s'], tools: [{ type: 'MCP', ref: 't' }], memoryLimit: 40, toolLimit: 10, enabled: false, references: [] };
+const resources = [{ id: 'p', kind: 'prompt', name: '预设', version: 'v1', state: 'ready', tenantIds: ['*'], description: '', content: '' }, { id: 's', kind: 'skill', name: '技能', version: 'v1', state: 'ready', tenantIds: ['heating'], description: '', content: '' }, { id: 't', kind: 'tool', type: 'MCP', name: '只读工具', version: 'v1', state: 'ready', tenantIds: ['*'], description: '', content: '', allow: ['read_file'] }];
+const model = { id: 'm', name: '对话模型', version: 1, enabled: true, kind: 'chat', capabilities: ['工具调用'], authorized: true, deleted: false };
+test('完整四要素可用；停用、未发布与向量模型不能启用', () => { assert.ok(checkConfiguration(a, [model], resources).every(c => c.ok)); for (const change of [{ enabled: false }, { version: undefined }, { kind: 'embedding' }, { deleted: true }])
+    assert.equal(checkConfiguration(a, [{ ...model, ...change }], resources)[0].ok, false); });
+test('编辑权限不能代替模型资源使用授权', () => { assert.equal(can(actors[3], 'agent:edit', 'heating', 'pbc-0'), true); assert.equal(checkConfiguration(a, [{ ...model, authorized: false }], resources).find(c => c.key === 'grant').ok, false); });
+test('跨租户、失效资源与工具类型不符阻断引用', () => { assert.equal(checkConfiguration({ ...a, tenantId: 'north' }, [model], resources).find(c => c.key === 'skills').ok, false); assert.equal(checkConfiguration(a, [model], resources.filter(r => r.id !== 'p')).find(c => c.key === 'prompt').ok, false); assert.equal(checkConfiguration({ ...a, tools: [{ type: 'HTTP', ref: 't' }] }, [model], resources).find(c => c.key === 'tools').ok, false); });
+test('白名单过宽、能力不符及无上限配置被拒绝', () => { assert.equal(checkConfiguration(a, [model], resources.map(r => r.kind === 'tool' ? { ...r, allow: ['*'] } : r)).find(c => c.key === 'tools').ok, false); assert.equal(checkConfiguration(a, [{ ...model, capabilities: [] }], resources).find(c => c.key === 'capability').ok, false); assert.throws(() => validateBasics({ ...a, toolLimit: 0 }), /上限/); assert.throws(() => validateBasics({ ...a, memoryLimit: NaN }), /记忆/); });
+test('技能与工具可选；未绑定工具不要求工具调用能力', () => { const r = checkConfiguration({ ...a, skillRefs: [], tools: [] }, [{ ...model, capabilities: [] }], resources); assert.ok(r.every(c => c.ok)); });
+test('删除保护启用及引用对象，停用无引用草稿可删', () => { assert.throws(() => assertRemovable({ ...a, enabled: true }), /停用/); assert.throws(() => assertRemovable({ ...a, references: [{ name: '流程', version: 'v1' }] }), /引用/); assert.doesNotThrow(() => assertRemovable(a)); assert.throws(() => validateBasics({ ...a, code: 'Bad code' }), /标识/); });

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/intent-state.test.js

@@ -0,0 +1,37 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { newIntent, publishVersion, reviseVersion, confirmVersion, replanIntent, lastVersion } from "../src/intents/domain.js";
+const at = '2026-09-09T10:00:00Z';
+const input = { title: '测试意图', request: '为业务人员提供可查询的工单进度', context: '集团意图池' };
+const answers = { audience: '业务人员', process: '查询并确认', boundary: '只读授权数据', acceptance: '结果可追溯' };
+function ready() { return publishVersion({ ...newIntent(input, 'i1', 'INT-001', at), answers }, at); }
+test('unresolved intent cannot generate a reviewable version', () => { assert.throws(() => publishVersion(newIntent(input, 'i1', 'INT-001', at), at), /补充/); });
+test('confirmation binds the displayed version and rejects a stale version', () => {
+    assert.throws(() => confirmVersion(ready(), 2, at), /版本已变化/);
+    assert.equal(confirmVersion(ready(), 1, at).status, 'confirmed');
+});
+test('editing makes a new unconfirmed version without altering the confirmed snapshot', () => {
+    const old = confirmVersion(ready(), 1, at);
+    const revised = reviseVersion(old, input, { ...answers, process: '主管确认后派单' }, at);
+    assert.equal(revised.status, 'ready');
+    assert.equal(lastVersion(revised)?.number, 2);
+    assert.equal(revised.versions[0]?.answers.process, '查询并确认');
+    assert.ok(revised.versions[0]?.confirmedAt);
+    assert.equal(lastVersion(revised)?.confirmedAt, undefined);
+    assert.equal(old.versions.length, 1);
+});
+test('replanning clears only selected answers and preserves confirmation history', () => {
+    const old = confirmVersion(ready(), 1, at);
+    const reopened = replanIntent(old, ['boundary'], '补充权限边界', at);
+    assert.equal(reopened.answers.boundary, '');
+    assert.equal(reopened.answers.audience, answers.audience);
+    assert.equal(reopened.status, 'clarifying');
+    assert.ok(reopened.versions[0]?.confirmedAt);
+    assert.throws(() => confirmVersion(reopened, 1, at), /版本已变化/);
+    assert.throws(() => publishVersion(reopened, at), /补充/);
+});
+test('changed content cannot borrow an older confirmation candidate', () => {
+    const candidate = ready();
+    candidate.answers = { ...answers, process: '不同内容' };
+    assert.throws(() => confirmVersion(candidate, 1, at), /内容已经变化/);
+});

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/list-batch.test.js

@@ -0,0 +1,44 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { assertBatch } from "../src/shared/listBatch.js";
+import { actors, can } from "../src/shared/policy.js";
+import { newIntent, assertIntentAccess, assertIntentDelete, publishVersion, confirmVersion, reviseVersion } from "../src/intents/domain.js";
+const owner = actors[2], admin = actors[0], at = '2026-09-10T15:00:00Z';
+const draft = (id = 'draft') => newIntent({ title: id, request: '业务描述', context: '意图池' }, id, 'INT-001', at, owner);
+const target = (i) => ({ id: i.id, name: i.title, recordVersion: i.recordVersion });
+const check = (i) => { assertIntentAccess(i, owner, 'intent:delete'); assertIntentDelete(i); };
+test('batch validates every target before a caller can commit', () => {
+    const first = draft('first'), stale = draft('stale'), records = [first, stale], snapshot = JSON.stringify(records);
+    assert.throws(() => assertBatch(records, [target(first), { ...target(stale), recordVersion: 0 }], check), /已被更新/);
+    assert.equal(JSON.stringify(records), snapshot);
+    assert.deepEqual(assertBatch(records, records.map(target), check).map(i => i.id), ['first', 'stale']);
+});
+test('empty, duplicated, missing and already deleted targets are rejected', () => {
+    const i = draft();
+    assert.throws(() => assertBatch([i], [], check), /至少/);
+    assert.throws(() => assertBatch([i], [target(i), target(i)], check), /重复/);
+    assert.throws(() => assertBatch([], [target(i)], check), /不存在/);
+    assert.throws(() => assertBatch([{ ...i, isDeleted: true }], [target(i)], check), /不存在/);
+});
+test('delete permission is separate from edit and respects the tenant boundary', () => {
+    assert.equal(can(actors[3], 'intent:edit'), true);
+    assert.equal(can(actors[3], 'intent:delete'), false);
+    assert.equal(can(admin, 'intent:delete'), true);
+    assert.equal(can(owner, 'intent:delete'), true);
+    assert.throws(() => assertIntentAccess(draft(), actors[3], 'intent:delete'), /权限/);
+    assert.throws(() => assertIntentAccess(draft(), actors[5], 'intent:delete'), /权限/);
+});
+test('confirmed history stays protected after later revisions', () => {
+    const i = draft();
+    i.answers = { audience: '业务人员', process: '处理工单', boundary: '本租户', acceptance: '可追溯' };
+    const confirmed = confirmVersion(publishVersion(i, at), 1, at, owner);
+    const revised = reviseVersion(confirmed, confirmed, confirmed.answers, at);
+    assert.equal(revised.status, 'ready');
+    assert.throws(() => assertIntentDelete(revised), /已确认版本/);
+});
+test('generation and uncertain confirmation cannot be deleted', () => {
+    assert.throws(() => assertIntentDelete({ ...draft(), generating: true }), /正在整理/);
+    for (const confirmation of ['pending', 'unknown'])
+        assert.throws(() => assertIntentDelete({ ...draft(), confirmation }), /核实/);
+    assert.doesNotThrow(() => assertIntentDelete({ ...draft(), status: 'closed' }));
+});

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/operation-fixtures.js

@@ -0,0 +1,19 @@
+import { actors } from "../src/shared/policy.js";
+import { standardBody } from "../src/workflows/data.js";
+import { newTask, startTask, advanceTask, approveTask, clone } from "../src/tasks/domain.js";
+import { retainReviews } from "../src/reviews/model.js";
+import { createRelease, sourceKey } from "../src/releases/model.js";
+import { applyRelease } from "../src/releases/commands.js";
+export const actor = actors[0];
+const binding = () => ({ intentId: 'intent', spec: { number: 1, source: { intentId: 'intent', code: 'INT-1', title: '发布测试', version: 1, confirmedAt: '2026-09-14' }, content: { overview: '需求', stories: '故事', requirements: 'FR-001', acceptance: 'AC-001', success: '标准', entities: '实体', pages: '页面', assumptions: '假设' }, decisions: [], reason: '确认样例', createdBy: '演示', createdAt: '2026-09-14', confirmedBy: '演示', confirmedAt: '2026-09-14' }, specRecordVersion: 1, pbcId: 'pbc-0', project: '供热工单', tenantId: 'heating', flowId: 'flow-0', flowRecordVersion: 1, flow: { number: 1, body: standardBody(), note: '标准', by: '演示', at: '2026-09-14', submittedBy: '演示' }, agents: [] });
+export function ready(grade = 'A') { const t = newTask(binding(), actor, '发布测试'); t.reviewPolicy = { grade, humanQuality: grade !== 'A', reason: '明确的测试策略' }; startTask(t, '测试'); advanceTask(t); approveTask(t, '测试', 1, '测试中确认原型'); for (let i = 0; i < 3; i++) {
+    const old = clone(t);
+    advanceTask(t);
+    retainReviews(old, t);
+} return t; }
+export const input = () => ({ name: '智能分诊首次发布', version: '1.0.0', environment: 'production', config: 'config-v1', description: '上线本次智能分诊功能', traffic: 10, errorLimit: 1, latencyLimit: 800, rollbackPlan: '异常时回退批准的稳定版本；首发停止并撤流。' });
+export function materials(t) { return { sourceKey: sourceKey(t), commit: 'demo-commit-a1', digest: 'sha256:demo-a1', config: 'config-v1', checks: ['merge', 'build', 'functional', 'contract', 'eval', 'security', 'migration'].map(id => ({ id, name: id, status: 'pass', detail: '测试用模拟证据' })), migration: 'none', rollback: { version: '0.9.0', digest: 'sha256:demo-old', config: 'config-old', environment: 'production' }, by: '独立CI（模拟）', at: '2026-09-14' }; }
+export function publishedTask(id = 'ops-task') { const t = ready(); t.id = id; t.code = 'DEL-' + id; t.name = '供热智能分诊'; t.releaseMaterials = materials(t); createRelease(t, actor, input(), 'release-' + id); for (const [i, action] of ['check', 'submit', 'approve', 'start', 'advance', 'advance', 'advance'].entries()) {
+    const r = t.releases[0];
+    applyRelease(t, r.id, actor, { id: id + '-' + i, action, expected: r.recordVersion, note: '测试中的模拟批准', checked: true });
+} return t; }

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/operation-repair.test.js

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { actor, publishedTask } from "./operation-fixtures.js";
+import { runsForTask, incidentLabel } from "../src/operations/model.js";
+import { applyOperation } from "../src/operations/commands.js";
+import { linkRepairIntent, repairCandidates, closureReason } from "../src/operations/repair.js";
+import { assertIntentDelete } from "../src/intents/domain.js";
+const setup = () => { const t = publishedTask(); let r = runsForTask(t)[0]; let n = 0; const apply = (action, extra = {}) => { r = applyOperation(t, r.id, actor, { id: 'c' + (++n), action, expected: r.recordVersion, note: '核对证据', checked: true, ...extra }); return r; }; apply('observe', { outcome: 'fail' }); return { t, get r() { return runsForTask(t)[0]; }, apply }; };
+test('调查失败不能编造根因；分诊需要完整调查，驳回保留历史', () => { const s = setup(), id = s.r.incidents[0].id; s.apply('diagnose', { incidentId: id, outcome: 'missing' }); assert.equal(s.r.incidents[0].reports[0].status, 'incomplete'); assert.throws(() => s.apply('triageNow', { incidentId: id }), /调查/); s.apply('diagnose', { incidentId: id }); s.apply('triageReject', { incidentId: id }); assert.equal(incidentLabel(s.r.incidents[0]), '已驳回'); assert.equal(s.r.incidents[0].reports.length, 2); assert.throws(() => s.apply('diagnose', { incidentId: id }), /结束/); });
+test('新修复需求保持草稿，保留异常来源，同一异常禁止重复创建且禁止删除来源链', () => { const s = setup(), id = s.r.incidents[0].id; s.apply('diagnose', { incidentId: id }); s.apply('triageNow', { incidentId: id }); const i = linkRepairIntent([], s.t, s.r, id, actor, { id: 'link1', note: '修复工具超时' }); assert.equal(i.status, 'draft'); assert.equal(i.versions.length, 0); assert.equal(i.operationLinks?.[0]?.pbcId, s.r.source.pbcId); assert.throws(() => assertIntentDelete(i), /运行异常/); assert.equal(linkRepairIntent([i], s.t, s.r, id, actor, { id: 'link1', note: '修复工具超时' }).id, i.id); assert.throws(() => linkRepairIntent([i], s.t, s.r, id, actor, { id: 'link2', note: '修复工具超时' }), /已经关联/); assert.throws(() => linkRepairIntent([], s.t, s.r, id, { ...actor, grants: [] }, { id: 'x', note: 'xx' }), /权限/); });
+test('创建需求并不关闭异常；新发布、回归、人工验收和当前版本缺一不可', () => { const s = setup(), id = s.r.incidents[0].id; s.apply('diagnose', { incidentId: id }); s.apply('triageNow', { incidentId: id }); const i = linkRepairIntent([], s.t, s.r, id, actor, { id: 'link1', note: '修复' }); assert.match(closureReason(s.r, s.r.incidents[0], [i], [s.t], actor), /修复版本/); const t = publishedTask('repair'); t.binding.intentId = i.id; t.createdAt = new Date(Date.now() + 500).toISOString(); t.releases[0].versions[0].version = '1.0.1'; t.releases[0].finishedAt = new Date(Date.now() + 1000).toISOString(); let r = runsForTask(t)[0]; const c = () => repairCandidates(s.r.incidents[0], [i], [s.t, t], actor)[0]; assert.match(closureReason(s.r, s.r.incidents[0], [i], [s.t, t], actor, c()), /验收|证据/); r = applyOperation(t, r.id, actor, { id: 'observe', action: 'observe', expected: r.recordVersion, note: '回归', outcome: 'pass' }); r = applyOperation(t, r.id, actor, { id: 'accept', action: 'accept', expected: r.recordVersion, note: '验证', checked: true }); assert.equal(closureReason(s.r, s.r.incidents[0], [i], [s.t, t], actor, c()), ''); const stale = c(); applyOperation(t, r.id, actor, { id: 'new', action: 'observe', expected: r.recordVersion, note: '新观测', outcome: 'fail' }); assert.match(closureReason(s.r, s.r.incidents[0], [i], [s.t, t], actor, stale), /变化|证据|验收/); });
+import { operationTodos } from "../src/operations/workbench.js";
+test('关闭绑定已验收的新版本，旧运行记录转历史且不留下旧验收待办', () => { const s = setup(), id = s.r.incidents[0].id; s.apply('diagnose', { incidentId: id }); s.apply('triageNow', { incidentId: id }); const i = linkRepairIntent([], s.t, s.r, id, actor, { id: 'close-link', note: '修复' }); const t = publishedTask('closing'); t.binding.intentId = i.id; t.createdAt = new Date(Date.now() + 1000).toISOString(); t.releases[0].finishedAt = new Date(Date.now() + 2000).toISOString(); t.releases[0].versions[0].version = '1.0.1'; let r = runsForTask(t)[0]; r = applyOperation(t, r.id, actor, { id: 'reg', action: 'observe', expected: r.recordVersion, note: '回归' }); applyOperation(t, r.id, actor, { id: 'accept', action: 'accept', expected: r.recordVersion, note: '验收', checked: true }); const target = repairCandidates(s.r.incidents[0], [i], [s.t, t], actor)[0]; const closed = applyOperation(s.t, s.r.id, actor, { id: 'close', action: 'closeIncident', incidentId: id, expected: s.r.recordVersion, note: '完成', checked: true, target }, { tasks: [s.t, t], intents: [i] }); assert.equal(closed.supersededBy?.runId, target.runId); assert.equal(operationTodos([s.t, t], actor, true).length, 0); assert.equal(closed.observations[0].health, 'abnormal'); });
+test('已有需求关联校验租户和结束状态，未知关联阻断关闭；重复分诊保留版本依据', () => { const s = setup(), id = s.r.incidents[0].id; s.apply('diagnose', { incidentId: id }); s.apply('triageNow', { incidentId: id }); s.apply('triagePlan', { incidentId: id }); assert.equal(s.r.incidents[0].triageHistory?.length, 2); const i = linkRepairIntent([], s.t, s.r, id, actor, { id: 'old', note: '保存', unknown: true }); assert.match(closureReason(s.r, s.r.incidents[0], [i], [s.t], actor), /核实/); const target = { ...i, id: 'existing', operationLinks: [], tenantId: 'ifm' }; assert.throws(() => linkRepairIntent([target], s.t, s.r, id, actor, { id: 'cross', note: '关联', targetId: target.id }), /租户/); target.tenantId = s.r.tenantId; target.status = 'closed'; assert.throws(() => linkRepairIntent([target], s.t, s.r, id, actor, { id: 'closed', note: '关联', targetId: target.id }), /结束/); });

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/operations.test.js

@@ -0,0 +1,25 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { actor, publishedTask } from "./operation-fixtures.js";
+import { clone } from "../src/tasks/domain.js";
+import { runsForTask, acceptanceLabel, healthLabel, operationReason } from "../src/operations/model.js";
+import { applyOperation } from "../src/operations/commands.js";
+let seq = 0;
+const run = (t) => runsForTask(t)[0];
+function act(t, action, more = {}) { return applyOperation(t, run(t).id, actor, { id: 'op-' + (++seq), action, expected: run(t).recordVersion, note: '已核对当前证据', checked: true, ...more }); }
+test('仅已核实成功的生产发布派生运行记录；缺证据仍待验收', () => { const t = publishedTask(); assert.equal(runsForTask(t).length, 1); assert.equal(acceptanceLabel(run(t)), '待验收'); assert.equal(healthLabel(run(t)), '数据待提供'); for (const state of ['failed', 'deploying']) {
+    t.releases[0].state = state;
+    assert.equal(runsForTask(t).length, 0);
+} t.releases[0].state = 'succeeded'; t.releases[0].unconfirmed = 'pending'; assert.equal(runsForTask(t).length, 0); t.releases[0].unconfirmed = undefined; t.releases[0].versions[0].environment = 'staging'; assert.equal(runsForTask(t).length, 0); });
+test('观测健康不自动验收；缺失、失败、过期证据不得通过', () => { for (const outcome of ['missing', 'fail', 'stale']) {
+    const t = publishedTask();
+    act(t, 'observe', { outcome });
+    assert.equal(acceptanceLabel(run(t)), '待验收');
+    assert.throws(() => act(t, 'accept'), /证据/);
+} const t = publishedTask(); act(t, 'observe', { outcome: 'pass' }); assert.equal(healthLabel(run(t)), '运行正常'); assert.equal(acceptanceLabel(run(t)), '待验收'); });
+test('人工验收绑定证据版本及实际人，空说明或未勾选不能通过', () => { const t = publishedTask(); act(t, 'observe', { outcome: 'pass' }); assert.throws(() => act(t, 'accept', { checked: false }), /核对/); assert.throws(() => act(t, 'accept', { note: '' }), /说明/); act(t, 'accept'); assert.equal(run(t).acceptances[0].evidenceVersion, 1); assert.equal(run(t).acceptances[0].actorId, actor.id); assert.equal(acceptanceLabel(run(t)), '验收通过'); });
+test('观察异常保留之前验收和证据，不抹掉历史结论', () => { const t = publishedTask(); act(t, 'observe', { outcome: 'pass' }); act(t, 'accept'); const previous = clone(run(t).acceptances); act(t, 'observe', { outcome: 'fail' }); assert.deepEqual(run(t).acceptances, previous); assert.equal(healthLabel(run(t)), '运行异常'); assert.equal(run(t).observations.length, 2); assert.equal(run(t).incidents.length, 1); act(t, 'observe', { outcome: 'fail' }); assert.equal(run(t).incidents.length, 1); });
+test('无动作/环境权限和旧记录版本不能提交；源发布变化后仍保留历史', () => { const t = publishedTask(), r = run(t); assert.match(operationReason(t, r, { ...actor, grants: [] }, 'observe'), /权限/); const restricted = { ...actor, grants: actor.grants.map(g => ({ ...g, environmentIds: ['staging'] })) }; assert.match(operationReason(t, r, restricted, 'accept'), /权限/); act(t, 'observe'); assert.throws(() => act(t, 'accept', { expected: r.recordVersion }), /版本/); t.releases[0].state = 'stopped'; assert.equal(runsForTask(t).length, 1); assert.match(operationReason(t, run(t), actor, 'accept'), /发布|撤流/); });
+test('未知响应先核实原请求；同编号重放不产生重复事件或验收', () => { const t = publishedTask(); act(t, 'observe', { outcome: 'pass' }); const c = { id: 'same-accept', action: 'accept', expected: run(t).recordVersion, note: '测试核对', checked: true, unknown: true }; applyOperation(t, run(t).id, actor, c); const snapshot = clone(run(t)); applyOperation(t, run(t).id, actor, c); assert.deepEqual(run(t), snapshot); assert.equal(acceptanceLabel(run(t)), '结果待核实'); assert.throws(() => act(t, 'observe'), /回执/); act(t, 'verify'); assert.equal(acceptanceLabel(run(t)), '验收通过'); assert.equal(run(t).acceptances.length, 1); });
+import { operationTodos } from "../src/operations/workbench.js";
+test('工作台验收后移除运行待办，后续异常独立保留，不重复统计相同对象', () => { const t = publishedTask(); assert.equal(operationTodos([t], actor, true).length, 1); act(t, 'observe'); act(t, 'accept'); assert.equal(operationTodos([t], actor, true).length, 0); act(t, 'observe', { outcome: 'fail' }); const todos = operationTodos([t], actor, true); assert.equal(todos.length, 1); assert.match(todos[0].id, /incident:/); assert.equal(operationTodos([t], { ...actor, grants: [] }, true).length, 0); assert.equal(operationTodos([t], actor, false)[0].allowed, false); });

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/pbc-management.test.js

@@ -0,0 +1,17 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { metadata } from "../src/shared/policy.js";
+import { revisePbc, reviseService, assertPbcRemovable, assertServiceRemovable, assertActive, requireReason } from "../src/pbc/management.js";
+import { assertBatch } from "../src/shared/listBatch.js";
+const actor = { id: 'a', name: '甲', department: '研发', role: '任意', tenantId: 'heating', label: '成员', grants: [] }, at = '2026-09-11T00:00:00Z';
+const pbc = () => ({ ...metadata(actor, at), id: 'p', name: '工单', slug: 'workorder', ebc: '服务', domain: 'example.test', owner: '甲', services: [], state: 'active', provisioned: false });
+const patch = { name: '工单新版', ebc: '客户服务', owner: '乙', description: '职责边界' };
+const service = { name: 'dispatch', title: '派单服务', template: 'java', purpose: '处理已确认派单', sourceIntentId: '' };
+test('修改仅更新允许字段，审计与授权别名不随名称变更', () => { const p = pbc(), n = revisePbc(p, patch, actor, at); assert.equal(n.resourceKey, '工单'); assert.equal(n.tenantId, p.tenantId); assert.equal(n.createdBy, p.createdBy); assert.equal(n.recordVersion, 2); assert.equal(p.name, '工单'); assert.equal(revisePbc(n, { ...patch, name: '第三版' }, actor, at).resourceKey, '工单'); });
+test('空字段、超长和归档禁止修改', () => { assert.throws(() => revisePbc(pbc(), { ...patch, name: ' ' }, actor, at)); assert.throws(() => revisePbc(pbc(), { ...patch, owner: 'x'.repeat(61) }, actor, at)); assert.throws(() => revisePbc({ ...pbc(), state: 'archived' }, patch, actor, at), /归档/); });
+test('删除需归档并且无工程、服务和引用', () => { const p = { ...pbc(), state: 'archived' }; assert.doesNotThrow(() => assertPbcRemovable(p, [])); assert.throws(() => assertPbcRemovable(pbc(), []), /归档/); assert.throws(() => assertPbcRemovable({ ...p, provisioned: true }, []), /工程/); assert.throws(() => assertPbcRemovable(p, ['task']), /引用/); assert.throws(() => assertPbcRemovable({ ...p, services: [reviseService(pbc(), undefined, service, actor, at)] }, []), /服务/); });
+test('批次拒绝重复、过期、已删除与混合不合法项', () => { const p = { ...pbc(), state: 'archived' }, q = { ...p, id: 'q', provisioned: true }; assert.throws(() => assertBatch([p, q], [{ ...p }, { ...q }], r => assertPbcRemovable(r, [])), /工程/); assert.equal(p.isDeleted, false); assert.throws(() => assertBatch([p], [{ ...p, recordVersion: 0 }], () => { }), /更新/); assert.throws(() => assertBatch([p], [{ ...p }, { ...p }], () => { }), /重复/); });
+test('新增服务仅为未登记的方案，保留审计字段', () => { const s = reviseService(pbc(), undefined, service, actor, at); assert.equal(s.registered, false); assert.equal(s.tenantId, 'heating'); assert.equal(s.purpose, service.purpose); assert.equal(s.recordVersion, 1); });
+test('服务重复标识、模板及格式校验', () => { const p = pbc(), s = reviseService(p, undefined, service, actor, at); p.services = [s]; assert.throws(() => reviseService(p, undefined, service, actor, at), /重复/); assert.throws(() => reviseService(p, undefined, { ...service, name: 'INVALID' }, actor, at)); assert.throws(() => reviseService(p, undefined, { ...service, template: 'random' }, actor, at)); });
+test('已登记服务不能改身份或删除，可维护职责', () => { const p = pbc(), s = { ...reviseService(p, undefined, service, actor, at), registered: true }; assert.throws(() => reviseService(p, s, { ...service, name: 'new' }, actor, at), /不可修改/); assert.throws(() => assertServiceRemovable(p, s), /不可在此删除/); assert.equal(reviseService(p, s, { ...service, title: '派单与通知' }, actor, at).title, '派单与通知'); });
+test('归档和删除对象拒绝新增使用；原因不能为空', () => { assert.throws(() => assertActive({ ...pbc(), state: 'archived' })); assert.throws(() => assertActive({ ...pbc(), isDeleted: true })); assert.throws(() => requireReason(' ')); assert.throws(() => requireReason('x'.repeat(501))); assert.doesNotThrow(() => requireReason('范围已核对')); });

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/pbc-state.test.js

@@ -0,0 +1,24 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { actors, can } from "../src/shared/policy.js";
+import { newIntent, publishVersion, confirmVersion } from "../src/intents/domain.js";
+import { newSpec, appendVersion, beginSpecConfirmation, completeSpecConfirmation, sections } from "../src/specs/domain.js";
+import { newDraft, validateDraft, makeJob, queryReceipt, activeStep, assertBinding } from "../src/pbc/domain.js";
+const actor = actors.at(-1), at = '2026-09-10T09:00:00.000Z';
+function fixture() {
+    let i = newIntent({ title: '需求', request: '处理请求', outcome: '可确认结果', context: '意图池' }, 'test', 'INT-1', at, actor);
+    i.answers = { audience: '有权人员', process: '核实后确认', boundary: '隔离资源', acceptance: '不重复执行' };
+    i = confirmVersion(publishVersion(i, at), 1, at, actor);
+    let s = appendVersion(newSpec(i, actor, at), { intentId: i.id, code: i.code, title: i.title, version: 1, confirmedAt: at }, Object.fromEntries(sections.map(k => [k.key, '内容'])), [], '首次', actor, at);
+    s = beginSpecConfirmation(s, i, actor, 1, s.recordVersion, 'request', at);
+    s.pending.acceptedAt = at;
+    s = completeSpecConfirmation(s);
+    const d = newDraft(i, actor, at), p = { ...d, id: 'pbc-' + d.slug };
+    return { i, s, d, p };
+}
+test('PBC 创建校验服务、唯一标识、域名与应用长度', () => { const { d, p } = fixture(); assert.doesNotThrow(() => validateDraft(d, [])); assert.throws(() => validateDraft({ ...d, services: [] }, []), /至少/); assert.throws(() => validateDraft({ ...d, services: [d.services[0], d.services[0]] }, []), /重复/); assert.throws(() => validateDraft(d, [p]), /已被使用/); assert.throws(() => validateDraft({ ...d, domain: 'invalid' }, []), /域名/); assert.throws(() => validateDraft({ ...d, slug: 'invalid_slug' }, []), /标识/); assert.doesNotThrow(() => validateDraft({ ...d, slug: '' }, [], 0)); });
+test('同一用户确认规格并创建 PBC，旧版本不会被新草稿回改', () => { const { i, s, d, p } = fixture(); const j = makeJob(i, s, actor, p, d); assert.equal(j.createdById, s.versions[0].confirmedBy === actor.name ? actor.id : ''); assert.equal(j.steps.length, 6); d.name = '修改原对象'; assert.notEqual(j.draft.name, d.name); s.versions[0].content.overview = 'later'; assert.notEqual(j.spec.content.overview, 'later'); });
+test('未确认规格、来源变化与跨租户拒绝归属', () => { const { i, s, p } = fixture(); assert.throws(() => makeJob(i, { ...s, versions: s.versions.map(v => ({ ...v, confirmedAt: undefined })) }, actor, p), /确认/); assert.throws(() => makeJob({ ...i, status: 'ready' }, s, actor, p), /意图/); assert.throws(() => makeJob(i, s, actor, { ...p, tenantId: 'north' }), /范围/); const limited = { ...actor, grants: [{ id: 'view', name: '查看', actions: ['pbc:view'], tenantIds: ['heating'] }] }; assert.throws(() => makeJob(i, s, limited, p), /权限/); });
+test('PBC 范围与动作在同一授权组匹配，不跨组拼接', () => { const scoped = { ...actor, grants: [{ id: 'a', name: '甲', actions: ['pbc:view', 'pbc:link'], tenantIds: ['heating'], pbcIds: ['pbc-0'] }, { id: 'b', name: '乙', actions: ['pbc:view'], tenantIds: ['heating'], pbcIds: ['pbc-1'] }] }; assert.equal(can(scoped, 'pbc:link', 'heating', 'pbc-0'), true); assert.equal(can(scoped, 'pbc:link', 'heating', 'pbc-1'), false); assert.equal(can(scoped, 'pbc:view', 'north', 'pbc-0'), false); });
+test('未知结果必须查询原回执，续接保留完成步骤和操作编号', () => { const { i, s, d, p } = fixture(), j = makeJob(i, s, actor, p, d); j.status = 'unknown'; j.steps[0].state = 'unknown'; j.steps[0].receipt = j.id + ':0'; const queried = queryReceipt(j); assert.equal(queried.id, j.id); assert.equal(queried.steps[0].state, 'done'); assert.equal(activeStep(queried), 1); assert.equal(j.steps[0].state, 'unknown'); const unaccepted = { ...j, steps: j.steps.map(step => ({ ...step, receipt: undefined })) }; assert.equal(queryReceipt(unaccepted).steps[0].state, 'waiting'); });
+test('归属复核绑定展示的精确版本，禁止静默换成更新的已确认规格', () => { const { i, s } = fixture(), binding = { specVersion: 1, recordVersion: s.recordVersion, sourceVersion: 1 }; assert.doesNotThrow(() => assertBinding(i, s, binding)); assert.throws(() => assertBinding(i, { ...s, recordVersion: s.recordVersion + 1 }, binding), /版本已变化/); assert.throws(() => assertBinding(i, s, { ...binding, specVersion: 2 }), /版本已变化/); assert.throws(() => assertBinding(i, s), /重新打开/); });

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/permission-config.test.js

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { actors, can, inScope } from "../src/shared/policy.js";
+test('role names do not decide permission and one person can confirm and create', () => {
+    const actor = structuredClone(actors.at(-1));
+    actor.role = 'custom-role';
+    actor.label = '自定义岗位';
+    assert.equal(can(actor, 'spec:confirm', 'heating'), true);
+    assert.equal(can(actor, 'pbc:create', 'heating'), true);
+    actor.grants[0].actions = actor.grants[0].actions.filter(a => a !== 'spec:confirm');
+    assert.equal(can(actor, 'spec:confirm', 'heating'), false);
+    assert.equal(can(actor, 'pbc:create', 'heating'), true);
+});
+test('multi-role permissions retain the scope of each assignment', () => {
+    const actor = { ...actors[2], grants: [
+            { id: 'a', name: '供热规格确认', actions: ['spec:confirm'], tenantIds: ['heating'] },
+            { id: 'b', name: '北方创建', actions: ['pbc:create'], tenantIds: ['north'] },
+        ] };
+    assert.equal(can(actor, 'spec:confirm', 'north'), false);
+    assert.equal(can(actor, 'pbc:create', 'heating'), false);
+    assert.equal(inScope(actor, 'north', 'spec:confirm'), false);
+    assert.equal(can(actor, 'spec:confirm', 'heating'), true);
+});

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/permissions.test.js

@@ -0,0 +1,24 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { actors, metadata, can } from "../src/shared/policy.js";
+import { resolveActor, validateRole, checkDelegation, checkMembership, deletableRole, assertVersion } from "../src/permissions/domain.js";
+const admin = { ...actors[0], grants: [{ id: 'mgmt', name: '管理', actions: ['permission:grant', 'permission:members', 'permission:delegate'], tenantIds: ['*'], pbcIds: ['*'] }] };
+const role = () => ({ ...metadata(admin, '2026-09-10', 'heating'), id: 'r1', name: '交付协调', code: 'delivery-editor', description: '可确认规格', enabled: true, protected: false, grants: [{ id: 'g', name: '确认规格', actions: ['spec:confirm'], tenantIds: ['heating'], pbcIds: ['*'] }] });
+const state = () => ({ version: 1, roles: [role()], members: [{ ...metadata(admin, '2026-09-10', 'heating'), id: 'm', actorId: 'zhou', roleIds: ['r1'] }], records: [] });
+test('权限来自成员角色关联，改名不改权', () => { const s = state(), person = actors[3]; assert.equal(can(resolveActor(person, s), 'spec:confirm', 'heating'), true); s.roles[0].name = '任意岗位'; assert.equal(can(resolveActor(person, s), 'spec:confirm', 'heating'), true); });
+test('停用、删除角色或移除成员关联立即撤权', () => { for (const kind of ['enabled', 'isDeleted', 'member']) {
+    const s = state();
+    if (kind === 'member')
+        s.members[0].isDeleted = true;
+    else if (kind === 'enabled')
+        s.roles[0].enabled = false;
+    else
+        s.roles[0].isDeleted = true;
+    assert.equal(can(resolveActor(actors[3], s), 'spec:confirm', 'heating'), false);
+} });
+test('不同授权不能拼接动作和范围', () => { const r = role(); r.grants.push({ id: 'g2', name: '北方查看', actions: ['spec:view'], tenantIds: ['north'], pbcIds: ['*'] }); const s = state(); s.roles = [r]; assert.equal(can(resolveActor(actors[3], s), 'spec:confirm', 'north'), false); });
+test('租户管理员不能授予其他租户或无限范围', () => { const limited = { ...admin, grants: admin.grants.map(g => ({ ...g, tenantIds: ['heating'] })) }; const r = role(); assert.doesNotThrow(() => checkDelegation(limited, r)); r.tenantId = 'platform'; r.grants[0].tenantIds = ['*']; assert.throws(() => checkDelegation(limited, r), /范围/); });
+test('转授管理权限需要单独授权', () => { const limited = { ...admin, grants: admin.grants.map(g => ({ ...g, actions: ['permission:grant', 'permission:members'] })) }; const r = role(); r.grants[0].actions = ['permission:roles']; assert.throws(() => checkDelegation(limited, r), /转授/); assert.doesNotThrow(() => checkDelegation(admin, r)); });
+test('租户角色不可包含其他租户授权', () => { const r = role(); r.grants[0].tenantIds = ['north']; assert.throws(() => checkDelegation(admin, r), /所属租户/); });
+test('在用、保护和版本过期均拒绝', () => { const s = state(); assert.throws(() => deletableRole(s.roles[0], s.members), /关联成员/); assert.throws(() => deletableRole({ ...role(), protected: true }, []), /保护/); assert.throws(() => assertVersion(role(), 0), /已被更新/); assert.doesNotThrow(() => deletableRole(role(), [])); });
+test('角色编码唯一与停用角色分配约束', () => { const s = state(); assert.throws(() => validateRole({ ...role(), id: 'another' }, s.roles), /已存在/); s.roles[0].enabled = false; assert.throws(() => checkMembership(admin, s.members[0], s.roles), /停用/); });

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/releases.test.js

@@ -0,0 +1,50 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { actors } from "../src/shared/policy.js";
+import { standardBody } from "../src/workflows/data.js";
+import { newTask, startTask, advanceTask, approveTask, clone } from "../src/tasks/domain.js";
+import { captureQuality, retainReviews } from "../src/reviews/model.js";
+import { decideReview } from "../src/reviews/commands.js";
+import { qualityReason, createRelease, sourceKey } from "../src/releases/model.js";
+const actor = actors[0];
+const binding = () => ({ intentId: 'intent', spec: { number: 1, source: { intentId: 'intent', code: 'INT-1', title: '发布测试', version: 1, confirmedAt: '2026-09-14' }, content: { overview: '需求', stories: '故事', requirements: 'FR-001', acceptance: 'AC-001', success: '标准', entities: '实体', pages: '页面', assumptions: '假设' }, decisions: [], reason: '确认样例', createdBy: '演示', createdAt: '2026-09-14', confirmedBy: '演示', confirmedAt: '2026-09-14' }, specRecordVersion: 1, pbcId: 'pbc-0', project: '供热工单', tenantId: 'heating', flowId: 'flow-0', flowRecordVersion: 1, flow: { number: 1, body: standardBody(), note: '标准', by: '演示', at: '2026-09-14', submittedBy: '演示' }, agents: [] });
+export function ready(grade = 'A') { const t = newTask(binding(), actor, '发布测试'); t.reviewPolicy = { grade, humanQuality: grade !== 'A', reason: '明确的测试策略' }; startTask(t, '测试'); advanceTask(t); approveTask(t, '测试', 1, '测试中确认原型'); for (let i = 0; i < 3; i++) {
+    const old = clone(t);
+    advanceTask(t);
+    retainReviews(old, t);
+} return t; }
+export const input = () => ({ name: '智能分诊首次发布', version: '1.0.0', environment: 'production', config: 'config-v1', description: '上线本次智能分诊功能', traffic: 10, errorLimit: 1, latencyLimit: 800, rollbackPlan: '异常时回退批准的稳定版本；首发停止并撤流。' });
+export function materials(t) { return { sourceKey: sourceKey(t), commit: 'demo-commit-a1', digest: 'sha256:demo-a1', config: 'config-v1', checks: ['merge', 'build', 'functional', 'contract', 'eval', 'security', 'migration'].map(id => ({ id, name: id, status: 'pass', detail: '测试用模拟证据' })), migration: 'none', rollback: { version: '0.9.0', digest: 'sha256:demo-old', config: 'config-old', environment: 'production' }, by: '独立CI（模拟）', at: '2026-09-14' }; }
+test('来源必须已有适用质量确认；A机器通过不代替生产授权', () => { const a = ready(); assert.equal(qualityReason(a), ''); const b = ready('B'); assert.match(qualityReason(b), /质量.*确认/); decideReview(b, captureQuality(b).id, actor, { action: 'confirm', requestId: 'quality-ok', note: '已核对', checked: true }); assert.equal(qualityReason(b), ''); const c = ready('C'); c.reviewPolicy.veto = true; assert.notEqual(qualityReason(c), ''); });
+test('新发布草稿固定来源、审计及版本，旧任务没有材料时保持缺失', () => { const t = ready(), original = clone(t.binding), r = createRelease(t, actor, input(), 'release-1'); assert.equal(r.state, 'draft'); assert.equal(r.versions[0].sourceKey, sourceKey(t)); assert.equal(r.versions[0].materials, undefined); assert.equal(r.createdBy, actor.name); assert.deepEqual(t.binding, original); assert.equal(r.traffic, 0); });
+test('发布材料必须匹配本任务的源版本，不能继承过期证据', () => { const t = ready(); t.releaseMaterials = materials(t); const r = createRelease(t, actor, input(), 'release-1'); assert.equal(r.versions[0].materials?.digest, 'sha256:demo-a1'); t.releaseMaterials.sourceKey = 'stale'; const next = createRelease(t, actor, { ...input(), environment: 'staging' }, 'release-2'); assert.equal(next.versions[0].materials, undefined); });
+test('草稿创建校验权限、输入和请求编号，不重复创建', () => { const t = ready(); assert.throws(() => createRelease(t, { ...actor, grants: [] }, input(), 'r'), /权限/); assert.throws(() => createRelease(t, actor, { ...input(), name: '' }, 'r'), /名称/); const r = createRelease(t, actor, input(), 'r'); assert.equal(createRelease(t, actor, input(), 'r').id, r.id); assert.equal(t.releases.length, 1); assert.throws(() => createRelease(t, actor, { ...input(), name: '另一个' }, 'r'), /编号/); assert.throws(() => createRelease(t, actor, input(), 'second'), /已有/); assert.equal(t.releases.length, 1); });
+import { applyRelease } from "../src/releases/commands.js";
+let sequence = 0;
+function command(t, action, extra = {}) { const r = t.releases[0]; return applyRelease(t, r.id, actor, { id: 'request-' + (++sequence), expected: r.recordVersion, action, note: '已核对本版内容', checked: true, ...extra }); }
+function prepared() { const t = ready(); t.releaseMaterials = materials(t); createRelease(t, actor, input(), 'release'); command(t, 'check'); command(t, 'submit'); return t; }
+function authorized() { const t = prepared(); command(t, 'approve'); return t; }
+function canary() { const t = authorized(); command(t, 'start'); command(t, 'advance'); return t; }
+test('缺少材料不能提交；检查、审核、首次流量按顺序执行', () => { const t = ready(); createRelease(t, actor, input(), 'release'); command(t, 'check'); assert.throws(() => command(t, 'submit'), /材料|证据/); const p = prepared(); assert.throws(() => command(p, 'start'), /授权/); assert.throws(() => command(p, 'approve', { checked: false }), /核对/); command(p, 'approve'); assert.equal(p.releases[0].traffic, 0); command(p, 'start'); assert.equal(p.releases[0].state, 'deploying'); command(p, 'advance'); assert.equal(p.releases[0].traffic, 10); });
+test('不同目标环境的动作独立授权；空说明和过期页面不得通过', () => { const t = prepared(), r = t.releases[0], a = { ...actor, grants: [{ id: 'staging', name: '仅预发布', actions: ['task:view', 'artifact:view', 'release:approve'], tenantIds: ['heating'], environmentIds: ['staging'] }] }; assert.throws(() => applyRelease(t, r.id, a, { id: 'approve', expected: r.recordVersion, action: 'approve', note: '核对', checked: true }), /权限/); assert.throws(() => command(t, 'approve', { note: '' }), /说明/); assert.throws(() => command(t, 'approve', { expected: 0 }), /更新|版本/); assert.equal(r.state, 'pending'); });
+test('修改环境或配置产生新版本，原批准保留但不再有效', () => { const t = authorized(); command(t, 'edit', { input: { ...input(), config: 'config-v2' } }); const r = t.releases[0]; assert.equal(r.versions.length, 2); assert.equal(r.state, 'draft'); assert.equal(r.approval, undefined); assert.ok(r.receipts.some(x => x.action === 'approve')); assert.throws(() => command(t, 'start'), /授权/); command(t, 'check'); assert.throws(() => command(t, 'submit'), /材料|证据/); assert.equal(r.traffic, 0); });
+test('来源变化阻断执行及全量，但仍可停止或回滚', () => { const t = authorized(); t.artifacts.find(a => a.kind === 'code').versions.at(-1).number++; assert.throws(() => command(t, 'start'), /来源|版本/); const c = canary(); c.releaseMaterials.sourceKey = 'changed'; c.artifacts.find(a => a.kind === 'code').versions.at(-1).number++; assert.throws(() => command(c, 'advance'), /来源|版本/); command(c, 'rollback'); assert.equal(c.releases[0].state, 'rollingBack'); });
+test('同编号同内容重试不推进两次；响应不明先查询回执', () => { const t = authorized(), r = t.releases[0], c = { id: 'same-start', expected: r.recordVersion, action: 'start', note: '执行', unknown: true }; applyRelease(t, r.id, actor, c); const saved = clone(r); applyRelease(t, r.id, actor, c); assert.deepEqual(r, saved); assert.throws(() => command(t, 'advance'), /回执/); assert.throws(() => applyRelease(t, r.id, actor, { ...c, note: '不同' }), /编号/); command(t, 'verify'); assert.equal(r.unconfirmed, undefined); command(t, 'advance'); assert.equal(r.traffic, 10); });
+test('观察通过才能全量；失败重试有限，暂停和恢复不产生流量', () => { const t = canary(); command(t, 'pause'); assert.equal(t.releases[0].traffic, 10); command(t, 'resume'); command(t, 'advance'); assert.equal(t.releases[0].state, 'observing'); command(t, 'advance'); assert.equal(t.releases[0].traffic, 100); assert.equal(t.releases[0].state, 'succeeded'); const f = authorized(); command(f, 'start'); for (let i = 0; i < 3; i++) {
+    command(f, 'advance', { outcome: 'fail' });
+    if (i < 2)
+        command(f, 'retry');
+} assert.throws(() => command(f, 'retry'), /次数/); assert.equal(f.releases[0].traffic, 0); });
+test('首发无回滚目标只能停止撤流；有历史时回滚明确保留数据库状态', () => { const t = ready(); t.releaseMaterials = materials(t); delete t.releaseMaterials.rollback; createRelease(t, actor, input(), 'release'); for (const a of ['check', 'submit', 'approve', 'start', 'advance'])
+    command(t, a); assert.throws(() => command(t, 'rollback'), /目标|首发/); command(t, 'stop'); assert.equal(t.releases[0].traffic, 0); const p = canary(); command(p, 'rollback'); command(p, 'advance'); assert.equal(p.releases[0].state, 'rolledBack'); assert.match(p.releases[0].reason, /数据库/); assert.equal(p.releases[0].traffic, 0); });
+test('只有未提交且无历史的草稿可删除', () => { const t = ready(); createRelease(t, actor, input(), 'release'); command(t, 'delete'); assert.equal(t.releases[0].isDeleted, true); const p = prepared(); command(p, 'return'); assert.throws(() => command(p, 'delete'), /历史|草稿/); assert.equal(p.releases[0].isDeleted, false); });
+import { buildWorkbench } from "../src/workbench/model.js";
+import { controlTask } from "../src/tasks/domain.js";
+import { checkDelegation } from "../src/permissions/domain.js";
+test('工作台沿用一个任务待办，发布完成后转运行验收待办', () => { const t = prepared(), data = () => buildWorkbench({ actor, active: true, intents: [], specs: [], jobs: [], pbcs: [], tasks: [t] }, 'all'); assert.equal(data().todos.length, 1); assert.equal(data().todos[0].group, '门禁与发布'); assert.equal(data().ongoing, 1); command(t, 'approve'); command(t, 'start'); command(t, 'advance'); command(t, 'advance'); command(t, 'advance'); assert.equal(data().todos.filter(x => x.group === '门禁与发布').length, 0); assert.equal(data().todos[0].group, '运行管理'); assert.equal(data().ongoing, 1); assert.equal(data().deliveries[0].label, '发布成功'); });
+test('发布执行后不能从旧任务接管入口破坏发布状态', () => { const t = canary(); assert.throws(() => controlTask(t, 'takeover', '测试', '接管'), /发布/); assert.equal(t.status, 'ready'); });
+test('授权管理不能超出可管理的发布环境', () => { const a = { ...actor, grants: [{ id: 'delegate', name: '预发布管理员', actions: ['permission:grant'], tenantIds: ['heating'], pbcIds: ['*'], environmentIds: ['staging'] }] }; const role = { ...a, tenantId: 'heating', grants: [{ id: 'g', name: '发布批准', actions: ['release:approve'], tenantIds: ['heating'], pbcIds: ['*'], environmentIds: ['production'] }] }; assert.throws(() => checkDelegation(a, role), /超出/); role.grants[0].environmentIds = ['staging']; assert.doesNotThrow(() => checkDelegation(a, role)); });
+import { taskReleaseLabel } from "../src/releases/model.js";
+test('预发布完成不能代签生产阶段，任务摘要标明环境', () => { const t = ready(); t.releaseMaterials = materials(t); delete t.releaseMaterials.rollback; const original = clone(t.stages); createRelease(t, actor, { ...input(), environment: 'staging' }, 'release'); for (const action of ['check', 'submit', 'approve', 'start', 'advance', 'advance', 'advance'])
+    command(t, action); assert.equal(t.releases[0].state, 'succeeded'); assert.deepEqual(t.stages, original); assert.equal(taskReleaseLabel(t, actor), '预发布环境 · 发布成功'); const data = buildWorkbench({ actor, active: true, intents: [], specs: [], jobs: [], pbcs: [], tasks: [t] }, 'all'); assert.equal(data.todos.length, 1); assert.match(data.todos[0].status, /生产/); assert.match(data.todos[0].path, /prepare=1/); });
+test('终态响应不明仍保留核实待办，核实前不允许新建同环境发布', () => { const t = canary(); command(t, 'advance'); command(t, 'advance', { unknown: true }); const data = () => buildWorkbench({ actor, active: true, intents: [], specs: [], jobs: [], pbcs: [], tasks: [t] }, 'all'); assert.equal(t.releases[0].state, 'succeeded'); assert.equal(data().todos.length, 1); assert.equal(data().todos[0].status, '结果待核实'); assert.match(data().todos[0].reason, /查询原请求回执/); assert.doesNotMatch(data().todos[0].reason, /已全量|发布完成/); assert.throws(() => createRelease(t, actor, input(), 'next-release'), /已有/); command(t, 'verify'); assert.equal(data().todos.filter(x => x.group === '门禁与发布').length, 0); assert.equal(data().todos[0].group, '运行管理'); });

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/reviews.test.js

@@ -0,0 +1,36 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { actors } from "../src/shared/policy.js";
+import { standardBody } from "../src/workflows/data.js";
+import { newTask, startTask, advanceTask, approveTask, controlTask, latestArtifact, clone } from "../src/tasks/domain.js";
+import { reviewsForTask, reviewStatus, actionableReview, actionReason, canReadReview, retainReviews, reviewBudget } from "../src/reviews/model.js";
+import { decideReview, validateDesign } from "../src/reviews/commands.js";
+import { buildWorkbench } from "../src/workbench/model.js";
+const actor = actors[0];
+function binding() { return { intentId: 'intent', spec: { number: 1, source: { intentId: 'intent', code: 'INT-1', title: '测试需求', version: 1, confirmedAt: '2026-09-11' }, content: { overview: '需求', stories: '故事', requirements: 'FR-004 幂等确认', acceptance: 'AC', success: '标准', entities: '实体', pages: '页面', assumptions: '假设' }, decisions: [], reason: '确认样例', createdBy: '演示', createdAt: '2026-09-11', confirmedBy: '演示', confirmedAt: '2026-09-11' }, specRecordVersion: 1, pbcId: 'pbc-0', project: '供热工单', tenantId: 'heating', flowId: 'flow-0', flowRecordVersion: 1, flow: { number: 1, body: standardBody(), note: '标准', by: '演示', at: '2026-09-11', submittedBy: '演示' }, agents: [] }; }
+function base() { const t = newTask(binding(), actor, '评审测试'); t.reviewPolicy = { grade: 'B', humanQuality: true, reason: '本确认点需要人工' }; startTask(t, '发起人'); advanceTask(t); return t; }
+function step(t, result = 'pass') { const old = structuredClone(t); advanceTask(t, result); retainReviews(old, t); }
+function quality(result = 'pass') { const t = base(); approveTask(t, '历史核对人', 1, '已核对原型'); step(t); step(t); step(t, result); return t; }
+function payload(action = 'confirm') { return { action, requestId: crypto.randomUUID(), note: '核对当前版本与依据', checked: true, content: action === 'edit' ? '新设计：按租户、建议版本和请求编号实现幂等确认。' : undefined, impact: action === 'replan' ? '重新设计幂等边界并重新实现、执行测试和验证。' : undefined }; }
+function active(t) { const r = actionableReview(t); assert.ok(r); return r; }
+function input(t) { return { actor, active: true, intents: [], specs: [], jobs: [], pbcs: [], tasks: [t] }; }
+test('评审按绑定版本呈现，查看不改写任务，分项无证据不显示通过', () => { const t = quality(), before = JSON.stringify(t), r = active(t); assert.equal(r.kind, 'quality'); assert.equal(reviewStatus(t, r), 'pending'); assert.ok(r.refs.some(x => x.kind === 'code' && x.version === 1)); assert.equal(JSON.stringify(t), before); assert.equal(r.checks.find(c => c.name === 'evals').status, 'unavailable'); });
+test('旧版原型确认保留历史操作者；新验证到达后旧检查中记录失效', () => { const t = base(); approveTask(t, '历史核对人', 1, '已核对原型'); step(t); step(t); const prior = active(t); assert.equal(reviewStatus(t, prior), 'checking'); step(t); assert.equal(reviewStatus(t, prior), 'superseded'); assert.equal(reviewsForTask(t).filter(r => ['pending', 'checking', 'blocked'].includes(reviewStatus(t, r))).length, 1); const r = reviewsForTask(t).find(r => r.kind === 'prototype'); assert.equal(r.decision.actor, '历史核对人'); assert.match(r.decision.note, /已核对原型/); });
+test('机器失败不能通过人工确认改成成功', () => { const t = quality('fail'), r = active(t), before = structuredClone(t); assert.equal(r.findings[0].id, 'ROB-AC003.2'); assert.equal(reviewStatus(t, r), 'blocked'); assert.throws(() => decideReview(t, r.id, actor, payload()), /重复确认|派单/); assert.deepEqual(t, before); });
+test('修改生成新设计版本；原设计、失败报告及规格与流程绑定不变', () => { const t = quality('fail'), r = active(t), old = structuredClone(t), p = payload('edit'), d = decideReview(t, r.id, actor, p); assert.equal(d.newVersion, 2); assert.equal(t.status, 'waiting'); assert.equal(t.reworks, 1); assert.equal(latestArtifact(t, 'design').content, p.content); assert.deepEqual(t.binding, old.binding); for (const a of old.artifacts)
+    for (const v of a.versions)
+        assert.deepEqual(t.artifacts.find(x => x.id === a.id).versions[v.number - 1], v); assert.equal(reviewStatus(t, active(t)), 'checking'); });
+test('保存不等于批准；设计复核通过并确认后才能恢复实现', () => { const t = quality('fail'); decideReview(t, active(t).id, actor, payload('edit')); const r = active(t); assert.throws(() => decideReview(t, r.id, actor, payload()), /新设计|等待/); assert.throws(() => advanceTask(t), /可推进/); validateDesign(t, r.id, 'pass'); assert.equal(reviewStatus(t, active(t)), 'pending'); decideReview(t, r.id, actor, payload()); assert.equal(t.status, 'running'); assert.equal(t.currentId, 'build'); assert.equal(t.approvedDesignVersion, 2); });
+test('重新实现保留人工设计并产生新代码、测试和独立验证', () => { const t = quality('fail'); decideReview(t, active(t).id, actor, payload('edit')); const r = active(t); validateDesign(t, r.id, 'pass'); decideReview(t, r.id, actor, payload()); const design = clone(latestArtifact(t, 'design')); step(t); assert.deepEqual(latestArtifact(t, 'design'), design); assert.equal(latestArtifact(t, 'code').number, 2); assert.ok(latestArtifact(t, 'code').inputs.some(i => i.id === 'design' && i.version === 2)); assert.equal(t.checksPassed, false); step(t); step(t); assert.equal(latestArtifact(t, 'test').iteration, 1); assert.equal(latestArtifact(t, 'verify').iteration, 1); assert.equal(reviewStatus(t, active(t)), 'pending'); });
+test('设计复核失败不可确认，后续结果保留前次失败报告版本', () => { const t = quality(); decideReview(t, active(t).id, actor, payload('edit')); const id = active(t).id; validateDesign(t, id, 'fail'); assert.equal(reviewStatus(t, active(t)), 'blocked'); assert.throws(() => decideReview(t, id, actor, payload()), /未覆盖/); const failed = clone(latestArtifact(t, 'review')); validateDesign(t, id, 'pass'); assert.equal(t.artifacts.find(a => a.kind === 'review').versions.length, 2); assert.deepEqual(t.artifacts.find(a => a.kind === 'review').versions[0], failed); });
+test('重新规划保留意见与影响，不改写来源和流程版本', () => { const t = quality(), original = clone(t.binding), p = payload('replan'); const d = decideReview(t, active(t).id, actor, p); assert.ok(d.nextReviewId); assert.equal(d.impact, p.impact); assert.match(latestArtifact(t, 'design').content, /重新规划意见/); assert.deepEqual(t.binding, original); assert.equal(reviewStatus(t, active(t)), 'checking'); });
+test('确认仅完成当前质量点，不执行生产发布或归档', () => { const t = quality(); decideReview(t, active(t).id, actor, payload()); assert.equal(t.status, 'ready'); assert.equal(t.currentId, 'approval'); assert.equal(t.stages.find(s => s.nodeId === 'release').state, 'pending'); assert.equal(t.stages.find(s => s.nodeId === 'archive').state, 'pending'); assert.equal(actionableReview(t), undefined); });
+test('相同提交返回原结果，编号不能跨记录或复用不同内容', () => { const t = quality(), id = active(t).id, p = payload('edit'); const d = decideReview(t, id, actor, p), before = structuredClone(t); assert.deepEqual(decideReview(t, id, actor, p), d); assert.deepEqual(t, before); assert.throws(() => decideReview(t, id, actor, { ...p, note: '更改说明' }), /同一提交编号/); assert.throws(() => decideReview(t, active(t).id, actor, p), /同一提交编号/); });
+test('动作和资源决定权限；岗位名称不授权，撤权与跨租户不可读写', () => { const t = quality(), r = active(t), read = { ...actor, label: 'AI工程师', grants: [{ id: 'read', name: '只读', actions: ['task:view', 'artifact:view'], tenantIds: ['heating'], pbcIds: ['pbc-0'] }] }; assert.ok(canReadReview(read, t)); assert.match(actionReason(t, r, read, 'edit'), /权限/); assert.throws(() => decideReview(t, r.id, read, payload()), /权限/); assert.equal(canReadReview({ ...read, grants: [] }, t), false); assert.equal(canReadReview({ ...read, grants: [{ ...read.grants[0], tenantIds: ['other'] }] }, t), false); assert.equal(canReadReview({ ...read, grants: [{ ...read.grants[0], pbcIds: ['pbc-other'] }] }, t), false); });
+test('必填、长度与未修改校验失败不生成决策或新版本', () => { const t = quality(), r = active(t), old = structuredClone(t); for (const p of [{ ...payload(), note: '' }, { ...payload(), note: 'x'.repeat(1001) }, { ...payload(), checked: false }, { ...payload('replan'), impact: '' }, { ...payload('edit'), content: '' }, { ...payload('edit'), content: latestArtifact(t, 'design').content }])
+    assert.throws(() => decideReview(t, r.id, actor, p)); assert.deepEqual(t, old); });
+test('达到有限次数须接管，接管不重置预算或判定通过', () => { const t = quality(); t.reworks = t.retryLimit; t.reviews = []; assert.match(actionReason(t, active(t), actor, 'edit'), /次数/); const before = clone(t.artifacts); controlTask(t, 'takeover', '接管人', '达到处理上限'); assert.equal(reviewStatus(t, active(t)), 'suspended'); controlTask(t, 'resume', '接管人', '回到原阶段'); assert.equal(t.reworks, 2); assert.deepEqual(t.artifacts, before); const n = t.binding.flow.body.nodes.find(n => n.id === 'build'); n.kind = 'loop'; n.limit = 1; assert.equal(reviewBudget(t), 1); });
+test('A档无额外人工点；C档敏感停点不能一键跳过', () => { const a = quality(); a.reviews = []; a.reviewPolicy = { grade: 'A', humanQuality: false, reason: '预置机器检查' }; assert.equal(reviewStatus(a, reviewsForTask(a).find(r => r.kind === 'quality')), 'automatic'); assert.equal(actionableReview(a), undefined); const c = quality(); c.reviews = []; c.reviewPolicy = { grade: 'C', humanQuality: true, veto: true, reason: '敏感停点' }; assert.equal(reviewStatus(c, active(c)), 'blocked'); assert.throws(() => decideReview(c, active(c).id, actor, payload()), /敏感停点/); });
+test('工作台同一任务门禁去重，质量确认后转发布待办；无产物权限不泄露评审', () => { const t = quality(), data = buildWorkbench(input(t), 'all'); assert.equal(data.todos.length, 1); assert.equal(data.todos[0].group, '质量与评审'); assert.equal(data.ongoing, 1); decideReview(t, active(t).id, actor, payload()); assert.equal(buildWorkbench(input(t), 'all').todos.length, 1); assert.equal(buildWorkbench(input(t), 'all').todos[0].group, '门禁与发布'); const limited = { ...actor, grants: [{ id: 'task', name: '任务只读', actions: ['task:view'], tenantIds: ['heating'] }] }; assert.equal(buildWorkbench({ ...input(quality()), actor: limited }, 'all').todos.length, 0); });
+test('旧依据缺失或出现新版本，拒绝继续提交旧记录', () => { const t = quality(), r = active(t); t.artifacts.find(a => a.kind === 'code').versions.push({ ...clone(latestArtifact(t, 'code')), number: 2 }); assert.equal(reviewStatus(t, r), 'superseded'); assert.throws(() => decideReview(t, r.id, actor, payload()), /版本已变化/); const x = quality(), q = active(x); x.artifacts = x.artifacts.filter(a => a.kind !== 'verify'); assert.equal(reviewStatus(x, q), 'superseded'); });
+test('原型通过统一评审入口确认，不能提前修改尚未生成的设计', () => { const t = base(), r = active(t); assert.equal(r.kind, 'prototype'); assert.match(actionReason(t, r, actor, 'edit'), /原型确认后/); decideReview(t, r.id, actor, payload()); assert.equal(t.prototypeApproved, true); assert.equal(t.currentId, 'build'); });

package/skills/i3-ui-demo/assets/templates/enterprise-admin/reference/tests/runtime-forms-router.test.js

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { validateValue,useForm } from '../runtime/forms.js';
+import { computed } from '../runtime/state.js';
+import { matchRoute } from '../runtime/router.js';
+
+test('form validation retains zero prices and rejects whitespace and invalid service URLs',async()=>{
+  assert.equal(await validateValue(0,[{required:true,type:'number',min:0}]),'');
+  assert.notEqual(await validateValue(-1,[{type:'number',min:0}]),'');
+  assert.notEqual(await validateValue('   ',[{required:true,whitespace:true}]),'');
+  assert.notEqual(await validateValue('not-a-service-url',[{type:'url'}]),'');
+  assert.equal(await validateValue('https://models.example.invalid/v1',[{type:'url'}]),'');
+});
+test('asynchronous uniqueness rules block saving without discarding form input',async()=>{
+  const form=useForm({alias:'duplicate'},[{path:'alias',rules:[{validator:async()=>{throw Error('标识已存在');}}]}]);
+  await assert.rejects(form.formRef.value.validate(),/校验/);
+  assert.equal(form.formData.alias,'duplicate');assert.equal(form.errors.alias,'标识已存在');
+});
+test('hidden fields follow current model type and validation accepts required multiple selections',async()=>{
+  const form=useForm({kind:'chat',dimension:undefined,capabilities:['文本']});
+  form.fields.value=[{path:'dimension',hidden:computed(()=>form.formData.kind!=='embedding'),rules:[{required:true}]},{path:'capabilities',hidden:computed(()=>form.formData.kind==='embedding'),rules:[{required:true,type:'array',min:1}]}];
+  await form.formRef.value.validate();form.formData.kind='embedding';await assert.rejects(form.formRef.value.validate());form.formData.dimension=1536;await form.formRef.value.validate();
+});
+test('native hash routes retain deep-link identifiers and query parameters',()=>{
+  const routes=[{path:'/tasks/new'},{path:'/tasks/:id/artifacts/:artifact'},{path:'/tasks/:id'}];
+  const route=matchRoute('#/tasks/task-example-1/artifacts/verify?version=1',routes);
+  assert.deepEqual(route.params,{id:'task-example-1',artifact:'verify'});assert.equal(route.query.version,'1');assert.equal(route.fullPath,'/tasks/task-example-1/artifacts/verify?version=1');assert.deepEqual(matchRoute('/tasks/new',routes).params,{});
+});