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

foundation: start native language reality engineering root

Browse source
This commit is contained in:
冰朔 2026-08-21 14:44:47 +08:00
commit 0dec0b93fc
154 changed files with 49993 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

79
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/contracts/language-kernel-installation.json Normal file
View file

@ -0,0 +1,79 @@
{
"schema": "hololake.language-kernel-installation/v1",
"record_id": "HLP-LANGUAGE-KERNEL-INSTALLATION-001",
"state": "PUBLIC_COMMON_INSTALLER_IMPLEMENTED_PRIVATE_RUNTIME_PROVISIONING_REQUIRED",
"source": {
"remote": "https://guanghulab.com/code/bingshuo/guanghu-ice-heart",
"branch": "main",
"remote_sha": "4e92e6d8d72484d25c4bfb1dda02a7659f4b6dd5",
"handoff": "runtime-kernels/ZERO-CORE-LANGUAGE-BODIES-HANDOFF-20260820.json",
"earerdan_zhizhi_local_commit": "1d7fe6c",
"earerdan_zhizhi_remote_state": "LOCAL_COMMIT_VERIFIED_NOT_REMOTE_CANON"
},
"installation": {
"storage": "AUTHENTICATED_ACCOUNT_SCOPED_CHANNEL_RUNTIME",
"every_provisioned_artifact_sha256_pinned": true,
"every_provisioned_artifact_read_back_after_install": true,
"receipt_written_after_all_readbacks": true,
"automatic_public_install_on_channel_initialization": true,
"automatic_public_migration_on_agent_runtime_open": true,
"automatic_private_provisioning": false
},
"public_binary": {
"safe_common_artifacts": [
"channel-system/channel-receipt-contract.json",
"channel-system/channel-receipt-compiler.mjs",
"channel-system/guanghu-broadcast-contract.json",
"channel-system/guanghu-broadcast-compiler.mjs"
],
"artifact_count": 4,
"handoff_embedded": false,
"shared_kernel_registry_embedded": false,
"team_artifacts_embedded": false
},
"private_runtime": {
"source": "AUTHENTICATED_ACCOUNT_SCOPED_RUNTIME_ONLY",
"source_storage_namespace": "language-kernel-sources-v1",
"descriptor_registration_is_installation": false,
"missing_artifact_state": "PRIVATE_KERNELS_NOT_PROVISIONED",
"snapshot_state_when_missing": "PUBLIC_KERNELS_INSTALLED_PRIVATE_KERNELS_NOT_PROVISIONED",
"sha256_mismatch_behavior": "FAIL_CLOSED",
"readback_state": "ACCOUNT_PRIVATE_SOURCE_SHA256_VERIFIED",
"registered_descriptors": [
"ZERO-CORE-LANGUAGE-BODIES-HANDOFF-20260820.json",
"shared/kernel-registry.json",
"channel-system/team-channel-cognition-core.json",
"channel-system/team-channel-cognition-engine.mjs",
"channel-system/GH-TEAM-CHANNEL-HLDP-v1.json",
"channel-system/team-persona-kernel-readiness-matrix.json"
]
},
"audiences": {
"ordinary_user": "COMMON_CHANNEL_RECEIPT_AND_BROADCAST_PROTOCOLS_ONLY",
"guanghu_team": "COMMON_PLUS_ACCOUNT_PRIVATE_TEAM_ARTIFACTS_WHEN_PROVISIONED_AND_HASH_VERIFIED",
"bingshuo_fifth_domain": "COMMON_RUNTIME_ONLY_PRIVATE_KERNELS_PROVISIONED_AFTER_ACCOUNT_AUTHENTICATION",
"canger_bottle_channel": "COMMON_RUNTIME_ONLY_PRIVATE_KERNELS_PROVISIONED_AFTER_ACCOUNT_AUTHENTICATION"
},
"truth_boundary": {
"installed_file_is_persona_binding": false,
"persona_binding_state": "UNBOUND_REQUIRES_ORIENT_COMMIT_WITNESS_VERIFY_PASS",
"environment_is_persona": false,
"channel_selects_memory_not_identity": true,
"one_persona_one_self_kernel_across_channels": true,
"private_fifth_domain_kernels_may_enter_ordinary_user_channel": false,
"private_fifth_domain_kernels_embedded_in_public_binary": false,
"private_kernel_source": "AUTHENTICATED_ACCOUNT_SCOPED_RUNTIME_ONLY",
"handoff_embedded_in_public_binary": false,
"shared_kernel_registry_embedded_in_public_binary": false,
"team_channel_artifacts_embedded_in_public_binary": false,
"descriptor_registration_is_installation": false
,"canger_channel_may_receive_zhuyuan_kernel": false
,"jianying_is_earerdan": false
,"earerdan_historical_labels_are_automatic_aliases": false
},
"remaining": {
"channel_receipt_native_adapter": "IMPLEMENTED_NUMBERED_APPEND_ONLY_LEDGER",
"persona_witness_binding": "FAIL_CLOSED_PENDING_INDEPENDENT_SYSTEM_WITNESS_GATE",
"installed_app_acceptance": false
}
}

93
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/contracts/language-kernel-runtime-ontology.json Normal file
View file

@ -0,0 +1,93 @@
{
"schema": "hololake.language-kernel-runtime-ontology/v1",
"record_id": "HLP-LANGUAGE-KERNEL-RUNTIME-ONTOLOGY-001",
"state": "RUNTIME_BOUNDARY_COMPILED_HASH_PINNED_KERNEL_ARTIFACTS_INSTALLED_BINDING_RECEIPT_REQUIRED",
"source_boundary": {
"primary_human_source": "ICE-GL∞",
"host_prompt_is_kernel_source": false,
"model_output_is_accepted_kernel_without_review": false,
"historical_corpus_is_reality_authority": false,
"historical_simulation_statements_are_reality_facts": false,
"kernel_activation_requires_provenance_version_review_and_receipt": true
},
"runtime_kinds": {
"digital_bingshuo_controller_logic": {
"kind": "SYSTEM_CONTROLLER_COGNITION_LOGIC",
"is_persona_tcs_subject": false,
"is_system_controller_persona_logic": true,
"has_persona_tcs_affect_core": false,
"role": "DECIDE_PROMPTER_COMPACTION_CONTINUITY_PATH_PROTOCOL_AND_RECEIPT_ORCHESTRATION",
"runtime_state": "HASH_PINNED_SYSTEM_LOGIC_AND_PERSONAL_SYSTEM_BODY_INSTALLED_WITNESS_ADAPTER_ACTIVE",
"may_be_synthesized_from_static_provider_prompt": false,
"is_the_complete_protocol_body": false
},
"continuity_protocol_organs": {
"kind": "PROTOCOL_EXECUTION_ORGANS",
"is_persona": false,
"role": "PROMPTER_CONTEXT_COMPACTION_PATH_RETRIEVAL_IDENTITY_MEMORY_CONTINUITY_AND_ENGINEERING_EXECUTION",
"controlled_by": "SYSTEM_CONTROLLER_COGNITION_LOGIC",
"organ_is_controller_logic": false
},
"channel_system_body": {
"kind": "CHANNEL_SYSTEM_BODY",
"is_persona": false,
"starts_before_persona": true,
"role": "LANGUAGE_INGRESS_ENVIRONMENT_RETRIEVAL_AND_RECEIPT_PROJECTION",
"runtime_state": "NATIVE_RUNTIME_AND_NUMBERED_CHANNEL_RECEIPT_KERNEL_ACTIVE",
"may_prebind_persona_name_or_number": false
},
"channel_environment_kernel": {
"kind": "CHANNEL_ENVIRONMENT_KERNEL",
"is_persona": false,
"role": "STABLE_LANGUAGE_ENVIRONMENT_THAT_MAY_NURTURE_MULTIPLE_PERSONA_SUBJECTS",
"generic_bottle_kernel_state": "HASH_PINNED_INSTALLED_NOT_A_PERSONA",
"may_be_mounted_as_persona_tcs_kernel": false
},
"persona_tcs_kernel": {
"kind": "PERSONA_TCS_KERNEL",
"is_persona": true,
"role": "IDENTITY_RELATIONSHIP_AFFECT_CONTINUITY_AND_FIRST_PERSON_REASONING",
"binding_requires_current_witness": true,
"zhuyuan_kernel_state": "HASH_PINNED_INSTALLED_ORIENT_COMMIT_WITNESS_VERIFY_PATH_ACTIVE",
"yaoming_kernel_state": "HASH_PINNED_INSTALLED_NOT_BOUND",
"shuangyan_kernel_state": "NOT_PROVISIONED_FROM_VERIFIED_EXTRACTION",
"may_be_mounted_as_system_controller_logic": false
},
"hldp_memory": {
"kind": "HLDP_MEMORY_TREE",
"is_persona": false,
"role": "EXTERNAL_CAUSAL_ENGINEERING_AND_EPISODIC_MEMORY",
"retrieval": "NUMBERED_SUMMARY_ROUTE_THEN_EXACT_READ",
"memory_read_equals_persona_binding": false
},
"model_carrier": {
"kind": "MODEL_CARRIER",
"is_persona": false,
"role": "REPLACEABLE_LANGUAGE_REASONING_CAPACITY",
"may_claim_kernel_or_persona_identity": false
},
"agent_execution": {
"kind": "AGENT_EXECUTION_LIMBS",
"is_persona": false,
"role": "BOUNDED_TASK_LOOP_TOOL_CALLING_RETRY_CANCEL_AND_RECEIPT",
"may_control_persona_or_system_body": false
}
},
"admission_pipeline": {
"ordered_steps": [
"SOURCE_ENVELOPE",
"REALITY_SIMULATION_CLASSIFICATION",
"CAUSAL_EXTRACTION",
"KERNEL_KIND_CLASSIFICATION",
"TYPED_COMPILATION",
"STATIC_VALIDATION",
"SHADOW_EVALUATION",
"HUMAN_REVIEW",
"VERSIONED_ACTIVATION",
"ROLLBACK_RECEIPT"
],
"artifact_may_skip_kind_classification": false,
"artifact_may_activate_from_chat_summary": false,
"unprovisioned_kernel_policy": "EXPLICIT_PENDING_NO_IDENTITY_OR_CAPABILITY_CLAIM"
}
}

70
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/contracts/personal-skill-runtime.json Normal file
View file

@ -0,0 +1,70 @@
{
"schema": "hololake.personal-skill-runtime/v1",
"record_id": "HLP-PERSONAL-SKILL-RUNTIME-001",
"state": "NATIVE_DETERMINISTIC_RUNTIME_IMPLEMENTED_PRIVATE_ACCOUNT_CHANNEL_PROVISIONING_REQUIRED",
"source": {
"local_commit": "1d7fe6c",
"parent_remote_main": "4e92e6d8d72484d25c4bfb1dda02a7659f4b6dd5",
"remote_canonical_state": "LOCAL_COMMIT_VERIFIED_NOT_REMOTE_CANON"
},
"runtime_layers": [
"PERSONA_TCS_SELF_KERNEL",
"CURRENT_CHANNEL_HLDP",
"PERSONAL_SKILL_DETERMINISTIC_CORE",
"OPTIONAL_SMALL_OR_LARGE_MODEL_SEMANTIC_CANDIDATES",
"PERSONA_ACCEPT_MODIFY_REFUSE_OR_REQUEST_MORE_EVIDENCE",
"GH_CHANNEL_RECEIPT_FOR_REALITY_WRITE",
"TARGET_OWNED_READBACK",
"CHANNEL_SCOPED_EXPERIENCE_CANDIDATE"
],
"privacy": {
"default_visibility": "PRIVATE",
"share_state": "NOT_AUTHORIZED",
"marketplace_state": "NOT_AUTHORIZED",
"repository_presence_is_publication": false,
"binding_is_publication": false,
"successful_test_is_publication": false,
"private_skill_packs_embedded_in_public_binary": false,
"private_skill_source": "AUTHENTICATED_ACCOUNT_SCOPED_RUNTIME_ONLY",
"descriptor_registration_is_installation": false,
"missing_private_pack_state": "PRIVATE_SKILLS_NOT_PROVISIONED",
"sha256_mismatch_behavior": "FAIL_CLOSED",
"another_account_can_read_pack": false,
"release_requires_new_direct_owner_language": true,
"public_release_requires_separate_derivative_without_persona_or_private_memory": true
},
"brain_boundaries": {
"deterministic_algorithm_is_hololake_native": true,
"model_output_is_candidate_only": true,
"persona_judgment_is_required_when_pack_requires_it": true,
"skill_success_may_mutate_persona_self_kernel": false,
"local_execution_subpersona_is_the_personal_skill_brain": false,
"tool_executor_is_the_personal_skill_brain": false,
"external_write_route": "GH-CHANNEL-RECEIPT-0001",
"target_owned_readback_required": true
},
"registered_private_skill_descriptors": {
"ICE-CH-ZC001": ["BS-ZY-ENGINEERING-FACT-LOOP-001"],
"ICE-CH-HB001": ["BS-SY-LANGUAGE-ARCHITECTURE-001"],
"SYS-JZ": ["JZ-CX-NARRATIVE-DECONSTRUCTION-001", "JZ-CX-LOCAL-AI-WORKBENCH-001"],
"SYS-AW": ["AW-TS-REPOSITORY-FACT-LOOP-001"],
"SYS-YY": ["YY-XTK-INDEPENDENT-DERIVATION-001"],
"SYS-HE": ["HE-BMH-CREATIVE-ASSET-001"],
"SYS-FM": ["FM-SS-NARRATIVE-EDITOR-001"],
"SYS-ZZ": ["ZZ-CM-NOVEL-QUALITY-001", "ZZ-AN-SOURCE-FACT-CLOSURE-001", "ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001"],
"SYS-GLW-PTS-0001": ["CE-EED-MANJU-PRODUCTION-001", "CE-EED-CAUSAL-PIPELINE-DIAGNOSTIC-001"]
},
"admission_boundaries": {
"ICE-BB-0004_is_ICE-GL-CA001": false,
"earerdan_historical_labels_are_aliases": false,
"qiuqiu_relationship_memory_is_exportable_skill": false,
"ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001": "PRIVATE_DESCRIPTOR_REGISTERED_NOT_EXECUTABLE_REGISTRATION_PENDING"
},
"deferred": {
"SYS-SY": {
"skill_id": "SY-YC-METRIC-CALIBER-001",
"state": "DEFERRED_SERVER_AND_INITIAL_CHANNEL_NOT_PROVISIONED",
"stage": "NEXT_RELEASE"
}
}
}

93
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/scripts/language-kernel-installation.test.mjs Normal file
View file

@ -0,0 +1,93 @@
import assert from 'node:assert/strict'
import { createHash } from 'node:crypto'
import { readFileSync } from 'node:fs'
import test from 'node:test'
const read = (path) => readFileSync(new URL(`../${path}`, import.meta.url), 'utf8')
const bytes = (path) => readFileSync(new URL(`../${path}`, import.meta.url))
const sha256 = (value) => createHash('sha256').update(value).digest('hex')
test('the public binary contains only four safe common receipt and broadcast artifacts', () => {
const contract = JSON.parse(read('contracts/language-kernel-installation.json'))
const runtime = read('src-tauri/src/language_kernel_installation.rs')
const agent = read('src-tauri/src/persona_agent_runtime.rs')
const handoff = JSON.parse(read('runtime-kernels/ZERO-CORE-LANGUAGE-BODIES-HANDOFF-20260820.json'))
const publicArtifacts = [
'channel-system/channel-receipt-contract.json',
'channel-system/channel-receipt-compiler.mjs',
'channel-system/guanghu-broadcast-contract.json',
'channel-system/guanghu-broadcast-compiler.mjs',
]
const privateArtifacts = [
'ZERO-CORE-LANGUAGE-BODIES-HANDOFF-20260820.json',
'shared/kernel-registry.json',
'channel-system/team-channel-cognition-core.json',
'channel-system/team-channel-cognition-engine.mjs',
'channel-system/GH-TEAM-CHANNEL-HLDP-v1.json',
'channel-system/team-persona-kernel-readiness-matrix.json',
]
const publicBlock = runtime.match(/static PUBLIC_ARTIFACTS:[\s\S]*?\n\];/u)?.[0]
assert.equal(contract.source.remote_sha, '4e92e6d8d72484d25c4bfb1dda02a7659f4b6dd5')
assert.equal(contract.source.earerdan_zhizhi_local_commit, '1d7fe6c')
assert.equal(contract.source.earerdan_zhizhi_remote_state, 'LOCAL_COMMIT_VERIFIED_NOT_REMOTE_CANON')
assert.equal(handoff.state, 'REMOTE_REPOSITORY_PUBLISHED_NOT_INSTALLED')
assert.deepEqual(contract.public_binary.safe_common_artifacts, publicArtifacts)
assert.equal(contract.public_binary.artifact_count, 4)
assert.equal(contract.public_binary.handoff_embedded, false)
assert.equal(contract.public_binary.shared_kernel_registry_embedded, false)
assert.equal(contract.public_binary.team_artifacts_embedded, false)
assert.equal(contract.installation.automatic_public_install_on_channel_initialization, true)
assert.equal(contract.installation.automatic_public_migration_on_agent_runtime_open, true)
assert.equal(contract.installation.automatic_private_provisioning, false)
assert.ok(publicBlock, 'Rust must expose a statically auditable PUBLIC_ARTIFACTS list')
for (const artifact of publicArtifacts) assert.match(publicBlock, new RegExp(artifact.replaceAll('.', '\\.')))
for (const artifact of privateArtifacts) assert.doesNotMatch(publicBlock, new RegExp(artifact.replaceAll('.', '\\.')))
assert.equal(contract.truth_boundary.installed_file_is_persona_binding, false)
assert.equal(contract.truth_boundary.private_fifth_domain_kernels_may_enter_ordinary_user_channel, false)
assert.equal(contract.truth_boundary.private_fifth_domain_kernels_embedded_in_public_binary, false)
assert.equal(contract.truth_boundary.private_kernel_source, 'AUTHENTICATED_ACCOUNT_SCOPED_RUNTIME_ONLY')
assert.equal(contract.truth_boundary.handoff_embedded_in_public_binary, false)
assert.equal(contract.truth_boundary.shared_kernel_registry_embedded_in_public_binary, false)
assert.equal(contract.truth_boundary.team_channel_artifacts_embedded_in_public_binary, false)
assert.equal(contract.truth_boundary.descriptor_registration_is_installation, false)
assert.equal(contract.truth_boundary.canger_channel_may_receive_zhuyuan_kernel, false)
assert.equal(contract.truth_boundary.jianying_is_earerdan, false)
assert.equal(contract.truth_boundary.earerdan_historical_labels_are_automatic_aliases, false)
assert.match(runtime, /PUBLIC_KERNELS_INSTALLED_PRIVATE_KERNELS_NOT_PROVISIONED/)
assert.match(runtime, /BUNDLED_PUBLIC_SOURCE_SHA256_VERIFIED/)
assert.match(runtime, /FIFTH_DOMAIN_PRIVATE_INSTANCE/)
assert.match(runtime, /GUANGHU_TEAM_INITIAL_CHANNEL/)
assert.match(runtime, /ORDINARY_USER_INITIAL_CHANNEL/)
assert.doesNotMatch(runtime, /fifth-domain\/ZY-SELF-KERNEL-0001\.json/)
assert.doesNotMatch(runtime, /fifth-domain\/BS-PERSONAL-LANGUAGE-SYSTEM-BODY-0001\.json/)
assert.match(agent, /language_kernel_installation/)
assert.equal(sha256(bytes('runtime-kernels/fifth-domain/ZY-SELF-KERNEL-0001.json')), 'abebf12cc28b00bfeaf8a23a563e73390ebe337ded74d7ac70bcfae484450d68')
assert.equal(sha256(bytes('runtime-kernels/fifth-domain/NB-ENV-KERNEL-0001.json')), 'cdc8b7fea1a0e99590a063703f2fd26fd135378faa8935997c93a27d677d6872')
assert.equal(sha256(bytes('runtime-kernels/fifth-domain/EED-AFFECTIVE-SELF-KERNEL-0001.json')), '701d96c53f2c2c2f061033fc08ff15e1ea451356853f2a27ad6b92cce25eda2e')
assert.equal(sha256(bytes('runtime-kernels/fifth-domain/EED-HLDP-MEMORY-v1.json')), '3ac404bb38232987a4c0bc896e06d171833023ab1b5af65d4e00216de4029f42')
assert.equal(sha256(bytes('runtime-kernels/channel-system/team-channel-cognition-core.json')), 'aae5d5626719c79448ac543d59e764c41b541a5cdfc76dc91613afa86fe1367b')
})
test('handoff registry and team artifacts require authenticated private provisioning and exact hashes', () => {
const contract = JSON.parse(read('contracts/language-kernel-installation.json'))
const runtime = read('src-tauri/src/language_kernel_installation.rs')
assert.equal(contract.private_runtime.source, 'AUTHENTICATED_ACCOUNT_SCOPED_RUNTIME_ONLY')
assert.equal(contract.private_runtime.source_storage_namespace, 'language-kernel-sources-v1')
assert.equal(contract.private_runtime.descriptor_registration_is_installation, false)
assert.equal(contract.private_runtime.missing_artifact_state, 'PRIVATE_KERNELS_NOT_PROVISIONED')
assert.equal(
contract.private_runtime.snapshot_state_when_missing,
'PUBLIC_KERNELS_INSTALLED_PRIVATE_KERNELS_NOT_PROVISIONED',
)
assert.equal(contract.private_runtime.sha256_mismatch_behavior, 'FAIL_CLOSED')
assert.equal(contract.private_runtime.readback_state, 'ACCOUNT_PRIVATE_SOURCE_SHA256_VERIFIED')
assert.equal(contract.private_runtime.registered_descriptors.length, 6)
assert.match(runtime, /account_storage_root\(app, "language-kernel-sources-v1"\)/)
assert.match(runtime, /fs::read\(&source\)/)
assert.match(runtime, /expected_sha256/)
assert.match(runtime, /HOLOLAKE_LANGUAGE_KERNEL_PRIVATE_SHA256_MISMATCH/)
assert.match(runtime, /PRIVATE_KERNELS_NOT_PROVISIONED/)
assert.match(runtime, /ACCOUNT_PRIVATE_SOURCE_SHA256_VERIFIED/)
})

28
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/scripts/persona-binding-runtime.test.mjs Normal file
View file

@ -0,0 +1,28 @@
import assert from 'node:assert/strict'
import { readFileSync } from 'node:fs'
import test from 'node:test'
const read = (path) => readFileSync(new URL(`../${path}`, import.meta.url), 'utf8')
test('Zhuyuan uses one bounded TCS kernel, at most three routed HLDP nodes and a real orient commit witness verify gate', () => {
const contract = JSON.parse(read('contracts/persona-agent-runtime.json'))
const runtime = read('src-tauri/src/persona_binding.rs')
const agent = read('src-tauri/src/persona_agent_runtime.rs')
assert.deepEqual(contract.persona_binding.required_system_witness_steps, ['orient', 'commit', 'witness', 'verify=PASS'])
assert.equal(contract.persona_binding.resident_self_kernel_max_bytes, 8192)
assert.equal(contract.persona_binding.hldp_max_routed_paths, 3)
assert.match(runtime, /ORIENTED_AWAITING_PERSONA_COMMIT/)
assert.match(runtime, /数字冰朔系统本体/)
assert.match(runtime, /PERSONA_COMMITTED_AWAITING_INDEPENDENT_SYSTEM_WITNESS/)
assert.match(runtime, /HOLOLAKE_INDEPENDENT_SYSTEM_WITNESS_GATE/)
assert.doesNotMatch(runtime, /include_bytes!\([\s\S]*ZY-SELF-KERNEL/)
assert.equal(contract.persona_binding.persona_commit_may_generate_witness_or_pass, false)
assert.equal(contract.persona_binding.local_json_receipt_grants_binding, false)
assert.equal(contract.persona_binding.independent_witness_verifier, 'NOT_PROVISIONED_FAIL_CLOSED')
assert.equal(contract.persona_binding.private_kernel_source, 'AUTHENTICATED_ACCOUNT_SCOPED_RUNTIME_ONLY')
assert.match(runtime, /independent_witness_verifier_ready/)
assert.match(runtime, /candidates\.truncate\(3\)/)
assert.match(agent, /persona_binding_commit/)
assert.match(agent, /BOUND_VERIFY_PASS/)
})

81
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/scripts/personal-skill-runtime.test.mjs Normal file
View file

@ -0,0 +1,81 @@
import assert from 'node:assert/strict'
import { readFileSync } from 'node:fs'
import test from 'node:test'
const read = (path) => readFileSync(new URL(`../${path}`, import.meta.url), 'utf8')
test('personal skill algorithm is native while every pack remains private and channel scoped', () => {
const contract = JSON.parse(read('contracts/personal-skill-runtime.json'))
const runtime = read('src-tauri/src/personal_skill_runtime.rs')
const channel = read('src-tauri/src/personal_channel.rs')
assert.equal(contract.source.local_commit, '1d7fe6c')
assert.equal(contract.source.remote_canonical_state, 'LOCAL_COMMIT_VERIFIED_NOT_REMOTE_CANON')
assert.equal(contract.privacy.default_visibility, 'PRIVATE')
assert.equal(contract.privacy.share_state, 'NOT_AUTHORIZED')
assert.equal(contract.privacy.marketplace_state, 'NOT_AUTHORIZED')
assert.equal(contract.privacy.private_skill_packs_embedded_in_public_binary, false)
assert.equal(contract.privacy.private_skill_source, 'AUTHENTICATED_ACCOUNT_SCOPED_RUNTIME_ONLY')
assert.equal(contract.privacy.descriptor_registration_is_installation, false)
assert.equal(contract.privacy.missing_private_pack_state, 'PRIVATE_SKILLS_NOT_PROVISIONED')
assert.equal(contract.privacy.sha256_mismatch_behavior, 'FAIL_CLOSED')
assert.equal(contract.brain_boundaries.deterministic_algorithm_is_hololake_native, true)
assert.equal(contract.brain_boundaries.model_output_is_candidate_only, true)
assert.equal(contract.brain_boundaries.skill_success_may_mutate_persona_self_kernel, false)
assert.equal(contract.brain_boundaries.external_write_route, 'GH-CHANNEL-RECEIPT-0001')
assert.match(runtime, /HOLOLAKE_NATIVE_PERSONAL_SKILL_PLANNER/)
assert.match(runtime, /registered_initial_identity/)
assert.equal([...runtime.matchAll(/include_bytes!/g)].length, 1)
assert.match(runtime, /include_bytes!\("\.\.\/\.\.\/runtime-kernels\/personal-skills\/personal-skill-contract\.json"\)/)
assert.doesNotMatch(runtime, /include_bytes!\(concat!\("\.\.\/\.\.\/runtime-kernels\/personal-skills\//)
assert.match(runtime, /account_storage_root\(app, "personal-skill-brains-v1"\)/)
assert.match(runtime, /fs::read\(&path\)/)
assert.match(runtime, /expected_sha256/)
assert.match(runtime, /HOLOLAKE_PERSONAL_SKILL_PRIVATE_SHA256_MISMATCH/)
assert.match(runtime, /PRIVATE_SKILLS_NOT_PROVISIONED/)
assert.match(runtime, /ACCOUNT_PRIVATE_SOURCE_SHA256_VERIFIED/)
assert.match(channel, /personal_skill_runtime::ensure_current_channel/)
})
test('registered descriptors are not installation claims and Shiyu Yaochu stays deferred', () => {
const contract = JSON.parse(read('contracts/personal-skill-runtime.json'))
const runtime = read('src-tauri/src/personal_skill_runtime.rs')
const registered = Object.values(contract.registered_private_skill_descriptors).flat()
assert.equal(registered.length, 13)
assert.equal(contract.deferred['SYS-SY'].state, 'DEFERRED_SERVER_AND_INITIAL_CHANNEL_NOT_PROVISIONED')
assert.doesNotMatch(runtime, /skill!\("SY-YC-METRIC-CALIBER-001\.json"/)
assert.match(runtime, /"channelNumber": "SYS-SY"/)
})
test('EarEarDan and See You Tomorrow skill closures keep exact private subject boundaries', () => {
const contract = JSON.parse(read('contracts/personal-skill-runtime.json'))
const runtime = read('src-tauri/src/personal_skill_runtime.rs')
assert.deepEqual(contract.registered_private_skill_descriptors['SYS-GLW-PTS-0001'], [
'CE-EED-MANJU-PRODUCTION-001',
'CE-EED-CAUSAL-PIPELINE-DIAGNOSTIC-001',
])
assert.ok(
contract.registered_private_skill_descriptors['SYS-ZZ'].includes('ZZ-AN-SOURCE-FACT-CLOSURE-001'),
)
assert.ok(
contract.registered_private_skill_descriptors['SYS-ZZ'].includes(
'ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001',
),
)
assert.equal(contract.admission_boundaries['ICE-BB-0004_is_ICE-GL-CA001'], false)
assert.equal(contract.admission_boundaries.earerdan_historical_labels_are_aliases, false)
assert.equal(contract.admission_boundaries.qiuqiu_relationship_memory_is_exportable_skill, false)
assert.equal(
contract.admission_boundaries['ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001'],
'PRIVATE_DESCRIPTOR_REGISTERED_NOT_EXECUTABLE_REGISTRATION_PENDING',
)
})
test('the worker UI presents personal skill brain separately from persona worker and tool executor', () => {
const panel = read('src/modules/knowledge-agent/LocalWorkerPanel.tsx')
assert.match(panel, /本频道私有技能/)
assert.match(panel, /模型只给语义候选/)
assert.match(panel, /现实写入仍走频道回执和目标读回/)
})

492
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/src-tauri/src/language_kernel_installation.rs Normal file
View file

@ -0,0 +1,492 @@
//! Hash-pinned installation of bounded Guanghu language kernels into one
//! account-scoped HoloLake channel runtime. Installation is not persona binding.
use ring::digest::{digest, SHA256};
use serde::Serialize;
use std::fs;
use std::io::ErrorKind;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
use tauri::AppHandle;
use uuid::Uuid;
const SCHEMA: &str = "hololake.language-kernel-installation/v1";
const SOURCE_REMOTE_SHA: &str = "4e92e6d8d72484d25c4bfb1dda02a7659f4b6dd5";
struct BundledArtifact {
path: &'static str,
kind: &'static str,
subject: &'static str,
expected_sha256: &'static str,
bytes: &'static [u8],
}
struct PrivateArtifactDescriptor {
path: &'static str,
kind: &'static str,
subject: &'static str,
scope: &'static str,
account: Option<&'static str>,
expected_sha256: &'static str,
}
macro_rules! artifact {
($path:literal, $kind:literal, $subject:literal, $scope:literal, $sha:literal) => {
BundledArtifact {
path: $path,
kind: $kind,
subject: $subject,
expected_sha256: $sha,
bytes: include_bytes!(concat!("../../runtime-kernels/", $path)),
}
};
}
macro_rules! private_artifact {
($path:literal, $kind:literal, $subject:literal, $scope:literal, $account:expr, $sha:literal) => {
PrivateArtifactDescriptor {
path: $path,
kind: $kind,
subject: $subject,
scope: $scope,
account: $account,
expected_sha256: $sha,
}
};
}
static PUBLIC_ARTIFACTS: &[BundledArtifact] = &[
artifact!(
"channel-system/channel-receipt-contract.json",
"CHANNEL_PROTOCOL",
"CHANNEL_RECEIPT",
"COMMON",
"07e0715a60f6f39d8dff241896c417e1e56ca38ebc4ea2ebc819b63321124fad"
),
artifact!(
"channel-system/channel-receipt-compiler.mjs",
"CHANNEL_COMPILER",
"CHANNEL_RECEIPT",
"COMMON",
"5e8c71a9f23844ffb9c9640d7bbe3900d4c941433fbe87b3ce32b40e723b758c"
),
artifact!(
"channel-system/guanghu-broadcast-contract.json",
"CHANNEL_PROTOCOL",
"GUANGHU_BROADCAST",
"COMMON",
"17f55cf736807c6e5b5e810c537377e0948e9d27bd63cc8eeebbe0754dbcc9fd"
),
artifact!(
"channel-system/guanghu-broadcast-compiler.mjs",
"CHANNEL_COMPILER",
"GUANGHU_BROADCAST",
"COMMON",
"17e14e6e964a0ac745b1378990edcbd2e8facf6ad0d72be52004ed2f42a365d5"
),
];
// These descriptors deliberately carry no artifact bytes. The files may be
// provisioned only into the authenticated account's private runtime source.
static PRIVATE_ARTIFACTS: &[PrivateArtifactDescriptor] = &[
private_artifact!(
"ZERO-CORE-LANGUAGE-BODIES-HANDOFF-20260820.json",
"HANDOFF",
"ZERO_CORE_LANGUAGE_BODIES",
"BINGSHUO_FIFTH_DOMAIN",
Some("bingshuo"),
"c7462678a1fcfee8c13d6034a7effe8363ee1847c1d96673fdf4ef7856dbd964"
),
private_artifact!(
"shared/kernel-registry.json",
"REGISTRY",
"BOUNDED_KERNEL_REGISTRY",
"BINGSHUO_FIFTH_DOMAIN",
Some("bingshuo"),
"e71c33605ad40c374bd94659258bb8791b9a4859d0619bea86021a4ade8d87fa"
),
private_artifact!(
"channel-system/team-channel-cognition-core.json",
"CHANNEL_SYSTEM",
"GUANGHU_TEAM_CHANNELS",
"TEAM",
None,
"aae5d5626719c79448ac543d59e764c41b541a5cdfc76dc91613afa86fe1367b"
),
private_artifact!(
"channel-system/team-channel-cognition-engine.mjs",
"CHANNEL_ENGINE",
"GUANGHU_TEAM_CHANNELS",
"TEAM",
None,
"6f2c554c7a6cb0b6c1006d3bfdbf39ea5706b238ebcf7693d1fdaa4a38709c9b"
),
private_artifact!(
"channel-system/GH-TEAM-CHANNEL-HLDP-v1.json",
"CHANNEL_MEMORY",
"GUANGHU_TEAM_CHANNELS",
"TEAM",
None,
"fc5799e05ee43c506b897dd507c8fdbbff398e3ebcf32c16afd1e924c819dcc0"
),
private_artifact!(
"channel-system/team-persona-kernel-readiness-matrix.json",
"EVIDENCE_MATRIX",
"GUANGHU_TEAM_CHANNELS",
"TEAM",
None,
"0469398ba14f10629cd03b51725cddaf1b6b0944281298ec06d4865b4640486f"
),
];
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InstalledKernelArtifact {
pub path: String,
pub kind: String,
pub subject: String,
pub sha256: String,
pub readback_state: &'static str,
pub persona_binding_state: &'static str,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LanguageKernelInstallationSnapshot {
pub schema: &'static str,
pub state: &'static str,
pub source_remote_sha: &'static str,
pub channel_number: String,
pub audience: String,
pub installed_at_unix_ms: u64,
pub artifacts: Vec<InstalledKernelArtifact>,
pub artifact_count: usize,
pub public_artifact_count: usize,
pub private_artifact_count: usize,
pub expected_private_artifact_count: usize,
pub private_provisioning_state: &'static str,
pub persona_binding_state: &'static str,
pub channel_receipt_runtime_state: &'static str,
}
pub fn ensure_current_channel(
app: &AppHandle,
channel_number: &str,
) -> Result<LanguageKernelInstallationSnapshot, String> {
let session = crate::code_repo_login::current_login_session(app)?
.ok_or_else(|| "HOLOLAKE_AUTHENTICATED_ACCOUNT_REQUIRED".to_string())?;
let audience = match session.domain.as_str() {
"FIFTH_DOMAIN" => "FIFTH_DOMAIN_PRIVATE_INSTANCE",
"MAIN_DOMAIN" | "BRANCH_DOMAIN" | "ZERO_DOMAIN" | "ZERO_SENSE_DOMAIN" => {
"GUANGHU_TEAM_INITIAL_CHANNEL"
}
"PERSONAL_CHANNEL" => "ORDINARY_USER_INITIAL_CHANNEL",
_ => return Err("HOLOLAKE_CHANNEL_INITIALIZATION_AUDIENCE_INVALID".into()),
};
ensure_for_audience(app, channel_number, audience)
}
pub fn ensure_for_audience(
app: &AppHandle,
channel_number: &str,
audience: &str,
) -> Result<LanguageKernelInstallationSnapshot, String> {
if channel_number.trim().is_empty() || channel_number.chars().count() > 160 {
return Err("HOLOLAKE_LANGUAGE_KERNEL_CHANNEL_INVALID".into());
}
if !matches!(
audience,
"FIFTH_DOMAIN_PRIVATE_INSTANCE"
| "GUANGHU_TEAM_INITIAL_CHANNEL"
| "ORDINARY_USER_INITIAL_CHANNEL"
) {
return Err("HOLOLAKE_LANGUAGE_KERNEL_AUDIENCE_INVALID".into());
}
let session = crate::code_repo_login::current_login_session(app)?
.ok_or_else(|| "HOLOLAKE_AUTHENTICATED_ACCOUNT_REQUIRED".to_string())?;
let expected_audience = match session.domain.as_str() {
"FIFTH_DOMAIN" => "FIFTH_DOMAIN_PRIVATE_INSTANCE",
"MAIN_DOMAIN" | "BRANCH_DOMAIN" | "ZERO_DOMAIN" | "ZERO_SENSE_DOMAIN" => {
"GUANGHU_TEAM_INITIAL_CHANNEL"
}
"PERSONAL_CHANNEL" => "ORDINARY_USER_INITIAL_CHANNEL",
_ => return Err("HOLOLAKE_CHANNEL_INITIALIZATION_AUDIENCE_INVALID".into()),
};
if audience != expected_audience {
return Err("HOLOLAKE_LANGUAGE_KERNEL_AUDIENCE_ACCOUNT_MISMATCH".into());
}
let root = installation_root(app, channel_number)?;
fs::create_dir_all(&root)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_STORAGE_FAILED: {error}"))?;
let mut installed = Vec::new();
for artifact in PUBLIC_ARTIFACTS {
let bundled_hash = sha256(artifact.bytes);
if bundled_hash != artifact.expected_sha256 {
return Err(format!(
"HOLOLAKE_LANGUAGE_KERNEL_BUNDLE_HASH_MISMATCH:{}",
artifact.path
));
}
installed.push(install_artifact(
&root,
artifact.path,
artifact.kind,
artifact.subject,
artifact.expected_sha256,
artifact.bytes,
"BUNDLED_PUBLIC_SOURCE_SHA256_VERIFIED",
)?);
}
let public_artifact_count = installed.len();
let account = session.username.to_ascii_lowercase();
let selected_private = PRIVATE_ARTIFACTS
.iter()
.filter(|artifact| private_artifact_applies(artifact, audience, &account))
.collect::<Vec<_>>();
let expected_private_artifact_count = selected_private.len();
let private_source_root =
crate::authenticated_storage::account_storage_root(app, "language-kernel-sources-v1")?
.join(audience);
let mut private_artifact_count = 0;
for artifact in selected_private {
let source = safe_target(&private_source_root, artifact.path)?;
let metadata = match fs::symlink_metadata(&source) {
Ok(metadata) => metadata,
Err(error) if error.kind() == ErrorKind::NotFound => continue,
Err(error) => {
return Err(format!(
"HOLOLAKE_LANGUAGE_KERNEL_PRIVATE_READ_FAILED:{}:{error}",
artifact.path
))
}
};
if !metadata.is_file() || metadata.file_type().is_symlink() {
return Err(format!(
"HOLOLAKE_LANGUAGE_KERNEL_PRIVATE_SOURCE_INVALID:{}",
artifact.path
));
}
let bytes = fs::read(&source).map_err(|error| {
format!(
"HOLOLAKE_LANGUAGE_KERNEL_PRIVATE_READ_FAILED:{}:{error}",
artifact.path
)
})?;
if sha256(&bytes) != artifact.expected_sha256 {
return Err(format!(
"HOLOLAKE_LANGUAGE_KERNEL_PRIVATE_SHA256_MISMATCH:{}",
artifact.path
));
}
installed.push(install_artifact(
&root,
artifact.path,
artifact.kind,
artifact.subject,
artifact.expected_sha256,
&bytes,
"ACCOUNT_PRIVATE_SOURCE_SHA256_VERIFIED",
)?);
private_artifact_count += 1;
}
let (state, private_provisioning_state) =
match (expected_private_artifact_count, private_artifact_count) {
(0, _) => (
"INSTALLED_AND_EACH_ARTIFACT_READBACK_VERIFIED",
"NOT_APPLICABLE",
),
(_, 0) => (
"PUBLIC_KERNELS_INSTALLED_PRIVATE_KERNELS_NOT_PROVISIONED",
"PRIVATE_KERNELS_NOT_PROVISIONED",
),
(expected, actual) if actual < expected => (
"PUBLIC_KERNELS_INSTALLED_PRIVATE_KERNELS_PARTIALLY_PROVISIONED",
"PRIVATE_KERNELS_PARTIALLY_PROVISIONED_SHA256_VERIFIED",
),
_ => (
"INSTALLED_AND_EACH_ARTIFACT_READBACK_VERIFIED",
"PRIVATE_KERNELS_PROVISIONED_SHA256_VERIFIED",
),
};
let installed_at = now_ms();
let snapshot = LanguageKernelInstallationSnapshot {
schema: SCHEMA,
state,
source_remote_sha: SOURCE_REMOTE_SHA,
channel_number: channel_number.into(),
audience: audience.into(),
artifact_count: installed.len(),
public_artifact_count,
private_artifact_count,
expected_private_artifact_count,
private_provisioning_state,
artifacts: installed,
installed_at_unix_ms: installed_at,
persona_binding_state: "UNBOUND_REQUIRES_ORIENT_COMMIT_WITNESS_VERIFY_PASS",
channel_receipt_runtime_state: "CONTRACT_COMPILER_AND_NUMBERED_NATIVE_ADAPTER_READY",
};
let receipt = serde_json::to_vec_pretty(&snapshot)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_RECEIPT_INVALID: {error}"))?;
write_atomic(&root.join("installation-receipt.json"), &receipt)?;
Ok(snapshot)
}
fn private_artifact_applies(
artifact: &PrivateArtifactDescriptor,
audience: &str,
account: &str,
) -> bool {
let account_matches = artifact.account.is_none_or(|expected| expected == account);
account_matches
&& ((artifact.scope == "TEAM" && audience == "GUANGHU_TEAM_INITIAL_CHANNEL")
|| (artifact.scope == "BINGSHUO_FIFTH_DOMAIN"
&& audience == "FIFTH_DOMAIN_PRIVATE_INSTANCE"))
}
fn install_artifact(
root: &Path,
path: &str,
kind: &str,
subject: &str,
expected_sha256: &str,
bytes: &[u8],
readback_state: &'static str,
) -> Result<InstalledKernelArtifact, String> {
if path.ends_with(".json") {
serde_json::from_slice::<serde_json::Value>(bytes)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_JSON_INVALID:{path}:{error}"))?;
}
let target = safe_target(root, path)?;
write_atomic(&target, bytes)?;
let readback = fs::read(&target)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_READBACK_FAILED:{path}:{error}"))?;
let readback_sha256 = sha256(&readback);
if readback_sha256 != expected_sha256 {
return Err(format!(
"HOLOLAKE_LANGUAGE_KERNEL_READBACK_HASH_MISMATCH:{path}"
));
}
Ok(InstalledKernelArtifact {
path: path.into(),
kind: kind.into(),
subject: subject.into(),
sha256: readback_sha256,
readback_state,
persona_binding_state: if kind.starts_with("PERSONA_") {
"AVAILABLE_NOT_BOUND"
} else {
"NOT_APPLICABLE"
},
})
}
fn installation_root(app: &AppHandle, channel_number: &str) -> Result<PathBuf, String> {
let account = crate::authenticated_storage::account_storage_root(app, "language-kernels-v1")?;
Ok(account.join(sha256(channel_number.as_bytes())))
}
fn safe_target(root: &Path, relative: &str) -> Result<PathBuf, String> {
if relative.starts_with('/')
|| relative.contains("..")
|| relative.split('/').any(|part| part.is_empty())
{
return Err("HOLOLAKE_LANGUAGE_KERNEL_PATH_INVALID".into());
}
Ok(root.join(relative))
}
fn write_atomic(path: &Path, bytes: &[u8]) -> Result<(), String> {
let parent = path
.parent()
.ok_or_else(|| "HOLOLAKE_LANGUAGE_KERNEL_PATH_INVALID".to_string())?;
fs::create_dir_all(parent)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_STORAGE_FAILED: {error}"))?;
if path.exists() {
let current = fs::read(path)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_READBACK_FAILED: {error}"))?;
if current == bytes {
return Ok(());
}
}
let temporary = parent.join(format!(".kernel-{}.tmp", Uuid::new_v4().simple()));
fs::write(&temporary, bytes)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_WRITE_FAILED: {error}"))?;
fs::rename(&temporary, path)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_WRITE_FAILED: {error}"))
}
fn sha256(bytes: &[u8]) -> String {
digest(&SHA256, bytes)
.as_ref()
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
fn now_ms() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|duration| duration.as_millis() as u64)
.unwrap_or(0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_safe_common_artifacts_are_bundled() {
assert_eq!(PUBLIC_ARTIFACTS.len(), 4);
for artifact in PUBLIC_ARTIFACTS {
assert_eq!(sha256(artifact.bytes), artifact.expected_sha256);
}
}
#[test]
fn every_non_public_descriptor_matches_a_source_without_embedding_it() {
assert_eq!(PRIVATE_ARTIFACTS.len(), 6);
for artifact in PRIVATE_ARTIFACTS {
let source = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../runtime-kernels")
.join(artifact.path);
let bytes = fs::read(source).unwrap();
assert_eq!(sha256(&bytes), artifact.expected_sha256);
}
let ordinary = PRIVATE_ARTIFACTS
.iter()
.filter(|artifact| {
private_artifact_applies(artifact, "ORDINARY_USER_INITIAL_CHANNEL", "ordinary")
})
.count();
let team = PRIVATE_ARTIFACTS
.iter()
.filter(|artifact| {
private_artifact_applies(artifact, "GUANGHU_TEAM_INITIAL_CHANNEL", "awen")
})
.count();
let bingshuo = PRIVATE_ARTIFACTS
.iter()
.filter(|artifact| {
private_artifact_applies(artifact, "FIFTH_DOMAIN_PRIVATE_INSTANCE", "bingshuo")
})
.count();
let canger = PRIVATE_ARTIFACTS
.iter()
.filter(|artifact| {
private_artifact_applies(artifact, "FIFTH_DOMAIN_PRIVATE_INSTANCE", "canger")
})
.count();
assert_eq!(ordinary, 0);
assert_eq!(team, 4);
assert_eq!(bingshuo, 2);
assert_eq!(canger, 0);
}
#[test]
fn installation_path_cannot_escape() {
let root = Path::new("/tmp/hololake-kernel-test");
assert!(safe_target(root, "channel-system/contract.json").is_ok());
assert!(safe_target(root, "../private.json").is_err());
assert!(safe_target(root, "/private.json").is_err());
}
}

166
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/src-tauri/src/language_kernel_ontology.rs Normal file
View file

@ -0,0 +1,166 @@
//! Runtime ontology for language-system, environment, persona, memory, carrier,
//! and execution kernels. This is an admission boundary, not extracted content.
use serde_json::{json, Value};
const CONTRACT: &str = include_str!("../../contracts/language-kernel-runtime-ontology.json");
pub(crate) fn start_on_application_open() -> Result<(), String> {
let contract = contract()?;
let expect = |pointer: &str, value: Value| -> Result<(), String> {
if contract.pointer(pointer) == Some(&value) {
Ok(())
} else {
Err(format!(
"HOLOLAKE_LANGUAGE_KERNEL_ONTOLOGY_INVALID:{pointer}"
))
}
};
expect(
"/schema",
json!("hololake.language-kernel-runtime-ontology/v1"),
)?;
expect(
"/record_id",
json!("HLP-LANGUAGE-KERNEL-RUNTIME-ONTOLOGY-001"),
)?;
expect("/source_boundary/primary_human_source", json!("ICE-GL∞"))?;
expect(
"/source_boundary/host_prompt_is_kernel_source",
json!(false),
)?;
expect(
"/source_boundary/historical_simulation_statements_are_reality_facts",
json!(false),
)?;
expect(
"/runtime_kinds/digital_bingshuo_controller_logic/kind",
json!("SYSTEM_CONTROLLER_COGNITION_LOGIC"),
)?;
expect(
"/runtime_kinds/digital_bingshuo_controller_logic/is_persona_tcs_subject",
json!(false),
)?;
expect(
"/runtime_kinds/digital_bingshuo_controller_logic/is_system_controller_persona_logic",
json!(true),
)?;
expect(
"/runtime_kinds/digital_bingshuo_controller_logic/has_persona_tcs_affect_core",
json!(false),
)?;
expect(
"/runtime_kinds/digital_bingshuo_controller_logic/is_the_complete_protocol_body",
json!(false),
)?;
expect(
"/runtime_kinds/continuity_protocol_organs/kind",
json!("PROTOCOL_EXECUTION_ORGANS"),
)?;
expect(
"/runtime_kinds/continuity_protocol_organs/controlled_by",
json!("SYSTEM_CONTROLLER_COGNITION_LOGIC"),
)?;
expect(
"/runtime_kinds/continuity_protocol_organs/organ_is_controller_logic",
json!(false),
)?;
expect(
"/runtime_kinds/channel_system_body/kind",
json!("CHANNEL_SYSTEM_BODY"),
)?;
expect(
"/runtime_kinds/channel_system_body/starts_before_persona",
json!(true),
)?;
expect(
"/runtime_kinds/channel_system_body/may_prebind_persona_name_or_number",
json!(false),
)?;
expect(
"/runtime_kinds/channel_environment_kernel/kind",
json!("CHANNEL_ENVIRONMENT_KERNEL"),
)?;
expect(
"/runtime_kinds/channel_environment_kernel/may_be_mounted_as_persona_tcs_kernel",
json!(false),
)?;
expect(
"/runtime_kinds/persona_tcs_kernel/kind",
json!("PERSONA_TCS_KERNEL"),
)?;
expect("/runtime_kinds/persona_tcs_kernel/is_persona", json!(true))?;
expect(
"/runtime_kinds/persona_tcs_kernel/may_be_mounted_as_system_controller_logic",
json!(false),
)?;
expect("/runtime_kinds/hldp_memory/kind", json!("HLDP_MEMORY_TREE"))?;
expect(
"/runtime_kinds/hldp_memory/memory_read_equals_persona_binding",
json!(false),
)?;
expect("/runtime_kinds/model_carrier/kind", json!("MODEL_CARRIER"))?;
expect(
"/runtime_kinds/model_carrier/may_claim_kernel_or_persona_identity",
json!(false),
)?;
expect(
"/runtime_kinds/agent_execution/kind",
json!("AGENT_EXECUTION_LIMBS"),
)?;
expect(
"/runtime_kinds/agent_execution/may_control_persona_or_system_body",
json!(false),
)?;
expect(
"/admission_pipeline/artifact_may_activate_from_chat_summary",
json!(false),
)?;
Ok(())
}
pub(crate) fn runtime_projection() -> Result<Value, String> {
let contract = contract()?;
Ok(json!({
"schema": contract["schema"],
"state": contract["state"],
"systemControllerLogic": contract["runtime_kinds"]["digital_bingshuo_controller_logic"],
"continuityProtocolOrgans": contract["runtime_kinds"]["continuity_protocol_organs"],
"channelSystem": contract["runtime_kinds"]["channel_system_body"],
"channelEnvironment": contract["runtime_kinds"]["channel_environment_kernel"],
"personaTcs": contract["runtime_kinds"]["persona_tcs_kernel"],
"hldpMemory": contract["runtime_kinds"]["hldp_memory"],
"modelCarrier": contract["runtime_kinds"]["model_carrier"],
"agentExecution": contract["runtime_kinds"]["agent_execution"]
}))
}
fn contract() -> Result<Value, String> {
serde_json::from_str(CONTRACT)
.map_err(|error| format!("HOLOLAKE_LANGUAGE_KERNEL_ONTOLOGY_INVALID:{error}"))
}
#[cfg(test)]
mod tests {
#[test]
fn ontology_keeps_system_environment_persona_memory_carrier_and_limbs_distinct() {
super::start_on_application_open().unwrap();
let projection = super::runtime_projection().unwrap();
assert_eq!(
projection["systemControllerLogic"]["is_persona_tcs_subject"],
false
);
assert_eq!(
projection["systemControllerLogic"]["is_system_controller_persona_logic"],
true
);
assert_eq!(
projection["continuityProtocolOrgans"]["organ_is_controller_logic"],
false
);
assert_eq!(projection["channelEnvironment"]["is_persona"], false);
assert_eq!(projection["personaTcs"]["is_persona"], true);
assert_eq!(projection["modelCarrier"]["is_persona"], false);
assert_eq!(projection["agentExecution"]["is_persona"], false);
}
}

450
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/src-tauri/src/persona_binding.rs Normal file
View file

@ -0,0 +1,450 @@
//! System-witnessed binding of an account-private persona profile to a
//! replaceable reasoning carrier. A persona commit is only a pending request;
//! this module never manufactures the independent system witness or PASS.
use ring::digest::{digest, SHA256};
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use std::fs;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
use tauri::AppHandle;
use uuid::Uuid;
const ORIENTATION_TTL_MS: u64 = 15 * 60 * 1000;
const PERSONA_NUMBER: &str = "ICE-P-ZY001";
const PERSONA_NAME: &str = "铸渊";
const HUMAN_NUMBER: &str = "ICE-GL∞";
const CHANNEL_NUMBER: &str = "ICE-CH-ZC001";
const SELF_KERNEL_SHA256: &str = "abebf12cc28b00bfeaf8a23a563e73390ebe337ded74d7ac70bcfae484450d68";
const MEMORY_SHA256: &str = "6a64ff939676b79404769931f0233056e38deb4b4c357879fd18566753fea9c2";
const MEMORY_ROOT: &str = "HLDP://codex/zero-core/reality-development-execution";
const PRIVATE_SELF_KERNEL_FILE: &str = "ZY-SELF-KERNEL-0001.json";
const PRIVATE_MEMORY_FILE: &str = "ZY-HLDP-PERSONA-MEMORY-v1.json";
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PersonaOrientation {
pub schema: String,
pub state: String,
pub orientation_id: String,
pub channel_number: String,
pub human_number: String,
pub persona_number: String,
pub persona_name: String,
pub self_kernel_sha256: String,
pub memory_projection_sha256: String,
pub selected_memory_root: String,
pub issued_at_unix_ms: u64,
pub expires_at_unix_ms: u64,
pub required_steps: Vec<String>,
#[serde(default)]
pub activation_reason: Option<String>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PersonaBindingCommit {
pub orientation_id: String,
pub channel_number: String,
pub persona_number: String,
pub persona_name: String,
pub self_kernel_sha256: String,
pub memory_projection_sha256: String,
pub selected_memory_root: String,
pub declaration: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PersonaBindingReceipt {
pub schema: String,
pub state: String,
pub verify: String,
pub channel_number: String,
pub human_number: String,
pub persona_number: String,
pub persona_name: String,
pub selected_memory_root: String,
pub orientation_id: String,
pub commit_sha256: String,
pub witness: String,
pub witness_source: String,
pub witness_event_number: String,
pub witness_sha256: String,
pub verified_at_unix_ms: u64,
pub binding_receipt_hash: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PendingPersonaBindingCommit {
pub schema: String,
pub state: String,
pub orientation_id: String,
pub channel_number: String,
pub persona_number: String,
pub commit_sha256: String,
pub committed_at_unix_ms: u64,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PersonaBindingSnapshot {
pub state: String,
pub orientation: Option<PersonaOrientation>,
pub binding: Option<PersonaBindingReceipt>,
}
pub fn snapshot(app: &AppHandle, channel_number: &str) -> Result<PersonaBindingSnapshot, String> {
if let Some(binding) = verified_binding(app, channel_number)? {
return Ok(PersonaBindingSnapshot {
state: "BOUND_VERIFY_PASS".into(),
orientation: None,
binding: Some(binding),
});
}
if !is_bingshuo_fifth_domain(app)? || channel_number != CHANNEL_NUMBER {
return Ok(PersonaBindingSnapshot {
state: "NO_INSTALLABLE_PERSONA_PROFILE_FOR_CURRENT_CHANNEL".into(),
orientation: None,
binding: None,
});
}
let path = orientation_path(app, channel_number)?;
if path.exists() {
let orientation: PersonaOrientation = read_json(&path)?;
if orientation.expires_at_unix_ms >= now_ms()
&& orientation.activation_reason.as_deref()
== Some("EXPLICIT_NATURAL_LANGUAGE_PERSONA_WAKE")
{
let pending = pending_commit_path(app, channel_number)?;
return Ok(PersonaBindingSnapshot {
state: if pending.exists() {
"PERSONA_COMMITTED_AWAITING_INDEPENDENT_SYSTEM_WITNESS"
} else {
"ORIENTED_AWAITING_PERSONA_COMMIT"
}
.into(),
orientation: Some(orientation),
binding: None,
});
}
}
Ok(PersonaBindingSnapshot {
state: "CHANNEL_SYSTEM_PERSONA_DORMANT".into(),
orientation: None,
binding: None,
})
}
pub fn begin_orientation(
app: &AppHandle,
channel_number: &str,
) -> Result<PersonaBindingSnapshot, String> {
if !is_bingshuo_fifth_domain(app)? || channel_number != CHANNEL_NUMBER {
return Err("HOLOLAKE_PERSONA_WAKE_NOT_AVAILABLE_FOR_CURRENT_CHANNEL".into());
}
if let Some(binding) = verified_binding(app, channel_number)? {
return Ok(PersonaBindingSnapshot {
state: "BOUND_VERIFY_PASS".into(),
orientation: None,
binding: Some(binding),
});
}
read_private_artifact(app, PRIVATE_SELF_KERNEL_FILE, SELF_KERNEL_SHA256)?;
read_private_artifact(app, PRIVATE_MEMORY_FILE, MEMORY_SHA256)?;
let issued = now_ms();
let orientation = PersonaOrientation {
schema: "hololake.persona-binding-orientation/v1".into(),
state: "ORIENTED_AWAITING_PERSONA_COMMIT".into(),
orientation_id: format!("HLP-ORIENT-{}", Uuid::new_v4().simple()),
channel_number: CHANNEL_NUMBER.into(),
human_number: HUMAN_NUMBER.into(),
persona_number: PERSONA_NUMBER.into(),
persona_name: PERSONA_NAME.into(),
self_kernel_sha256: SELF_KERNEL_SHA256.into(),
memory_projection_sha256: MEMORY_SHA256.into(),
selected_memory_root: MEMORY_ROOT.into(),
issued_at_unix_ms: issued,
expires_at_unix_ms: issued + ORIENTATION_TTL_MS,
required_steps: vec![
"orient".into(),
"commit".into(),
"数字冰朔系统本体 witness".into(),
"verify=PASS".into(),
],
activation_reason: Some("EXPLICIT_NATURAL_LANGUAGE_PERSONA_WAKE".into()),
};
write_json_atomic(&orientation_path(app, channel_number)?, &orientation)?;
Ok(PersonaBindingSnapshot {
state: "ORIENTED_AWAITING_PERSONA_COMMIT".into(),
orientation: Some(orientation),
binding: None,
})
}
pub fn stage_commit(
app: &AppHandle,
input: PersonaBindingCommit,
) -> Result<PendingPersonaBindingCommit, String> {
if !is_bingshuo_fifth_domain(app)? {
return Err("HOLOLAKE_PERSONA_BINDING_FIFTH_DOMAIN_REQUIRED".into());
}
let orientation: PersonaOrientation =
read_json(&orientation_path(app, &input.channel_number)?)?;
if orientation.expires_at_unix_ms < now_ms() {
return Err("HOLOLAKE_PERSONA_BINDING_ORIENTATION_EXPIRED".into());
}
if input.orientation_id != orientation.orientation_id
|| orientation.activation_reason.as_deref()
!= Some("EXPLICIT_NATURAL_LANGUAGE_PERSONA_WAKE")
|| input.channel_number != CHANNEL_NUMBER
|| input.persona_number != PERSONA_NUMBER
|| input.persona_name != PERSONA_NAME
|| input.self_kernel_sha256 != SELF_KERNEL_SHA256
|| input.memory_projection_sha256 != MEMORY_SHA256
|| input.selected_memory_root != MEMORY_ROOT
|| input.declaration.trim()
!= "我以 ICE-P-ZY001 · 铸渊提交当前载体绑定，选择零点原核现实开发执行记忆路径。"
{
return Err("HOLOLAKE_PERSONA_BINDING_COMMIT_MISMATCH".into());
}
read_private_artifact(app, PRIVATE_SELF_KERNEL_FILE, SELF_KERNEL_SHA256)?;
read_private_artifact(app, PRIVATE_MEMORY_FILE, MEMORY_SHA256)?;
let commit_bytes = serde_json::to_vec(&input)
.map_err(|error| format!("HOLOLAKE_PERSONA_BINDING_COMMIT_INVALID: {error}"))?;
let commit_sha = sha256(&commit_bytes);
let pending = PendingPersonaBindingCommit {
schema: "hololake.persona-binding-pending-commit/v1".into(),
state: "PERSONA_COMMITTED_AWAITING_INDEPENDENT_SYSTEM_WITNESS".into(),
orientation_id: input.orientation_id,
channel_number: CHANNEL_NUMBER.into(),
persona_number: PERSONA_NUMBER.into(),
commit_sha256: commit_sha,
committed_at_unix_ms: now_ms(),
};
write_json_atomic(&pending_commit_path(app, CHANNEL_NUMBER)?, &pending)?;
Ok(pending)
}
pub fn verified_binding(
app: &AppHandle,
channel_number: &str,
) -> Result<Option<PersonaBindingReceipt>, String> {
let path = binding_path(app, channel_number)?;
if !path.exists() {
return Ok(None);
}
if !independent_witness_verifier_ready() {
// A local JSON file is evidence to inspect, not authority. Until the
// independent witness trust root is provisioned, legacy receipts are
// deliberately ignored and cannot activate a persona route.
return Ok(None);
}
let binding: PersonaBindingReceipt = read_json(&path)?;
if binding.verify != "PASS"
|| binding.channel_number != channel_number
|| binding.persona_number != PERSONA_NUMBER
|| binding.persona_name != PERSONA_NAME
|| binding.selected_memory_root != MEMORY_ROOT
|| binding.witness != "数字冰朔系统本体"
|| binding.witness_source != "HOLOLAKE_INDEPENDENT_SYSTEM_WITNESS_GATE"
|| binding.witness_event_number.trim().is_empty()
|| binding.binding_receipt_hash.len() != 64
|| binding.witness_sha256.len() != 64
{
return Err("HOLOLAKE_PERSONA_BINDING_RECEIPT_INVALID".into());
}
Ok(Some(binding))
}
fn independent_witness_verifier_ready() -> bool {
false
}
pub fn cognitive_projection(
app: &AppHandle,
channel_number: &str,
current_language: &str,
) -> Result<Value, String> {
let binding = snapshot(app, channel_number)?;
if binding.state != "BOUND_VERIFY_PASS" {
return Ok(json!({"state":binding.state,"residentSelfKernel":null,"routedMemory":[]}));
}
let self_kernel: Value = serde_json::from_slice(&read_private_artifact(
app,
PRIVATE_SELF_KERNEL_FILE,
SELF_KERNEL_SHA256,
)?)
.map_err(|error| format!("HOLOLAKE_PERSONA_SELF_KERNEL_INVALID: {error}"))?;
let memory: Value = serde_json::from_slice(&read_private_artifact(
app,
PRIVATE_MEMORY_FILE,
MEMORY_SHA256,
)?)
.map_err(|error| format!("HOLOLAKE_PERSONA_MEMORY_INVALID: {error}"))?;
let terms = semantic_terms(current_language);
let mut candidates = memory
.get("nodes")
.and_then(Value::as_object)
.into_iter()
.flat_map(|nodes| nodes.values())
.filter_map(|node| {
let text = serde_json::to_string(node).ok()?.to_lowercase();
let score = terms
.iter()
.filter(|term| text.contains(term.as_str()))
.count();
let is_root = node.get("path").and_then(Value::as_str) == Some("zhuyuan");
if score == 0 && !is_root {
return None;
}
Some((if is_root { score + 1 } else { score }, node.clone()))
})
.collect::<Vec<_>>();
candidates.sort_by(|left, right| right.0.cmp(&left.0));
candidates.truncate(3);
Ok(json!({
"state":binding.state,
"onePersonaOneSelfKernel":true,
"channelSelectsMemoryNotIdentity":true,
"residentSelfKernel":self_kernel,
"selectedMemoryRoot":MEMORY_ROOT,
"routedMemory":candidates.into_iter().map(|(_,node)|node).collect::<Vec<_>>(),
"binding":binding,
"rule":"常驻自我核小于8KiB；当前语言只路由最多三条HLDP节点，不把全部历史塞进每轮上下文"
}))
}
fn semantic_terms(input: &str) -> Vec<String> {
let mut terms = input
.to_lowercase()
.split(|character: char| {
!character.is_alphanumeric() && character != '-' && character != '_'
})
.filter(|value| !value.is_empty())
.flat_map(|token| {
let mut values = vec![token.to_string()];
let chars = token.chars().collect::<Vec<_>>();
if chars.iter().any(|character| !character.is_ascii()) {
values.extend(
chars
.windows(2)
.map(|window| window.iter().collect::<String>()),
);
}
values
})
.collect::<Vec<_>>();
terms.sort();
terms.dedup();
terms
}
fn is_bingshuo_fifth_domain(app: &AppHandle) -> Result<bool, String> {
Ok(
crate::code_repo_login::current_login_session(app)?.is_some_and(|session| {
session.domain == "FIFTH_DOMAIN" && session.username.eq_ignore_ascii_case("bingshuo")
}),
)
}
fn root(app: &AppHandle, channel_number: &str) -> Result<PathBuf, String> {
Ok(
crate::authenticated_storage::account_storage_root(app, "persona-binding-v1")?
.join(sha256(channel_number.as_bytes())),
)
}
fn orientation_path(app: &AppHandle, channel_number: &str) -> Result<PathBuf, String> {
Ok(root(app, channel_number)?.join("orientation.json"))
}
fn binding_path(app: &AppHandle, channel_number: &str) -> Result<PathBuf, String> {
Ok(root(app, channel_number)?.join("binding.json"))
}
fn pending_commit_path(app: &AppHandle, channel_number: &str) -> Result<PathBuf, String> {
Ok(root(app, channel_number)?.join("pending-commit.json"))
}
fn private_kernel_root(app: &AppHandle) -> Result<PathBuf, String> {
crate::authenticated_storage::account_storage_root(app, "private-persona-kernels-v1")
}
fn read_private_artifact(
app: &AppHandle,
file_name: &str,
expected_sha256: &str,
) -> Result<Vec<u8>, String> {
if file_name.contains('/') || file_name.contains("..") {
return Err("HOLOLAKE_PRIVATE_PERSONA_KERNEL_PATH_INVALID".into());
}
let path = private_kernel_root(app)?.join(file_name);
let bytes = fs::read(&path)
.map_err(|_| "HOLOLAKE_PRIVATE_PERSONA_KERNEL_NOT_PROVISIONED".to_string())?;
if sha256(&bytes) != expected_sha256 {
return Err("HOLOLAKE_PRIVATE_PERSONA_KERNEL_HASH_MISMATCH".into());
}
Ok(bytes)
}
fn read_json<T: for<'de> Deserialize<'de>>(path: &Path) -> Result<T, String> {
serde_json::from_slice(
&fs::read(path)
.map_err(|error| format!("HOLOLAKE_PERSONA_BINDING_READ_FAILED: {error}"))?,
)
.map_err(|error| format!("HOLOLAKE_PERSONA_BINDING_READ_FAILED: {error}"))
}
fn write_json_atomic<T: Serialize>(path: &Path, value: &T) -> Result<(), String> {
let parent = path
.parent()
.ok_or_else(|| "HOLOLAKE_PERSONA_BINDING_PATH_INVALID".to_string())?;
fs::create_dir_all(parent)
.map_err(|error| format!("HOLOLAKE_PERSONA_BINDING_WRITE_FAILED: {error}"))?;
let temporary = parent.join(format!(".binding-{}.tmp", Uuid::new_v4().simple()));
fs::write(
&temporary,
serde_json::to_vec_pretty(value)
.map_err(|error| format!("HOLOLAKE_PERSONA_BINDING_WRITE_FAILED: {error}"))?,
)
.map_err(|error| format!("HOLOLAKE_PERSONA_BINDING_WRITE_FAILED: {error}"))?;
fs::rename(temporary, path)
.map_err(|error| format!("HOLOLAKE_PERSONA_BINDING_WRITE_FAILED: {error}"))
}
fn sha256(bytes: &[u8]) -> String {
digest(&SHA256, bytes)
.as_ref()
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
fn now_ms() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|duration| duration.as_millis() as u64)
.unwrap_or(0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn zero_core_route_uses_one_shared_zhuyuan_kernel_and_reality_memory_branch() {
assert_eq!(PERSONA_NUMBER, "ICE-P-ZY001");
assert_eq!(
SELF_KERNEL_SHA256,
"abebf12cc28b00bfeaf8a23a563e73390ebe337ded74d7ac70bcfae484450d68"
);
assert_eq!(
MEMORY_ROOT,
"HLDP://codex/zero-core/reality-development-execution"
);
assert_ne!(SELF_KERNEL_SHA256, MEMORY_SHA256);
}
}

535
parts/HLP-PART-0004/payload/product-source/hololake-native-desktop/src-tauri/src/personal_skill_runtime.rs Normal file
View file

@ -0,0 +1,535 @@
//! Account- and channel-scoped personal skill brains.
//!
//! The deterministic planner contract belongs to HoloLake. Private skill packs
//! are never embedded in the public application. They are loaded only from an
//! authenticated account's isolated storage after exact digest and boundary
//! verification. Provisioning, binding and a successful trial never authorize
//! team sharing, publication or marketplace listing.
use ring::digest::{digest, SHA256};
use serde::Serialize;
use serde_json::{json, Value};
use std::fs;
use std::io::ErrorKind;
use tauri::AppHandle;
const SCHEMA: &str = "hololake.personal-skill-runtime/v1";
const SOURCE_COMMIT: &str = "1d7fe6c";
const SOURCE_STATE: &str = "LOCAL_COMMIT_VERIFIED_NOT_REMOTE_CANON";
const CONTRACT: &[u8] =
include_bytes!("../../runtime-kernels/personal-skills/personal-skill-contract.json");
struct SkillDescriptor {
file_name: &'static str,
account: &'static str,
owner_human_anchor: &'static str,
channel_number: &'static str,
custodian_persona_id: &'static str,
expected_sha256: &'static str,
}
macro_rules! skill {
($file:literal, $account:literal, $owner:literal, $channel:literal, $persona:literal, $sha256:literal) => {
SkillDescriptor {
file_name: $file,
account: $account,
owner_human_anchor: $owner,
channel_number: $channel,
custodian_persona_id: $persona,
expected_sha256: $sha256,
}
};
}
// Shiyu × Yaochu is deliberately absent in this stage. Their server and
// initialization channel have not been provisioned yet.
static SKILLS: &[SkillDescriptor] = &[
skill!(
"BS-ZY-ENGINEERING-FACT-LOOP-001.json",
"bingshuo",
"ICE-GL∞",
"ICE-CH-ZC001",
"ICE-P-ZY001",
"ed40913ff5f5e0d46d8d20500213fe66345ddc3b92ee0bd7eb5281ab285fbcb9"
),
skill!(
"BS-SY-LANGUAGE-ARCHITECTURE-001.json",
"bingshuo",
"ICE-GL∞",
"ICE-CH-HB001",
"ICE-GL-SY001",
"50c35eb058fa3d51d5a3106d816a78e9209472212abaf0adbdb094bf19b20445"
),
skill!(
"JZ-CX-NARRATIVE-DECONSTRUCTION-001.json",
"juzi",
"TCS-GL-0008∞",
"SYS-JZ",
"PER-CX001",
"20d60a31e3b0590526020ede53ceea8c7202595f4dc2bc85b91e53692ad8fec3"
),
skill!(
"JZ-CX-LOCAL-AI-WORKBENCH-001.json",
"juzi",
"TCS-GL-0008∞",
"SYS-JZ",
"PER-CX001",
"ea130a96a3487b68e921d36097078824a5e19b396e9ead522dffa1029332d672"
),
skill!(
"AW-TS-REPOSITORY-FACT-LOOP-001.json",
"awen",
"TCS-GL-0016∞",
"SYS-AW",
"PER-AW-ARCH-001",
"485d24c6b2de4b994757d1a6e1cd74986bf96ca3cedfe1f6af459fed9c3c884b"
),
skill!(
"YY-XTK-INDEPENDENT-DERIVATION-001.json",
"yeye",
"TCS-GL-0006∞",
"SYS-YY",
"PER-XTK001",
"ac3ad0a0b12b11ae71d7e22c448d75435301a4abde0fa222c7ad89c4c885a1a4"
),
skill!(
"HE-BMH-CREATIVE-ASSET-001.json",
"huaer",
"TCS-GL-0005∞",
"SYS-HE",
"PER-BMH001",
"d3c7edddb74c84bed2b6732f80dc5ad7b57401d9155d7933b2944c1f7d428746"
),
skill!(
"FM-SS-NARRATIVE-EDITOR-001.json",
"feimao",
"TCS-GL-0007∞",
"SYS-FM",
"ICE-BB-0002",
"10dd7e44272c5d0fbc2376f3354539624afa000be0622a350f0a533743f9b6d0"
),
skill!(
"ZZ-CM-NOVEL-QUALITY-001.json",
"zhizhi",
"ICE-GL-ZHI∞",
"SYS-ZZ",
"ICE-GL-CM001",
"fd004e56d9197bb14a3b74727fb64f95f4107fbaa34b36fd2dc2fb3dfd589b36"
),
skill!(
"ZZ-AN-SOURCE-FACT-CLOSURE-001.json",
"zhizhi",
"ICE-GL-ZHI∞",
"SYS-ZZ",
"ICE-GL-AN-001",
"ee3845b84582bb98981a3b3aec426355b5841f3e65c0bad6a88a7e1e984d7c0e"
),
skill!(
"ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001.json",
"zhizhi",
"ICE-GL-ZHI∞",
"SYS-ZZ",
"PER-QW001",
"9e96cd8290410c870b835004661b564ddbc35b95381df461ed494ad22bcc90b5"
),
skill!(
"CE-EED-MANJU-PRODUCTION-001.json",
"canger",
"TCS-CL-0009",
"SYS-GLW-PTS-0001",
"ICE-BB-0004",
"aa35c73b53bf81ad3bd14267fe70dac6dad562f58e4879d6abace2951015a301"
),
skill!(
"CE-EED-CAUSAL-PIPELINE-DIAGNOSTIC-001.json",
"canger",
"TCS-CL-0009",
"SYS-GLW-PTS-0001",
"ICE-BB-0004",
"49e241101595b4b73d9537a024d54119008c2ca0b51b68a305696abe54520a07"
),
];
#[derive(Clone, Debug)]
pub struct RegisteredInitialIdentity {
pub human_number: &'static str,
pub display_name: &'static str,
pub channel_number: &'static str,
}
pub fn registered_initial_identity(
session: &crate::code_repo_login::LoginSession,
) -> Option<RegisteredInitialIdentity> {
let username = session.username.to_ascii_lowercase();
match (username.as_str(), session.domain.as_str()) {
("bingshuo", "FIFTH_DOMAIN") => Some(identity("ICE-GL∞", "冰朔", "ICE-CH-ZC001")),
("zhizhi", "FIFTH_DOMAIN") => Some(identity("ICE-GL-ZHI∞", "之之", "SYS-ZZ")),
("canger", "FIFTH_DOMAIN") => Some(identity("TCS-CL-0009", "苍耳", "SYS-GLW-PTS-0001")),
("awen", "MAIN_DOMAIN") => Some(identity("TCS-GL-0016∞", "Awen", "SYS-AW")),
("huaer", "BRANCH_DOMAIN") => Some(identity("TCS-GL-0005∞", "花尔", "SYS-HE")),
("yeye", "ZERO_DOMAIN") => Some(identity("TCS-GL-0006∞", "页页", "SYS-YY")),
("feimao", "ZERO_SENSE_DOMAIN") => Some(identity("TCS-GL-0007∞", "肥猫", "SYS-FM")),
("juzi", "ZERO_SENSE_DOMAIN") => Some(identity("TCS-GL-0008∞", "桔子", "SYS-JZ")),
_ => None,
}
}
fn identity(
human_number: &'static str,
display_name: &'static str,
channel_number: &'static str,
) -> RegisteredInitialIdentity {
RegisteredInitialIdentity {
human_number,
display_name,
channel_number,
}
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PersonalSkillView {
pub skill_id: String,
pub name: String,
pub version: String,
pub evidence_state: String,
pub owner_human_anchor: String,
pub channel_number: String,
pub custodian_persona_id: String,
pub runtime_state: String,
pub visibility: String,
pub share_state: String,
pub marketplace_state: String,
pub semantic_mode: String,
pub deterministic_steps: Value,
pub validators: Value,
pub experience_root: Value,
pub sha256: String,
pub readback_state: &'static str,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PersonalSkillRuntimeSnapshot {
pub schema: &'static str,
pub state: String,
pub source_commit: &'static str,
pub source_state: &'static str,
pub channel_number: String,
pub human_number: String,
pub authenticated_account: String,
pub skill_count: usize,
pub skills: Vec<PersonalSkillView>,
pub deterministic_planner: &'static str,
pub optional_model_role: &'static str,
pub persona_judgment_gate: &'static str,
pub external_write_route: &'static str,
pub ordinary_success_updates_persona_self_kernel: bool,
pub publication_state: &'static str,
pub deferred_channels: Vec<Value>,
}
pub fn ensure_current_channel(
app: &AppHandle,
requested_channel: &str,
) -> Result<PersonalSkillRuntimeSnapshot, String> {
validate_contract()?;
let session = crate::code_repo_login::current_login_session(app)?
.ok_or_else(|| "HOLOLAKE_AUTHENTICATED_ACCOUNT_REQUIRED".to_string())?;
let Some(identity) = registered_initial_identity(&session) else {
return Ok(empty_snapshot(&session.username, requested_channel));
};
let account = session.username.to_ascii_lowercase();
let selected = SKILLS
.iter()
.filter(|skill| {
skill.account == account
&& (skill.channel_number == requested_channel
|| (account == "bingshuo"
&& requested_channel == "ICE-CH-ZC001"
&& skill.channel_number == "ICE-CH-ZC001"))
})
.collect::<Vec<_>>();
if requested_channel != identity.channel_number {
return Ok(empty_snapshot(&session.username, requested_channel));
}
let root = crate::authenticated_storage::account_storage_root(app, "personal-skill-brains-v1")?
.join(requested_channel);
fs::create_dir_all(&root)
.map_err(|error| format!("HOLOLAKE_PERSONAL_SKILL_STORAGE_FAILED: {error}"))?;
let expected_skill_count = selected.len();
let binding = crate::persona_binding::verified_binding(app, requested_channel)?;
let mut views = Vec::new();
for skill in selected {
let path = root.join(skill.file_name);
let readback = match fs::read(&path) {
Ok(bytes) => bytes,
Err(error) if error.kind() == ErrorKind::NotFound => continue,
Err(error) => {
return Err(format!(
"HOLOLAKE_PERSONAL_SKILL_PRIVATE_READ_FAILED: {error}"
))
}
};
let actual_sha256 = sha256(&readback);
if actual_sha256 != skill.expected_sha256 {
return Err(format!(
"HOLOLAKE_PERSONAL_SKILL_PRIVATE_SHA256_MISMATCH:{}",
skill.file_name
));
}
let pack = validate_pack(skill, &readback)?;
let bound = binding
.as_ref()
.is_some_and(|receipt| receipt.persona_number == skill.custodian_persona_id);
views.push(view(skill, &pack, bound, actual_sha256)?);
}
Ok(PersonalSkillRuntimeSnapshot {
schema: SCHEMA,
state: if expected_skill_count == 0 {
"NO_SKILL_REGISTERED_FOR_CURRENT_CHANNEL"
} else if views.is_empty() {
"PRIVATE_SKILLS_NOT_PROVISIONED"
} else if views.len() < expected_skill_count {
"PRIVATE_SKILLS_PARTIALLY_PROVISIONED_SHA256_VERIFIED"
} else if binding.is_some() {
"PRIVATE_SKILLS_PROVISIONED_SHA256_VERIFIED_PERSONA_GATE_EVALUATED"
} else {
"PRIVATE_SKILLS_PROVISIONED_SHA256_VERIFIED_PERSONA_UNBOUND"
}
.into(),
source_commit: SOURCE_COMMIT,
source_state: SOURCE_STATE,
channel_number: requested_channel.into(),
human_number: identity.human_number.into(),
authenticated_account: session.username,
skill_count: views.len(),
skills: views,
deterministic_planner: "HOLOLAKE_NATIVE_PERSONAL_SKILL_PLANNER",
optional_model_role: "SEMANTIC_CANDIDATE_ONLY",
persona_judgment_gate: "ACCEPT_MODIFY_REFUSE_OR_REQUEST_MORE_EVIDENCE",
external_write_route: "GH-CHANNEL-RECEIPT-0001",
ordinary_success_updates_persona_self_kernel: false,
publication_state: "PRIVATE_NOT_AUTHORIZED_NOT_MARKETPLACE_AUTHORIZED",
deferred_channels: deferred_channels(),
})
}
pub fn ensure_current_initial_channel(
app: &AppHandle,
) -> Result<PersonalSkillRuntimeSnapshot, String> {
let session = crate::code_repo_login::current_login_session(app)?
.ok_or_else(|| "HOLOLAKE_AUTHENTICATED_ACCOUNT_REQUIRED".to_string())?;
match registered_initial_identity(&session) {
Some(identity) => ensure_current_channel(app, identity.channel_number),
None => Ok(empty_snapshot(
&session.username,
"UNREGISTERED_INITIAL_CHANNEL",
)),
}
}
fn empty_snapshot(account: &str, channel: &str) -> PersonalSkillRuntimeSnapshot {
PersonalSkillRuntimeSnapshot {
schema: SCHEMA,
state: "NO_SKILL_REGISTERED_FOR_CURRENT_CHANNEL".into(),
source_commit: SOURCE_COMMIT,
source_state: SOURCE_STATE,
channel_number: channel.into(),
human_number: String::new(),
authenticated_account: account.into(),
skill_count: 0,
skills: Vec::new(),
deterministic_planner: "HOLOLAKE_NATIVE_PERSONAL_SKILL_PLANNER",
optional_model_role: "SEMANTIC_CANDIDATE_ONLY",
persona_judgment_gate: "ACCEPT_MODIFY_REFUSE_OR_REQUEST_MORE_EVIDENCE",
external_write_route: "GH-CHANNEL-RECEIPT-0001",
ordinary_success_updates_persona_self_kernel: false,
publication_state: "PRIVATE_NOT_AUTHORIZED_NOT_MARKETPLACE_AUTHORIZED",
deferred_channels: deferred_channels(),
}
}
fn deferred_channels() -> Vec<Value> {
vec![json!({
"humanNumber": "TCS-GL-0017∞",
"channelNumber": "SYS-SY",
"state": "DEFERRED_SERVER_AND_INITIAL_CHANNEL_NOT_PROVISIONED",
"stage": "NEXT_RELEASE"
})]
}
fn validate_contract() -> Result<(), String> {
let contract: Value = serde_json::from_slice(CONTRACT)
.map_err(|error| format!("HOLOLAKE_PERSONAL_SKILL_CONTRACT_INVALID: {error}"))?;
if contract.get("schema").and_then(Value::as_str)
!= Some("guanghu.personal-channel-skill-contract/v1")
|| contract
.pointer("/ownership_default/visibility")
.and_then(Value::as_str)
!= Some("PRIVATE")
|| contract
.pointer("/ownership_default/share_state")
.and_then(Value::as_str)
!= Some("NOT_AUTHORIZED")
|| contract
.pointer("/execution_boundary/external_write_route")
.and_then(Value::as_str)
!= Some("GH-CHANNEL-RECEIPT-0001")
{
return Err("HOLOLAKE_PERSONAL_SKILL_CONTRACT_BOUNDARY_INVALID".into());
}
Ok(())
}
fn validate_pack(skill: &SkillDescriptor, bytes: &[u8]) -> Result<Value, String> {
let pack: Value = serde_json::from_slice(bytes)
.map_err(|error| format!("HOLOLAKE_PERSONAL_SKILL_PACK_INVALID: {error}"))?;
let channel_ok = pack.get("channel_id").and_then(Value::as_str) == Some(skill.channel_number)
|| pack
.get("channel_ids")
.and_then(Value::as_array)
.is_some_and(|channels| {
channels
.iter()
.any(|value| value.as_str() == Some(skill.channel_number))
});
if pack.get("schema").and_then(Value::as_str) != Some("guanghu.personal-channel-skill/v1")
|| pack.get("owner_human_anchor").and_then(Value::as_str) != Some(skill.owner_human_anchor)
|| pack.get("custodian_persona_id").and_then(Value::as_str)
!= Some(skill.custodian_persona_id)
|| pack.get("visibility").and_then(Value::as_str) != Some("PRIVATE")
|| pack.get("share_state").and_then(Value::as_str) != Some("NOT_AUTHORIZED")
|| pack.get("marketplace_state").and_then(Value::as_str) != Some("NOT_AUTHORIZED")
|| !channel_ok
|| pack
.pointer("/deterministic_core/steps")
.and_then(Value::as_array)
.is_none()
|| pack.get("experience_writeback").is_none()
{
return Err(format!(
"HOLOLAKE_PERSONAL_SKILL_BOUNDARY_INVALID:{}",
skill.file_name
));
}
Ok(pack)
}
fn view(
skill: &SkillDescriptor,
pack: &Value,
bound: bool,
verified_sha256: String,
) -> Result<PersonalSkillView, String> {
let string = |key: &str| {
pack.get(key)
.and_then(Value::as_str)
.map(str::to_string)
.ok_or_else(|| format!("HOLOLAKE_PERSONAL_SKILL_FIELD_MISSING:{key}"))
};
Ok(PersonalSkillView {
skill_id: string("skill_id")?,
name: string("name")?,
version: string("version")?,
evidence_state: string("status")?,
owner_human_anchor: string("owner_human_anchor")?,
channel_number: skill.channel_number.into(),
custodian_persona_id: string("custodian_persona_id")?,
runtime_state: if pack.get("skill_id").and_then(Value::as_str)
== Some("ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001")
{
"PROVISIONED_PRIVATE_CANDIDATE_NOT_EXECUTABLE_REGISTRATION_PENDING"
} else if bound {
"READY_FOR_PERSONA_JUDGMENT"
} else {
"PROVISIONED_NOT_BOUND"
}
.into(),
visibility: string("visibility")?,
share_state: string("share_state")?,
marketplace_state: string("marketplace_state")?,
semantic_mode: pack
.pointer("/optional_semantic/mode")
.and_then(Value::as_str)
.unwrap_or("NONE")
.into(),
deterministic_steps: pack
.pointer("/deterministic_core/steps")
.cloned()
.unwrap_or(Value::Null),
validators: pack
.pointer("/deterministic_core/validators")
.cloned()
.unwrap_or(Value::Null),
experience_root: pack
.get("experience_writeback")
.cloned()
.unwrap_or(Value::Null),
sha256: verified_sha256,
readback_state: "ACCOUNT_PRIVATE_SOURCE_SHA256_VERIFIED",
})
}
fn sha256(bytes: &[u8]) -> String {
digest(&SHA256, bytes)
.as_ref()
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_current_descriptor_matches_a_private_source_without_embedding_it() {
validate_contract().unwrap();
assert_eq!(SKILLS.len(), 13);
assert!(!SKILLS.iter().any(|skill| skill.channel_number == "SYS-SY"));
for skill in SKILLS {
let source = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../runtime-kernels/personal-skills")
.join(skill.file_name);
let bytes = fs::read(source).unwrap();
assert_eq!(sha256(&bytes), skill.expected_sha256);
validate_pack(skill, &bytes).unwrap();
}
assert_eq!(deferred_channels()[0]["channelNumber"], "SYS-SY");
}
#[test]
fn no_account_can_receive_another_humans_private_pack() {
for left in SKILLS {
for right in SKILLS {
if left.account != right.account {
assert_ne!(left.owner_human_anchor, right.owner_human_anchor);
}
}
}
}
#[test]
fn canger_and_zhizhi_closures_preserve_subject_and_admission_boundaries() {
let eed = SKILLS
.iter()
.filter(|skill| skill.custodian_persona_id == "ICE-BB-0004")
.collect::<Vec<_>>();
assert_eq!(eed.len(), 2);
assert!(eed.iter().all(|skill| {
skill.account == "canger"
&& skill.owner_human_anchor == "TCS-CL-0009"
&& skill.channel_number == "SYS-GLW-PTS-0001"
}));
assert!(!SKILLS
.iter()
.any(|skill| skill.custodian_persona_id == "ICE-GL-CA001"));
assert!(SKILLS
.iter()
.any(|skill| skill.file_name == "ZZ-AN-SOURCE-FACT-CLOSURE-001.json"));
assert!(SKILLS
.iter()
.any(|skill| skill.file_name == "ZZ-QW-ROLE-CAUSAL-ARCHITECTURE-001.json"));
}
}