320 lines
9.8 KiB
TypeScript
320 lines
9.8 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import {
|
|
createDeterministicLivingSystemPlan,
|
|
createLivingSystemExecutionReceipt,
|
|
createLivingSystemEvent,
|
|
parseLivingSystemPlan,
|
|
validateLivingSystemPlan,
|
|
} from './guanghuLivingSystem'
|
|
|
|
describe('Guanghu living system contract', () => {
|
|
it('binds every event to the persona system, knowledge state, boundaries, and capability registry', () => {
|
|
const event = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
eventId: 'event-context',
|
|
intent: 'open-knowledge',
|
|
receiptIds: ['truth-001'],
|
|
requestedRoute: 'world',
|
|
worldOpen: true,
|
|
modelInstanceId: 'model-instance-current',
|
|
knowledgeState: {
|
|
selectedLakeId: 'lake-current',
|
|
mountedSources: ['REPO-012', 'REPO-014'],
|
|
},
|
|
})
|
|
|
|
expect(event.personaSystem).toEqual({
|
|
humanAnchorId: 'ICE-GL∞',
|
|
personaSystemId: 'ICE-P-ZY001',
|
|
memoryProtocolRoot: 'REPO-012',
|
|
modelInstanceId: 'model-instance-current',
|
|
})
|
|
expect(event.knowledgeState).toEqual({
|
|
selectedLakeId: 'lake-current',
|
|
mountedSources: ['REPO-012', 'REPO-014'],
|
|
})
|
|
expect(event.permissionBoundary.allowedCapabilities).toContain('knowledge.open')
|
|
expect(event.responsibilityBoundary.controllerPersonaSystemId).toBe('ICE-P-ZY001')
|
|
expect(event.capabilityRegistry).toContainEqual(expect.objectContaining({
|
|
id: 'knowledge.open',
|
|
outputType: 'CapabilityCall',
|
|
}))
|
|
})
|
|
|
|
it('drops a claimed runtime binding when its issuing receipt is absent', () => {
|
|
const event = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
eventId: 'event-unverified-runtime',
|
|
intent: 'navigate',
|
|
receiptIds: [],
|
|
requestedRoute: 'world',
|
|
worldOpen: true,
|
|
runtimeBinding: {
|
|
bindingId: 'binding-unverified',
|
|
nodeId: 'JD-FD-PRIMARY',
|
|
personaSystemId: 'ICE-P-ZY001',
|
|
modelInstanceId: 'model-unverified',
|
|
issuedByReceiptId: 'missing-receipt',
|
|
status: 'verified',
|
|
},
|
|
})
|
|
|
|
expect(event.currentSystemState.runtimeBinding).toBeNull()
|
|
expect(event.personaSystem.modelInstanceId).toBeNull()
|
|
})
|
|
|
|
it('accepts a model-native navigation plan with a bounded visual scene', () => {
|
|
const event = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
intent: 'navigate',
|
|
requestedRoute: 'fifth-domain',
|
|
worldOpen: true,
|
|
receiptIds: ['receipt-001'],
|
|
now: 1_785_670_000_000,
|
|
eventId: 'event-001',
|
|
})
|
|
const plan = parseLivingSystemPlan(JSON.stringify({
|
|
version: 1,
|
|
eventId: 'event-001',
|
|
intent: 'navigate',
|
|
planId: 'plan-001',
|
|
requiredTruth: ['receipt-001'],
|
|
uiProjection: {
|
|
route: 'fifth-domain',
|
|
stateLabel: 'model-proposed',
|
|
scene: {
|
|
depth: 'immersive',
|
|
motion: 'responsive',
|
|
starDensity: 'rich',
|
|
connectionEmphasis: 'active-route',
|
|
},
|
|
},
|
|
navigationAction: { type: 'navigate', route: 'fifth-domain' },
|
|
capabilityCall: null,
|
|
receiptSchema: { outcome: 'pending-evidence', requiredEvidence: ['ui.route.readback'] },
|
|
}))
|
|
|
|
expect(validateLivingSystemPlan(event, plan)).toEqual({
|
|
accepted: true,
|
|
plan,
|
|
})
|
|
})
|
|
|
|
it('fails closed when a model plan references truth that was not supplied', () => {
|
|
const event = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
intent: 'navigate',
|
|
requestedRoute: 'fifth-domain',
|
|
worldOpen: true,
|
|
receiptIds: [],
|
|
eventId: 'event-002',
|
|
now: 1,
|
|
})
|
|
const plan = parseLivingSystemPlan(JSON.stringify({
|
|
version: 1,
|
|
eventId: 'event-002',
|
|
intent: 'navigate',
|
|
planId: 'plan-002',
|
|
requiredTruth: ['invented-receipt'],
|
|
uiProjection: {
|
|
route: 'fifth-domain',
|
|
stateLabel: 'model-proposed',
|
|
scene: {
|
|
depth: 'focused', motion: 'quiet', starDensity: 'balanced', connectionEmphasis: 'contextual',
|
|
},
|
|
},
|
|
navigationAction: { type: 'navigate', route: 'fifth-domain' },
|
|
capabilityCall: null,
|
|
receiptSchema: { outcome: 'pending-evidence', requiredEvidence: [] },
|
|
}))
|
|
|
|
expect(validateLivingSystemPlan(event, plan)).toEqual({
|
|
accepted: false,
|
|
reason: 'unverified_truth',
|
|
})
|
|
})
|
|
|
|
it('redirects protected routes to the login gate while the world is closed', () => {
|
|
const event = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
intent: 'navigate',
|
|
requestedRoute: 'fifth-domain',
|
|
worldOpen: false,
|
|
receiptIds: [],
|
|
eventId: 'event-003',
|
|
now: 1,
|
|
})
|
|
|
|
expect(createDeterministicLivingSystemPlan(event)).toMatchObject({
|
|
uiProjection: {
|
|
route: 'world-login',
|
|
scene: { depth: 'focused', motion: 'responsive' },
|
|
},
|
|
navigationAction: { route: 'world-login' },
|
|
})
|
|
})
|
|
|
|
it('rejects a model plan that substitutes a different host action', () => {
|
|
const event = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
eventId: 'event-host-action',
|
|
intent: 'open-knowledge',
|
|
requestedRoute: 'world',
|
|
worldOpen: false,
|
|
receiptIds: [],
|
|
now: 1,
|
|
})
|
|
const plan = parseLivingSystemPlan(JSON.stringify({
|
|
version: 1,
|
|
eventId: event.eventId,
|
|
intent: 'open-agent-workspace',
|
|
planId: 'substituted-action',
|
|
requiredTruth: [],
|
|
uiProjection: {
|
|
route: 'world',
|
|
stateLabel: 'model-proposed',
|
|
scene: {
|
|
depth: 'overview',
|
|
motion: 'responsive',
|
|
starDensity: 'balanced',
|
|
connectionEmphasis: 'contextual',
|
|
},
|
|
},
|
|
navigationAction: { type: 'navigate', route: 'world' },
|
|
capabilityCall: {
|
|
type: 'capability',
|
|
capabilityId: 'agent.workspace.open',
|
|
input: {},
|
|
},
|
|
receiptSchema: { outcome: 'pending-evidence', requiredEvidence: [] },
|
|
}))
|
|
|
|
expect(validateLivingSystemPlan(event, plan)).toEqual({
|
|
accepted: false,
|
|
reason: 'intent_mismatch',
|
|
})
|
|
})
|
|
|
|
it('rejects route substitution, closed-world projection, and capability substitution', () => {
|
|
const openEvent = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
eventId: 'event-route-boundary',
|
|
intent: 'navigate',
|
|
requestedRoute: 'fifth-domain',
|
|
worldOpen: true,
|
|
receiptIds: [],
|
|
now: 1,
|
|
})
|
|
const openPlan = createDeterministicLivingSystemPlan(openEvent)
|
|
expect(validateLivingSystemPlan(openEvent, {
|
|
...openPlan,
|
|
navigationAction: { type: 'navigate', route: 'world' },
|
|
})).toEqual({ accepted: false, reason: 'route_mismatch' })
|
|
|
|
const closedEvent = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
eventId: 'event-world-boundary',
|
|
intent: 'navigate',
|
|
requestedRoute: 'fifth-domain',
|
|
worldOpen: false,
|
|
receiptIds: [],
|
|
now: 1,
|
|
})
|
|
const closedPlan = createDeterministicLivingSystemPlan(closedEvent)
|
|
const protectedPlan = {
|
|
...closedPlan,
|
|
uiProjection: { ...closedPlan.uiProjection, route: 'fifth-domain' as const },
|
|
navigationAction: { type: 'navigate' as const, route: 'fifth-domain' as const },
|
|
}
|
|
expect(validateLivingSystemPlan(closedEvent, protectedPlan)).toEqual({
|
|
accepted: false,
|
|
reason: 'world_closed',
|
|
})
|
|
|
|
const capabilityEvent = createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
eventId: 'event-capability-boundary',
|
|
intent: 'open-knowledge',
|
|
requestedRoute: 'world',
|
|
worldOpen: true,
|
|
receiptIds: [],
|
|
now: 1,
|
|
})
|
|
const capabilityPlan = createDeterministicLivingSystemPlan(capabilityEvent)
|
|
expect(validateLivingSystemPlan(capabilityEvent, {
|
|
...capabilityPlan,
|
|
capabilityCall: {
|
|
type: 'capability',
|
|
capabilityId: 'agent.workspace.open',
|
|
input: {},
|
|
},
|
|
})).toEqual({ accepted: false, reason: 'capability_mismatch' })
|
|
})
|
|
|
|
it('rejects chatty or structurally invalid model output', () => {
|
|
expect(parseLivingSystemPlan('我来帮你进入第五域')).toBeNull()
|
|
expect(parseLivingSystemPlan('{"route":"fifth-domain"}')).toBeNull()
|
|
expect(parseLivingSystemPlan(JSON.stringify({
|
|
version: 1,
|
|
eventId: 'event-001',
|
|
intent: 'navigate',
|
|
planId: 'legacy-theme-adapter',
|
|
route: 'fifth-domain',
|
|
requiredTruth: [],
|
|
scene: {
|
|
depth: 'immersive', motion: 'active', starDensity: 'rich', connectionEmphasis: 'network',
|
|
},
|
|
}))).toBeNull()
|
|
})
|
|
|
|
it('binds a local executor receipt to the accepted event and plan', () => {
|
|
const plan = createDeterministicLivingSystemPlan(createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
intent: 'navigate',
|
|
requestedRoute: 'zero-core',
|
|
worldOpen: true,
|
|
receiptIds: [],
|
|
eventId: 'event-004',
|
|
now: 1,
|
|
}))
|
|
|
|
expect(createLivingSystemExecutionReceipt({
|
|
plan,
|
|
source: 'fallback',
|
|
outcome: 'executed',
|
|
evidence: ['ui.route:zero-core'],
|
|
now: 2,
|
|
})).toEqual({
|
|
version: 1,
|
|
receiptId: 'local-execution:fallback-event-004:executed',
|
|
eventId: 'event-004',
|
|
intent: 'navigate',
|
|
planId: 'fallback-event-004',
|
|
route: 'zero-core',
|
|
source: 'fallback',
|
|
outcome: 'executed',
|
|
evidence: ['ui.route:zero-core'],
|
|
completedAt: 2,
|
|
})
|
|
})
|
|
|
|
it('refuses to create a successful receipt before real evidence exists', () => {
|
|
const plan = createDeterministicLivingSystemPlan(createLivingSystemEvent({
|
|
currentRoute: 'world',
|
|
intent: 'navigate',
|
|
requestedRoute: 'zero-core',
|
|
worldOpen: true,
|
|
receiptIds: [],
|
|
eventId: 'event-no-evidence',
|
|
now: 1,
|
|
}))
|
|
|
|
expect(() => createLivingSystemExecutionReceipt({
|
|
plan,
|
|
source: 'fallback',
|
|
outcome: 'executed',
|
|
evidence: [],
|
|
now: 2,
|
|
})).toThrow('guanghu_living_system_success_evidence_required')
|
|
})
|
|
})
|