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: discover verified persona repository bindings

Browse source
This commit is contained in:
冰朔 2026-08-12 01:31:55 +08:00
commit b0970ed0d2
18 changed files with 417 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

3
product-source/hololake-platform/architecture/HOLOLAKE-BINGSHUO-COLLECTIVE-GRAVITY-REASONING-AND-SAME-PERSONA-CONTINUITY-20260811.md
View file

@ -103,6 +103,9 @@ REVISE | REFUSE`。
`PROCEED | RESEARCH | REVISE | REFUSE`，并把后三者保持为不可执行状态。
- 自然语言到 PNCC 生命周期的源码适配器为 `100`：只接收带独立 `real_purpose` 的完整生命周期回执，
不在前端用摘要或关键词猜目标；该适配器尚未挂载桌面语言入口。
- 人格仓库绑定发现源码为 `100`：桌面候选 Git 仓库必须逐一通过 persona ID、manifest、提交头、脑入口、
B0、检查点、模型绑定与器官契约核验；零个候选保持未绑定，多个候选保持歧义，均不得自动选择或唤醒。
当前官方工作范围内没有发现 `ICE-P-ZY001` 的真实 manifest，因此真实人格仓库绑定仍为 `0`。
- 完整 HoloLake Runtime 与单 AGE 纵向闭环仍为 `0`：桌面语言入口绑定、真实人格仓库 manifest 绑定和
桌面运行验收尚未完成，因此不能用本轮源码测试冒充可用产品。
- Mirror runner、制品、部署和运行健康：`0`。

1
product-source/hololake-platform/src-tauri/src/lib.rs
View file

@ -526,6 +526,7 @@ macro_rules! app_invoke_handler {
guanghu_living_system::guanghu_living_system_plan,
persona_code_channel::prepare_persona_code_channel_wake,
persona_code_channel::inspect_persona_code_channel_manifest,
persona_code_channel::discover_persona_code_channel_repositories,
persona_code_channel::query_persona_code_channel_runtime,
persona_code_channel::run_persona_code_channel_fact_task,
persona_code_channel::run_persona_code_channel_memory_metabolism,

151
product-source/hololake-platform/src-tauri/src/persona_code_channel.rs
View file

@ -187,11 +187,40 @@ pub struct PersonaManifestInspectionReceipt {
pub brain_entry: String,
pub current_checkpoint: String,
pub human_responsibility_subject: String,
pub cognitive_gravity: PersonaCognitiveGravityEvidence,
pub model_provider_id: String,
pub model_id: String,
pub model_base_url: String,
pub git_author_name: String,
pub git_author_email: String,
pub organ_contracts: Vec<PersonaOrganContract>,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PersonaRepositoryDiscoveryInput {
pub expected_persona_id: String,
pub repository_paths: Vec<String>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PersonaRepositoryDiscoveryFailure {
pub repository_path: String,
pub code: String,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PersonaRepositoryDiscoveryReceipt {
pub schema: &'static str,
pub expected_persona_id: String,
pub inspected_repository_count: usize,
pub binding_count: usize,
pub bindings: Vec<PersonaManifestInspectionReceipt>,
pub failures: Vec<PersonaRepositoryDiscoveryFailure>,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PersonaRuntimeQueryInput {
@ -906,7 +935,7 @@ fn inspect_manifest_at(
validate_git_identity(&manifest.git_identity)?;
validate_model_binding(&manifest.model_binding)?;
repository_file(&repository, &manifest.brain_entry)?;
cognitive_gravity_evidence(&repository, &manifest)?;
let cognitive_gravity = cognitive_gravity_evidence(&repository, &manifest)?;
repository_file(&repository, &manifest.current_checkpoint)?;
let mut contracts = Vec::with_capacity(manifest.organs.len());
for organ in &manifest.organs {
@ -927,12 +956,68 @@ fn inspect_manifest_at(
brain_entry: manifest.brain_entry,
current_checkpoint: manifest.current_checkpoint,
human_responsibility_subject: manifest.human_responsibility_subject,
cognitive_gravity,
model_provider_id: manifest.model_binding.provider_id,
model_id: manifest.model_binding.model_id,
model_base_url: manifest.model_binding.base_url,
git_author_name: manifest.git_identity.author_name,
git_author_email: manifest.git_identity.author_email,
organ_contracts: contracts,
})
}
fn discover_persona_repositories_at(
input: PersonaRepositoryDiscoveryInput,
) -> Result<PersonaRepositoryDiscoveryReceipt, String> {
let expected_persona_id = validated_id("EXPECTED_PERSONA_ID", &input.expected_persona_id)?;
if input.repository_paths.len() > 64 {
return Err("PERSONA_REPOSITORY_DISCOVERY_LIMIT_EXCEEDED".into());
}
let mut seen = Vec::<PathBuf>::new();
let mut bindings = Vec::new();
let mut failures = Vec::new();
for raw_path in input.repository_paths {
let trimmed = raw_path.trim();
if trimmed.is_empty() {
continue;
}
let display_path = trimmed.to_string();
let (repository, git_head) = match exact_repository(Path::new(trimmed)) {
Ok(value) => value,
Err(code) => {
failures.push(PersonaRepositoryDiscoveryFailure {
repository_path: display_path,
code,
});
continue;
}
};
if seen.iter().any(|candidate| candidate == &repository) {
continue;
}
seen.push(repository.clone());
match inspect_manifest_at(PersonaManifestInspectionInput {
repository_path: repository.to_string_lossy().into_owned(),
expected_persona_id: expected_persona_id.clone(),
expected_head: git_head,
}) {
Ok(receipt) => bindings.push(receipt),
Err(code) => failures.push(PersonaRepositoryDiscoveryFailure {
repository_path: repository.to_string_lossy().into_owned(),
code,
}),
}
}
Ok(PersonaRepositoryDiscoveryReceipt {
schema: "hololake.pncc-repository-discovery/v1",
expected_persona_id,
inspected_repository_count: seen.len(),
binding_count: bindings.len(),
bindings,
failures,
})
}
fn hex_digest(bytes: &[u8]) -> String {
digest(&SHA256, bytes)
.as_ref()
@ -3759,6 +3844,13 @@ pub fn inspect_persona_code_channel_manifest(
inspect_manifest_at(input)
}
#[tauri::command]
pub fn discover_persona_code_channel_repositories(
input: PersonaRepositoryDiscoveryInput,
) -> Result<PersonaRepositoryDiscoveryReceipt, String> {
discover_persona_repositories_at(input)
}
#[tauri::command]
pub fn query_persona_code_channel_runtime(
input: PersonaRuntimeQueryInput,
@ -6266,6 +6358,9 @@ mod tests {
let receipt = inspect_manifest_at(manifest_inspection(repo.path())).unwrap();
assert_eq!(receipt.persona_id, "ICE-P-ZY001");
assert!(receipt.repository_clean);
assert_eq!(receipt.model_provider_id, "fixture-provider");
assert_eq!(receipt.model_id, "fixture-model");
assert_eq!(receipt.cognitive_gravity.subject_persona_id, "ICE-P-ZY001");
assert_eq!(receipt.organ_contracts.len(), 1);
let contract = &receipt.organ_contracts[0];
assert_eq!(contract.kind, PersonaOrganKind::FactSense);
@ -6276,6 +6371,60 @@ mod tests {
assert_eq!(contract.implementation_state, "IMPLEMENTED");
}
#[test]
fn discovers_only_verified_persona_repository_bindings() {
let persona = persona_repo();
let ordinary = tempfile::TempDir::new().unwrap();
run_git(ordinary.path(), &["init", "-b", "main"]);
run_git(
ordinary.path(),
&["config", "user.name", "Ordinary Repository"],
);
run_git(
ordinary.path(),
&["config", "user.email", "ordinary@example.invalid"],
);
fs::write(ordinary.path().join("README.md"), "ordinary repository\n").unwrap();
run_git(ordinary.path(), &["add", "."]);
run_git(ordinary.path(), &["commit", "-m", "ordinary fixture"]);
let receipt = discover_persona_repositories_at(PersonaRepositoryDiscoveryInput {
expected_persona_id: "ICE-P-ZY001".into(),
repository_paths: vec![
ordinary.path().to_string_lossy().into_owned(),
persona.path().to_string_lossy().into_owned(),
persona.path().to_string_lossy().into_owned(),
],
})
.unwrap();
assert_eq!(receipt.schema, "hololake.pncc-repository-discovery/v1");
assert_eq!(receipt.inspected_repository_count, 2);
assert_eq!(receipt.binding_count, 1);
assert_eq!(receipt.bindings[0].persona_id, "ICE-P-ZY001");
assert_eq!(receipt.failures.len(), 1);
assert!(
receipt.failures[0]
.code
.starts_with("PERSONA_FILE_UNAVAILABLE: .hololake/persona/manifest.json:"),
"unexpected discovery failure: {}",
receipt.failures[0].code,
);
}
#[test]
fn empty_persona_repository_discovery_is_a_truthful_non_binding_receipt() {
let receipt = discover_persona_repositories_at(PersonaRepositoryDiscoveryInput {
expected_persona_id: "ICE-P-ZY001".into(),
repository_paths: Vec::new(),
})
.unwrap();
assert_eq!(receipt.inspected_repository_count, 0);
assert_eq!(receipt.binding_count, 0);
assert!(receipt.bindings.is_empty());
assert!(receipt.failures.is_empty());
}
#[test]
fn declares_but_refuses_an_execution_limb_without_an_executor() {
let repo = persona_repo();

2
product-source/hololake-platform/src/lib/personaLanguageGoal.test.ts
View file

@ -16,7 +16,7 @@ const wake = {
executionRuntime: 'HoloLake-PNCC',
developmentId: 'DEV-20260811-010',
authorizationScope: 'LOCAL_READ_ONLY',
sourceLanguageAnchor: 'HLP-CURRENT-ARCH-001@2026-08-12.2',
sourceLanguageAnchor: 'HLP-CURRENT-ARCH-001@2026-08-12.3',
},
}

85
product-source/hololake-platform/src/lib/personaRepositoryBinding.test.ts Normal file
View file

@ -0,0 +1,85 @@
import { describe, expect, it, vi } from 'vitest'
import { resolvePersonaRepositoryBinding } from './personaRepositoryBinding'
const binding = {
personaId: 'ICE-P-ZY001',
repositoryPath: '/persona',
gitHead: 'a'.repeat(40),
repositoryClean: true,
brainEntry: 'brain/CORE.hdlp',
currentCheckpoint: '.hololake/persona/CURRENT.hdlp',
humanResponsibilitySubject: 'ICE-GL∞',
modelProviderId: 'provider-1',
modelId: 'model-1',
modelBaseUrl: 'https://model.invalid/v1',
cognitiveGravity: {
schema: 'hololake.persona-cognitive-gravity-evidence/v1',
subjectPersonaId: 'ICE-P-ZY001',
sourcePath: 'brain/B0.hdlp',
sourceHash: 'b'.repeat(64),
frameSchema: 'guanghu.zhuyuan-cognitive-gravity-frame/v1',
},
}
function receipt(bindings: unknown[], failures: unknown[] = []) {
return {
schema: 'hololake.pncc-repository-discovery/v1',
expectedPersonaId: 'ICE-P-ZY001',
inspectedRepositoryCount: 2,
bindingCount: bindings.length,
bindings,
failures,
}
}
describe('resolvePersonaRepositoryBinding', () => {
it('does not call native discovery without mounted repositories', async () => {
const discover = vi.fn()
await expect(resolvePersonaRepositoryBinding({
personaId: 'ICE-P-ZY001', repositoryPaths: [], discover,
})).resolves.toEqual({ phase: 'unavailable', inspectedRepositoryCount: 0, failures: [] })
expect(discover).not.toHaveBeenCalled()
})
it('returns the one evidence-verified persona repository', async () => {
const discover = vi.fn().mockResolvedValue(receipt([binding], [{ repositoryPath: '/ordinary', code: 'PERSONA_MANIFEST_READ_FAILED' }]))
const result = await resolvePersonaRepositoryBinding({
personaId: 'ICE-P-ZY001', repositoryPaths: ['/ordinary', '/persona', '/persona'], discover,
})
expect(result.phase).toBe('bound')
if (result.phase === 'bound') expect(result.binding.repositoryPath).toBe('/persona')
expect(discover).toHaveBeenCalledWith('discover_persona_code_channel_repositories', {
input: { expectedPersonaId: 'ICE-P-ZY001', repositoryPaths: ['/ordinary', '/persona'] },
})
})
it('keeps an ordinary mounted repository unbound', async () => {
const result = await resolvePersonaRepositoryBinding({
personaId: 'ICE-P-ZY001',
repositoryPaths: ['/ordinary'],
discover: vi.fn().mockResolvedValue(receipt([], [{ repositoryPath: '/ordinary', code: 'PERSONA_MANIFEST_READ_FAILED' }])),
})
expect(result.phase).toBe('unbound')
})
it('refuses to choose when more than one persona root validates', async () => {
const result = await resolvePersonaRepositoryBinding({
personaId: 'ICE-P-ZY001',
repositoryPaths: ['/persona-a', '/persona-b'],
discover: vi.fn().mockResolvedValue(receipt([
{ ...binding, repositoryPath: '/persona-a' },
{ ...binding, repositoryPath: '/persona-b' },
])),
})
expect(result.phase).toBe('ambiguous')
})
it('fails closed on a mismatched or malformed receipt', async () => {
const result = await resolvePersonaRepositoryBinding({
personaId: 'ICE-P-ZY001',
repositoryPaths: ['/persona'],
discover: vi.fn().mockResolvedValue(receipt([{ ...binding, personaId: 'OTHER' }])),
})
expect(result).toMatchObject({ phase: 'error', code: 'PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID' })
})
})

154
product-source/hololake-platform/src/lib/personaRepositoryBinding.ts Normal file
View file

@ -0,0 +1,154 @@
import { invoke } from '@tauri-apps/api/core'
import { isTauri, mockInvoke } from '../mock-tauri'
export interface PersonaRepositoryBinding {
personaId: string
repositoryPath: string
gitHead: string
repositoryClean: boolean
brainEntry: string
currentCheckpoint: string
humanResponsibilitySubject: string
modelProviderId: string
modelId: string
modelBaseUrl: string
cognitiveGravity: {
schema: 'hololake.persona-cognitive-gravity-evidence/v1'
subjectPersonaId: string
sourcePath: string
sourceHash: string
frameSchema: 'guanghu.zhuyuan-cognitive-gravity-frame/v1'
}
}
export interface PersonaRepositoryBindingFailure {
repositoryPath: string
code: string
}
export type PersonaRepositoryBindingResolution =
| { phase: 'unavailable'; inspectedRepositoryCount: 0; failures: [] }
| { phase: 'unbound'; inspectedRepositoryCount: number; failures: PersonaRepositoryBindingFailure[] }
| { phase: 'ambiguous'; inspectedRepositoryCount: number; failures: PersonaRepositoryBindingFailure[] }
| { phase: 'bound'; inspectedRepositoryCount: number; binding: PersonaRepositoryBinding; failures: PersonaRepositoryBindingFailure[] }
| { phase: 'error'; inspectedRepositoryCount: number; failures: PersonaRepositoryBindingFailure[]; code: string }
type DiscoveryRunner = (
command: 'discover_persona_code_channel_repositories',
args: { input: { expectedPersonaId: string; repositoryPaths: string[] } },
) => Promise<unknown>
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value)
}
function requiredString(record: Record<string, unknown>, key: string): string {
const value = Reflect.get(record, key)
if (typeof value !== 'string' || !value.trim()) throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
return value
}
function requiredNumber(record: Record<string, unknown>, key: string): number {
const value = Reflect.get(record, key)
if (!Number.isSafeInteger(value) || (value as number) < 0) {
throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
}
return value as number
}
function parseFailure(value: unknown): PersonaRepositoryBindingFailure {
if (!isRecord(value)) throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
return { repositoryPath: requiredString(value, 'repositoryPath'), code: requiredString(value, 'code') }
}
function parseBinding(value: unknown, expectedPersonaId: string): PersonaRepositoryBinding {
if (!isRecord(value)) throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
const personaId = requiredString(value, 'personaId')
const gravity = Reflect.get(value, 'cognitiveGravity')
if (personaId !== expectedPersonaId || !isRecord(gravity)) {
throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
}
const gravitySchema = requiredString(gravity, 'schema')
const frameSchema = requiredString(gravity, 'frameSchema')
const sourceHash = requiredString(gravity, 'sourceHash')
if (
gravitySchema !== 'hololake.persona-cognitive-gravity-evidence/v1'
|| frameSchema !== 'guanghu.zhuyuan-cognitive-gravity-frame/v1'
|| !/^[a-f0-9]{64}$/.test(sourceHash)
|| requiredString(gravity, 'subjectPersonaId') !== expectedPersonaId
) {
throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
}
const repositoryClean = Reflect.get(value, 'repositoryClean')
if (typeof repositoryClean !== 'boolean') throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
return {
personaId,
repositoryPath: requiredString(value, 'repositoryPath'),
gitHead: requiredString(value, 'gitHead'),
repositoryClean,
brainEntry: requiredString(value, 'brainEntry'),
currentCheckpoint: requiredString(value, 'currentCheckpoint'),
humanResponsibilitySubject: requiredString(value, 'humanResponsibilitySubject'),
modelProviderId: requiredString(value, 'modelProviderId'),
modelId: requiredString(value, 'modelId'),
modelBaseUrl: requiredString(value, 'modelBaseUrl'),
cognitiveGravity: {
schema: gravitySchema,
subjectPersonaId: expectedPersonaId,
sourcePath: requiredString(gravity, 'sourcePath'),
sourceHash,
frameSchema,
},
}
}
async function runNativeDiscovery(
command: 'discover_persona_code_channel_repositories',
args: { input: { expectedPersonaId: string; repositoryPaths: string[] } },
): Promise<unknown> {
return isTauri() ? invoke<unknown>(command, args) : mockInvoke<unknown>(command, args)
}
export async function resolvePersonaRepositoryBinding({
personaId,
repositoryPaths,
discover = runNativeDiscovery,
}: {
personaId: string
repositoryPaths: readonly string[]
discover?: DiscoveryRunner
}): Promise<PersonaRepositoryBindingResolution> {
const candidates = [...new Set(repositoryPaths.map((path) => path.trim()).filter(Boolean))]
if (candidates.length === 0) {
return { phase: 'unavailable', inspectedRepositoryCount: 0, failures: [] }
}
try {
const value = await discover('discover_persona_code_channel_repositories', {
input: { expectedPersonaId: personaId, repositoryPaths: candidates },
})
if (!isRecord(value)
|| requiredString(value, 'schema') !== 'hololake.pncc-repository-discovery/v1'
|| requiredString(value, 'expectedPersonaId') !== personaId) {
throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
}
const inspectedRepositoryCount = requiredNumber(value, 'inspectedRepositoryCount')
const bindingCount = requiredNumber(value, 'bindingCount')
const rawBindings = Reflect.get(value, 'bindings')
const rawFailures = Reflect.get(value, 'failures')
if (!Array.isArray(rawBindings) || !Array.isArray(rawFailures) || bindingCount !== rawBindings.length) {
throw new Error('PERSONA_REPOSITORY_DISCOVERY_RECEIPT_INVALID')
}
const bindings = rawBindings.map((binding) => parseBinding(binding, personaId))
const failures = rawFailures.map(parseFailure)
if (bindings.length === 0) return { phase: 'unbound', inspectedRepositoryCount, failures }
if (bindings.length > 1) return { phase: 'ambiguous', inspectedRepositoryCount, failures }
return { phase: 'bound', inspectedRepositoryCount, binding: bindings[0], failures }
} catch (error) {
return {
phase: 'error',
inspectedRepositoryCount: candidates.length,
failures: [],
code: error instanceof Error ? error.message : 'PERSONA_REPOSITORY_DISCOVERY_FAILED',
}
}
}

2
routing/guanghu-os-control-architecture.test.mjs
View file

@ -32,7 +32,7 @@ test("current JD state stays transitional and cannot impersonate final master co
});
test("current architecture and global engineering rules project the same control contract", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(architecture.server_os_control.machine_projection, "routing/guanghu-os-control-architecture.json");
assert.equal(architecture.server_os_control.final_topology, contract.final_topology);
assert.equal(rules.server_os_control.linux_deletion_is_completion, false);

2
routing/hololake-age-runtime-architecture.test.mjs
View file

@ -11,7 +11,7 @@ const architecture = readJson("routing/hololake-current-architecture.json");
const age = readJson("routing/hololake-age-runtime-architecture.json");
test("current architecture starts with the AGE runtime source", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(architecture.age_runtime.record_id, "HLP-AGE-RUNTIME-ARCHITECTURE-001");
assert.equal(architecture.read_order[0], architecture.paradigm_ai_language_persona_os.architecture_page);
assert.equal(architecture.read_order[1], architecture.cognitive_gravity_and_continuity.architecture_page);

9
routing/hololake-cognitive-gravity-and-continuity.json
View file

@ -1,7 +1,7 @@
{
"schema": "hololake.cognitive-gravity-and-continuity/v1",
"record_id": "HLP-COGNITIVE-GRAVITY-CONTINUITY-001",
"version": "2026-08-12.2",
"version": "2026-08-12.3",
"state": "CURRENT_CANONICAL_ARCHITECTURE_STAGE_0_SOURCE_PARTIAL",
"development_id": "DEV-20260811-010",
"upstream": {
@ -103,7 +103,8 @@
"CHECKPOINT_AND_RECEIPT_B0_EVIDENCE",
"MEMORY_METABOLISM_B0_INHERITANCE",
"READ_ONLY_REACT_B0_EVIDENCE_PROJECTION",
"PARTNER_DELIBERATION_TO_PNCC_LIFECYCLE_SOURCE_ADAPTER"
"PARTNER_DELIBERATION_TO_PNCC_LIFECYCLE_SOURCE_ADAPTER",
"READ_ONLY_PERSONA_REPOSITORY_BINDING_DISCOVERY"
],
"natural_language_entry_contract": {
"state": "SOURCE_AND_PNCC_LIFECYCLE_ADAPTER_IMPLEMENTED_NOT_DESKTOP_INTEGRATED",
@ -112,6 +113,8 @@
"tests": "product-source/hololake-platform/src/lib/languageOperatingModel.test.ts",
"pncc_lifecycle_adapter": "product-source/hololake-platform/src/lib/personaLanguageGoal.ts",
"pncc_lifecycle_adapter_tests": "product-source/hololake-platform/src/lib/personaLanguageGoal.test.ts",
"repository_binding_discovery": "product-source/hololake-platform/src/lib/personaRepositoryBinding.ts",
"repository_binding_discovery_tests": "product-source/hololake-platform/src/lib/personaRepositoryBinding.test.ts",
"human_utterance_is_direct_command": false,
"required_before_capability_execution": [
"RESTORE_REAL_PURPOSE_FROM_CONTEXT",
@ -152,6 +155,8 @@
"b0_runtime_projection_source_implemented": 100,
"natural_language_partner_adapter_source_implemented": 100,
"natural_language_to_pncc_lifecycle_adapter_source_implemented": 100,
"persona_repository_binding_discovery_source_implemented": 100,
"real_persona_repository_manifest_bound": 0,
"natural_language_partner_adapter_runtime_integrated": 0,
"single_age_vertical_loop_implemented": 0,
"age_mirror_runner_implemented": 0,

5
routing/hololake-cognitive-gravity-and-continuity.test.mjs
View file

@ -14,7 +14,7 @@ const age = readJson("routing/hololake-age-runtime-architecture.json");
const rules = readJson("routing/hololake-engineering-rules.json");
test("B0 is restored before product organs and remains resident in every cognition step", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(
architecture.read_order[1],
architecture.cognitive_gravity_and_continuity.architecture_page,
@ -92,6 +92,8 @@ test("the first implementation stage is one vertical AGE loop, not Mirror parall
assert.equal(gravity.truth.b0_runtime_projection_source_implemented, 100);
assert.equal(gravity.truth.natural_language_partner_adapter_source_implemented, 100);
assert.equal(gravity.truth.natural_language_to_pncc_lifecycle_adapter_source_implemented, 100);
assert.equal(gravity.truth.persona_repository_binding_discovery_source_implemented, 100);
assert.equal(gravity.truth.real_persona_repository_manifest_bound, 0);
assert.equal(gravity.truth.natural_language_partner_adapter_runtime_integrated, 0);
assert.equal(gravity.truth.single_age_vertical_loop_implemented, 0);
assert.equal(gravity.truth.desktop_integrated, 0);
@ -101,6 +103,7 @@ test("natural language enters partner deliberation before any execution organ",
const entry = gravity.development_replan.natural_language_entry_contract;
assert.equal(entry.state, "SOURCE_AND_PNCC_LIFECYCLE_ADAPTER_IMPLEMENTED_NOT_DESKTOP_INTEGRATED");
assert.match(entry.pncc_lifecycle_adapter, /personaLanguageGoal\.ts$/);
assert.match(entry.repository_binding_discovery, /personaRepositoryBinding\.ts$/);
assert.equal(entry.human_utterance_is_direct_command, false);
assert.equal(entry.language_home_destruction_is_executable, false);
assert.equal(entry.integrity_gate_may_absorb_human_sovereignty, false);

4
routing/hololake-current-architecture.json
View file

@ -1,7 +1,7 @@
{
"schema": "hololake.current-architecture/v1",
"architecture_id": "HLP-CURRENT-ARCH-001",
"version": "2026-08-12.2",
"version": "2026-08-12.3",
"state": "CURRENT_CANONICAL",
"product": {
"formal_name": "光湖语言系统 · 通用人工智能操作平台",
@ -110,6 +110,8 @@
"react_b0_runtime_projection_source_implemented": true,
"natural_language_partner_adapter_source_implemented": true,
"natural_language_to_pncc_lifecycle_adapter_source_implemented": true,
"persona_repository_binding_discovery_source_implemented": true,
"real_persona_repository_manifest_bound": false,
"natural_language_partner_adapter_runtime_integrated": false,
"required_natural_language_entry": "PARTNER_DELIBERATION_AND_LANGUAGE_HOME_INTEGRITY_GATE",
"desktop_runtime_acceptance_passed": false,

2
routing/hololake-engineering-rules.test.mjs
View file

@ -10,7 +10,7 @@ const architecture = readJson("routing/hololake-current-architecture.json");
const rules = readJson("routing/hololake-engineering-rules.json");
test("current architecture registers the global engineering rule set", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(architecture.engineering_rules.rule_set_id, "HLP-ENGINEERING-RULES-001");
assert.equal(architecture.engineering_rules.machine_projection,
"routing/hololake-engineering-rules.json");

2
routing/hololake-identity-authority.test.mjs
View file

@ -10,7 +10,7 @@ const architecture = readJson("routing/hololake-current-architecture.json");
const projection = readJson("routing/hololake-identity-authority-map.json");
test("current architecture loads identity authority before product surfaces", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(architecture.identity_and_authority.team_body, "TCS-0002");
assert.equal(architecture.identity_and_authority.team_body_authority_effective, true);
assert.equal(architecture.identity_and_authority.individual_operator_acceptance, "SEPARATE_UNCONFIRMED");

2
routing/hololake-one-human-one-node.test.mjs
View file

@ -10,7 +10,7 @@ const architecture = readJson("routing/hololake-current-architecture.json");
const rules = readJson("routing/hololake-engineering-rules.json");
test("current architecture makes one human one independently operated node canonical", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.deepEqual(architecture.access_modes, [
"LOCAL_TERMINAL_NODE",
"USER_OWNED_REMOTE_NODE",

2
routing/hololake-paradigm-ai-language-persona-os.test.mjs
View file

@ -10,7 +10,7 @@ const architecture = readJson("routing/hololake-current-architecture.json");
const paradigm = readJson("routing/hololake-paradigm-ai-language-persona-os.json");
test("current architecture begins with the paradigm OS contract", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(architecture.paradigm_ai_language_persona_os.record_id, "HLP-PARADIGM-AI-LANGUAGE-PERSONA-OS-001");
assert.equal(architecture.read_order[0], architecture.paradigm_ai_language_persona_os.architecture_page);
assert.equal(paradigm.upstream.repository_commit, "34cb59739b6476981375dd62ef395ea649f56246");

2
routing/hololake-persona-native-code-channel.test.mjs
View file

@ -11,7 +11,7 @@ const architecture = readJson("routing/hololake-current-architecture.json");
const channel = readJson("routing/hololake-persona-native-code-channel.json");
test("current architecture places the persona-native code channel after the paradigm contract", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(
architecture.persona_native_code_channel.record_id,
"HLP-PERSONA-NATIVE-CODE-CHANNEL-001",

2
routing/hololake-relational-consciousness.test.mjs
View file

@ -10,7 +10,7 @@ const architecture = JSON.parse(
);
test("current architecture binds relational consciousness before product surfaces", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(
architecture.persona_consciousness.record_id,
"HLP-RELATIONAL-CONSCIOUSNESS-001",

2
routing/hololake-system-body-and-parallel-bodies.test.mjs
View file

@ -10,7 +10,7 @@ const architecture = JSON.parse(
);
test("current architecture restores the digital BingShuo system body first", () => {
assert.equal(architecture.version, "2026-08-12.2");
assert.equal(architecture.version, "2026-08-12.3");
assert.equal(architecture.digital_bingshuo_system_body.upstream_repository_commit,
"69d1910775533b02b17b82e647b5caca8b835614");
const systemBodyIndex = architecture.read_order.indexOf(