456 lines
14 KiB
TypeScript
456 lines
14 KiB
TypeScript
export const GUANGHU_LIVING_SYSTEM_VERSION = 1 as const
|
|
|
|
export const GUANGHU_CHANNEL_ROUTES = [
|
|
'world',
|
|
'world-login',
|
|
'zero-core',
|
|
'fifth-domain',
|
|
'pufferfish',
|
|
'eternal-lake-heart',
|
|
'light-lake',
|
|
'heartbeat-core',
|
|
'education-work-lake',
|
|
'love-core',
|
|
'servers',
|
|
] as const
|
|
|
|
export type GuanghuChannelRoute = typeof GUANGHU_CHANNEL_ROUTES[number]
|
|
export type LivingSceneDepth = 'overview' | 'focused' | 'immersive'
|
|
export type LivingSceneMotion = 'quiet' | 'responsive' | 'active'
|
|
export type LivingSceneStarDensity = 'sparse' | 'balanced' | 'rich'
|
|
export type LivingSceneConnectionEmphasis = 'contextual' | 'active-route' | 'network'
|
|
export const GUANGHU_LIVING_INTENTS = [
|
|
'navigate',
|
|
'open-knowledge',
|
|
'open-agent-workspace',
|
|
'open-local-workspace',
|
|
'apply-theme',
|
|
] as const
|
|
export type GuanghuLivingIntent = typeof GUANGHU_LIVING_INTENTS[number]
|
|
|
|
export type GuanghuLivingScene = {
|
|
depth: LivingSceneDepth
|
|
motion: LivingSceneMotion
|
|
starDensity: LivingSceneStarDensity
|
|
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
|
|
currentRoute: GuanghuChannelRoute
|
|
requestedRoute: GuanghuChannelRoute
|
|
appearanceTheme?: string
|
|
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 = {
|
|
version: typeof GUANGHU_LIVING_SYSTEM_VERSION
|
|
eventId: string
|
|
intent: GuanghuLivingIntent
|
|
planId: string
|
|
requiredTruth: string[]
|
|
uiProjection: GuanghuUIProjection
|
|
navigationAction: GuanghuNavigationAction
|
|
capabilityCall: GuanghuCapabilityCall | null
|
|
receiptSchema: GuanghuReceiptSchema
|
|
}
|
|
|
|
export type GuanghuLivingSystemExecutionReceipt = {
|
|
version: typeof GUANGHU_LIVING_SYSTEM_VERSION
|
|
receiptId: string
|
|
eventId: string
|
|
intent: GuanghuLivingIntent
|
|
planId: string
|
|
route: GuanghuChannelRoute
|
|
source: 'server' | 'model' | 'fallback'
|
|
outcome: 'executed' | 'failed'
|
|
evidence: string[]
|
|
completedAt: number
|
|
error?: string
|
|
}
|
|
|
|
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'
|
|
| 'capability_mismatch'
|
|
}
|
|
|
|
const PROTECTED_ROUTES = new Set<GuanghuChannelRoute>([
|
|
'fifth-domain',
|
|
'pufferfish',
|
|
'eternal-lake-heart',
|
|
'light-lake',
|
|
'heartbeat-core',
|
|
'love-core',
|
|
'servers',
|
|
])
|
|
|
|
const SCENE_DEPTHS = new Set<LivingSceneDepth>(['overview', 'focused', 'immersive'])
|
|
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')
|
|
}
|
|
|
|
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 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
|
|
&& isStringArray(candidate.requiredTruth)
|
|
&& 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,
|
|
currentRoute: input.currentRoute,
|
|
requestedRoute: input.requestedRoute,
|
|
...(input.appearanceTheme ? { appearanceTheme: input.appearanceTheme } : {}),
|
|
worldOpen: input.worldOpen,
|
|
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 })),
|
|
}
|
|
}
|
|
|
|
export function parseLivingSystemPlan(output: string): GuanghuLivingSystemPlan | null {
|
|
try {
|
|
const parsed: unknown = JSON.parse(output.trim())
|
|
return isLivingSystemPlan(parsed) ? parsed : null
|
|
} catch {
|
|
return null
|
|
}
|
|
}
|
|
|
|
export function validateLivingSystemPlan(
|
|
event: GuanghuLivingSystemEvent,
|
|
plan: GuanghuLivingSystemPlan | null,
|
|
): 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.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.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 }
|
|
}
|
|
|
|
export function createDeterministicLivingSystemPlan(
|
|
event: GuanghuLivingSystemEvent,
|
|
): GuanghuLivingSystemPlan {
|
|
const route = !event.worldOpen && PROTECTED_ROUTES.has(event.requestedRoute)
|
|
? '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}`,
|
|
requiredTruth: [],
|
|
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`],
|
|
},
|
|
}
|
|
}
|
|
|
|
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}:${outcome}`,
|
|
eventId: plan.eventId,
|
|
intent: plan.intent,
|
|
planId: plan.planId,
|
|
route: plan.uiProjection.route,
|
|
source,
|
|
outcome,
|
|
evidence: [...evidence],
|
|
completedAt: now,
|
|
...(error ? { error } : {}),
|
|
}
|
|
}
|