bingshuo/hololake-system-architecture
Watch
1
0
Fork
You've already forked hololake-system-architecture
 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity

feat: enforce Guanghu-native HoloLake runtime laws

Browse source
This commit is contained in:
冰朔 2026-08-04 23:11:25 +08:00
commit 67e6fcdd38
57 changed files with 1765 additions and 1504 deletions
Download patch file Download diff file Expand all files Collapse all files

214
product-source/hololake-platform/src/lib/guanghuLivingSystem.test.ts
View file

@ -8,6 +8,61 @@ import {
} 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',
@ -23,14 +78,20 @@ describe('Guanghu living system contract', () => {
eventId: 'event-001',
intent: 'navigate',
planId: 'plan-001',
route: 'fifth-domain',
requiredTruth: ['receipt-001'],
scene: {
depth: 'immersive',
motion: 'responsive',
starDensity: 'rich',
connectionEmphasis: 'active-route',
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({
@ -54,11 +115,17 @@ describe('Guanghu living system contract', () => {
eventId: 'event-002',
intent: 'navigate',
planId: 'plan-002',
route: 'fifth-domain',
requiredTruth: ['invented-receipt'],
scene: {
depth: 'focused', motion: 'quiet', starDensity: 'balanced', connectionEmphasis: 'contextual',
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({
@ -79,8 +146,11 @@ describe('Guanghu living system contract', () => {
})
expect(createDeterministicLivingSystemPlan(event)).toMatchObject({
route: 'world-login',
scene: { depth: 'focused', motion: 'responsive' },
uiProjection: {
route: 'world-login',
scene: { depth: 'focused', motion: 'responsive' },
},
navigationAction: { route: 'world-login' },
})
})
@ -99,14 +169,24 @@ describe('Guanghu living system contract', () => {
eventId: event.eventId,
intent: 'open-agent-workspace',
planId: 'substituted-action',
route: 'world',
requiredTruth: [],
scene: {
depth: 'overview',
motion: 'responsive',
starDensity: 'balanced',
connectionEmphasis: 'contextual',
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({
@ -115,9 +195,76 @@ describe('Guanghu living system contract', () => {
})
})
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', () => {
@ -131,16 +278,43 @@ describe('Guanghu living system contract', () => {
now: 1,
}))
expect(createLivingSystemExecutionReceipt({ plan, source: 'fallback', now: 2 })).toEqual({
expect(createLivingSystemExecutionReceipt({
plan,
source: 'fallback',
outcome: 'executed',
evidence: ['ui.route:zero-core'],
now: 2,
})).toEqual({
version: 1,
receiptId: 'local-execution:fallback-event-004',
receiptId: 'local-execution:fallback-event-004:executed',
eventId: 'event-004',
intent: 'navigate',
planId: 'fallback-event-004',
route: 'zero-core',
source: 'fallback',
outcome: 'executed',
executedAt: 2,
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')
})
})

302
product-source/hololake-platform/src/lib/guanghuLivingSystem.ts
View file

@ -34,6 +34,61 @@ export type GuanghuLivingScene = {
connectionEmphasis: LivingSceneConnectionEmphasis
}
export type GuanghuPersonaSystemContext = {
humanAnchorId: 'ICE-GL∞'
personaSystemId: 'ICE-P-ZY001'
memoryProtocolRoot: 'REPO-012'
modelInstanceId: string | null
}
export type GuanghuRuntimeBinding = {
bindingId: string
nodeId: string
personaSystemId: 'ICE-P-ZY001'
modelInstanceId: string
issuedByReceiptId: string
status: 'verified'
}
export type GuanghuKnowledgeState = {
selectedLakeId: string | null
mountedSources: string[]
}
export type GuanghuCapabilityId =
| 'navigation.apply'
| 'knowledge.open'
| 'agent.workspace.open'
| 'local.workspace.open'
| 'appearance.apply'
export type GuanghuCapabilityRegistration = {
id: GuanghuCapabilityId
inputType: 'NavigationAction' | 'CapabilityCall'
outputType: 'ReceiptSchema' | 'CapabilityCall'
requiresWorldOpen: boolean
}
export type GuanghuPermissionBoundary = {
allowedCapabilities: GuanghuCapabilityId[]
deniedCapabilities: string[]
}
export type GuanghuResponsibilityBoundary = {
controllerPersonaSystemId: 'ICE-P-ZY001'
humanAnchorId: 'ICE-GL∞'
executorRule: 'deterministic-host-only'
successRule: 'evidence-required'
}
export type GuanghuCurrentSystemState = {
currentRoute: GuanghuChannelRoute
requestedRoute: GuanghuChannelRoute
worldOpen: boolean
receiptIds: string[]
runtimeBinding: GuanghuRuntimeBinding | null
}
export type GuanghuLivingSystemEvent = {
eventId: string
intent: GuanghuLivingIntent
@ -43,6 +98,34 @@ export type GuanghuLivingSystemEvent = {
worldOpen: boolean
receiptIds: string[]
occurredAt: number
personaSystem: GuanghuPersonaSystemContext
currentSystemState: GuanghuCurrentSystemState
knowledgeState: GuanghuKnowledgeState
permissionBoundary: GuanghuPermissionBoundary
responsibilityBoundary: GuanghuResponsibilityBoundary
capabilityRegistry: GuanghuCapabilityRegistration[]
}
export type GuanghuUIProjection = {
route: GuanghuChannelRoute
scene: GuanghuLivingScene
stateLabel: 'local-safe' | 'model-proposed' | 'server-bound'
}
export type GuanghuNavigationAction = {
type: 'navigate'
route: GuanghuChannelRoute
}
export type GuanghuCapabilityCall = {
type: 'capability'
capabilityId: GuanghuCapabilityId
input: Record<string, unknown>
}
export type GuanghuReceiptSchema = {
outcome: 'pending-evidence'
requiredEvidence: string[]
}
export type GuanghuLivingSystemPlan = {
@ -50,9 +133,11 @@ export type GuanghuLivingSystemPlan = {
eventId: string
intent: GuanghuLivingIntent
planId: string
route: GuanghuChannelRoute
requiredTruth: string[]
scene: GuanghuLivingScene
uiProjection: GuanghuUIProjection
navigationAction: GuanghuNavigationAction
capabilityCall: GuanghuCapabilityCall | null
receiptSchema: GuanghuReceiptSchema
}
export type GuanghuLivingSystemExecutionReceipt = {
@ -63,17 +148,40 @@ export type GuanghuLivingSystemExecutionReceipt = {
planId: string
route: GuanghuChannelRoute
source: 'server' | 'model' | 'fallback'
outcome: 'executed'
executedAt: number
outcome: 'executed' | 'failed'
evidence: string[]
completedAt: number
error?: string
}
type CreateLivingSystemEventInput = Omit<GuanghuLivingSystemEvent, 'occurredAt'> & {
type CreateLivingSystemEventInput = Omit<
GuanghuLivingSystemEvent,
| 'occurredAt'
| 'personaSystem'
| 'currentSystemState'
| 'knowledgeState'
| 'permissionBoundary'
| 'responsibilityBoundary'
| 'capabilityRegistry'
> & {
now?: number
modelInstanceId?: string | null
runtimeBinding?: GuanghuRuntimeBinding | null
knowledgeState?: GuanghuKnowledgeState
}
export type LivingSystemPlanValidation =
| { accepted: true; plan: GuanghuLivingSystemPlan }
| { accepted: false; reason: 'event_mismatch' | 'intent_mismatch' | 'route_mismatch' | 'unverified_truth' | 'world_closed' }
| {
accepted: false
reason:
| 'event_mismatch'
| 'intent_mismatch'
| 'route_mismatch'
| 'unverified_truth'
| 'world_closed'
| 'capability_mismatch'
}
const PROTECTED_ROUTES = new Set<GuanghuChannelRoute>([
'fifth-domain',
@ -90,6 +198,39 @@ const SCENE_MOTIONS = new Set<LivingSceneMotion>(['quiet', 'responsive', 'active
const STAR_DENSITIES = new Set<LivingSceneStarDensity>(['sparse', 'balanced', 'rich'])
const CONNECTION_EMPHASES = new Set<LivingSceneConnectionEmphasis>(['contextual', 'active-route', 'network'])
const LIVING_INTENTS = new Set<GuanghuLivingIntent>(GUANGHU_LIVING_INTENTS)
const CAPABILITY_FOR_INTENT: Record<GuanghuLivingIntent, GuanghuCapabilityId> = {
navigate: 'navigation.apply',
'open-knowledge': 'knowledge.open',
'open-agent-workspace': 'agent.workspace.open',
'open-local-workspace': 'local.workspace.open',
'apply-theme': 'appearance.apply',
}
const CAPABILITY_REGISTRY: GuanghuCapabilityRegistration[] = [
{ id: 'navigation.apply', inputType: 'NavigationAction', outputType: 'ReceiptSchema', requiresWorldOpen: false },
{ id: 'knowledge.open', inputType: 'CapabilityCall', outputType: 'CapabilityCall', requiresWorldOpen: false },
{ id: 'agent.workspace.open', inputType: 'CapabilityCall', outputType: 'CapabilityCall', requiresWorldOpen: false },
{ id: 'local.workspace.open', inputType: 'CapabilityCall', outputType: 'CapabilityCall', requiresWorldOpen: false },
{ id: 'appearance.apply', inputType: 'CapabilityCall', outputType: 'CapabilityCall', requiresWorldOpen: false },
]
function verifiedRuntimeBinding(
binding: GuanghuRuntimeBinding | null | undefined,
receiptIds: string[],
): GuanghuRuntimeBinding | null {
if (
!binding
|| binding.status !== 'verified'
|| binding.personaSystemId !== 'ICE-P-ZY001'
|| binding.bindingId.length === 0
|| binding.nodeId.length === 0
|| binding.modelInstanceId.length === 0
|| binding.issuedByReceiptId.length === 0
|| !receiptIds.includes(binding.issuedByReceiptId)
) {
return null
}
return { ...binding }
}
function isStringArray(value: unknown): value is string[] {
return Array.isArray(value) && value.every(item => typeof item === 'string')
@ -99,26 +240,58 @@ function isRoute(value: unknown): value is GuanghuChannelRoute {
return typeof value === 'string' && (GUANGHU_CHANNEL_ROUTES as readonly string[]).includes(value)
}
function isLivingScene(value: unknown): value is GuanghuLivingScene {
if (!value || typeof value !== 'object') return false
const scene = value as Partial<GuanghuLivingScene>
return SCENE_DEPTHS.has(scene.depth!)
&& SCENE_MOTIONS.has(scene.motion!)
&& STAR_DENSITIES.has(scene.starDensity!)
&& CONNECTION_EMPHASES.has(scene.connectionEmphasis!)
}
function isCapabilityCall(value: unknown): value is GuanghuCapabilityCall | null {
if (value === null) return true
if (!value || typeof value !== 'object') return false
const call = value as Partial<GuanghuCapabilityCall>
return call.type === 'capability'
&& Object.values(CAPABILITY_FOR_INTENT).includes(call.capabilityId!)
&& Boolean(call.input)
&& typeof call.input === 'object'
&& !Array.isArray(call.input)
}
function isLivingSystemPlan(value: unknown): value is GuanghuLivingSystemPlan {
if (!value || typeof value !== 'object') return false
const candidate = value as Partial<GuanghuLivingSystemPlan>
const scene = candidate.scene
const projection = candidate.uiProjection
const navigation = candidate.navigationAction
const receipt = candidate.receiptSchema
return candidate.version === GUANGHU_LIVING_SYSTEM_VERSION
&& typeof candidate.eventId === 'string'
&& candidate.eventId.length > 0
&& LIVING_INTENTS.has(candidate.intent!)
&& typeof candidate.planId === 'string'
&& candidate.planId.length > 0
&& isRoute(candidate.route)
&& isStringArray(candidate.requiredTruth)
&& Boolean(scene)
&& SCENE_DEPTHS.has(scene!.depth)
&& SCENE_MOTIONS.has(scene!.motion)
&& STAR_DENSITIES.has(scene!.starDensity)
&& CONNECTION_EMPHASES.has(scene!.connectionEmphasis)
&& Boolean(projection)
&& isRoute(projection!.route)
&& isLivingScene(projection!.scene)
&& ['local-safe', 'model-proposed', 'server-bound'].includes(projection!.stateLabel)
&& Boolean(navigation)
&& navigation!.type === 'navigate'
&& isRoute(navigation!.route)
&& isCapabilityCall(candidate.capabilityCall)
&& Boolean(receipt)
&& receipt!.outcome === 'pending-evidence'
&& isStringArray(receipt!.requiredEvidence)
}
export function createLivingSystemEvent(input: CreateLivingSystemEventInput): GuanghuLivingSystemEvent {
const runtimeBinding = verifiedRuntimeBinding(input.runtimeBinding, input.receiptIds)
const allowedCapabilities = CAPABILITY_REGISTRY
.filter(capability => !capability.requiresWorldOpen || input.worldOpen)
.map(capability => capability.id)
const receiptIds = [...input.receiptIds]
return {
eventId: input.eventId,
intent: input.intent,
@ -126,8 +299,36 @@ export function createLivingSystemEvent(input: CreateLivingSystemEventInput): Gu
requestedRoute: input.requestedRoute,
...(input.appearanceTheme ? { appearanceTheme: input.appearanceTheme } : {}),
worldOpen: input.worldOpen,
receiptIds: [...input.receiptIds],
receiptIds,
occurredAt: input.now ?? Date.now(),
personaSystem: {
humanAnchorId: 'ICE-GL∞',
personaSystemId: 'ICE-P-ZY001',
memoryProtocolRoot: 'REPO-012',
modelInstanceId: input.modelInstanceId ?? runtimeBinding?.modelInstanceId ?? null,
},
currentSystemState: {
currentRoute: input.currentRoute,
requestedRoute: input.requestedRoute,
worldOpen: input.worldOpen,
receiptIds,
runtimeBinding,
},
knowledgeState: input.knowledgeState ?? {
selectedLakeId: null,
mountedSources: [],
},
permissionBoundary: {
allowedCapabilities,
deniedCapabilities: [],
},
responsibilityBoundary: {
controllerPersonaSystemId: 'ICE-P-ZY001',
humanAnchorId: 'ICE-GL∞',
executorRule: 'deterministic-host-only',
successRule: 'evidence-required',
},
capabilityRegistry: CAPABILITY_REGISTRY.map(capability => ({ ...capability })),
}
}
@ -146,16 +347,33 @@ export function validateLivingSystemPlan(
): LivingSystemPlanValidation {
if (!plan || plan.eventId !== event.eventId) return { accepted: false, reason: 'event_mismatch' }
if (plan.intent !== event.intent) return { accepted: false, reason: 'intent_mismatch' }
if (plan.route !== event.requestedRoute && plan.route !== 'world-login') {
if (
plan.uiProjection.route !== plan.navigationAction.route
|| (
plan.uiProjection.route !== event.requestedRoute
&& plan.uiProjection.route !== 'world-login'
)
) {
return { accepted: false, reason: 'route_mismatch' }
}
const suppliedTruth = new Set(event.receiptIds)
if (plan.requiredTruth.some(receiptId => !suppliedTruth.has(receiptId))) {
return { accepted: false, reason: 'unverified_truth' }
}
if (!event.worldOpen && PROTECTED_ROUTES.has(plan.route)) {
if (!event.worldOpen && PROTECTED_ROUTES.has(plan.uiProjection.route)) {
return { accepted: false, reason: 'world_closed' }
}
const expectedCapability = CAPABILITY_FOR_INTENT[event.intent]
if (
!event.permissionBoundary.allowedCapabilities.includes(expectedCapability)
|| (
event.intent === 'navigate'
? plan.capabilityCall !== null
: plan.capabilityCall?.capabilityId !== expectedCapability
)
) {
return { accepted: false, reason: 'capability_mismatch' }
}
return { accepted: true, plan }
}
@ -166,18 +384,39 @@ export function createDeterministicLivingSystemPlan(
? 'world-login'
: event.requestedRoute
const immersive = event.worldOpen && route !== 'world' && route !== 'world-login'
const capabilityId = CAPABILITY_FOR_INTENT[event.intent]
return {
version: GUANGHU_LIVING_SYSTEM_VERSION,
eventId: event.eventId,
intent: event.intent,
planId: `fallback-${event.eventId}`,
route,
requiredTruth: [],
scene: {
depth: immersive ? 'immersive' : route === 'world' ? 'overview' : 'focused',
motion: route === 'world' ? 'quiet' : 'responsive',
starDensity: immersive ? 'rich' : 'balanced',
connectionEmphasis: immersive ? 'active-route' : 'contextual',
uiProjection: {
route,
stateLabel: 'local-safe',
scene: {
depth: immersive ? 'immersive' : route === 'world' ? 'overview' : 'focused',
motion: route === 'world' ? 'quiet' : 'responsive',
starDensity: immersive ? 'rich' : 'balanced',
connectionEmphasis: immersive ? 'active-route' : 'contextual',
},
},
navigationAction: { type: 'navigate', route },
capabilityCall: event.intent === 'navigate'
? null
: {
type: 'capability',
capabilityId,
input: {
...(event.appearanceTheme ? { appearanceTheme: event.appearanceTheme } : {}),
requestedRoute: route,
},
},
receiptSchema: {
outcome: 'pending-evidence',
requiredEvidence: event.intent === 'navigate'
? ['ui.route.readback']
: [`capability.${capabilityId}.result`],
},
}
}
@ -185,21 +424,32 @@ export function createDeterministicLivingSystemPlan(
export function createLivingSystemExecutionReceipt({
plan,
source,
outcome,
evidence,
error,
now = Date.now(),
}: {
plan: GuanghuLivingSystemPlan
source: GuanghuLivingSystemExecutionReceipt['source']
outcome: GuanghuLivingSystemExecutionReceipt['outcome']
evidence: string[]
error?: string
now?: number
}): GuanghuLivingSystemExecutionReceipt {
if (outcome === 'executed' && evidence.length === 0) {
throw new Error('guanghu_living_system_success_evidence_required')
}
return {
version: GUANGHU_LIVING_SYSTEM_VERSION,
receiptId: `local-execution:${plan.planId}`,
receiptId: `local-execution:${plan.planId}:${outcome}`,
eventId: plan.eventId,
intent: plan.intent,
planId: plan.planId,
route: plan.route,
route: plan.uiProjection.route,
source,
outcome: 'executed',
executedAt: now,
outcome,
evidence: [...evidence],
completedAt: now,
...(error ? { error } : {}),
}
}