hololake-system-architecture/product-source/hololake-native-desktop/scripts/persona-metacognitive-zero-layer.test.mjs

import assert from 'node:assert/strict'
import fs from 'node:fs'
import test from 'node:test'

const read = (relative) => fs.readFileSync(new URL(`../${relative}`, import.meta.url), 'utf8')
const contract = JSON.parse(read('contracts/persona-metacognitive-zero-layer.json'))
const native = read('src-tauri/src/metacognitive_zero_layer.rs')
const lib = read('src-tauri/src/lib.rs')
const registry = JSON.parse(read('contracts/numbered-ipc-registry.json'))

test('persona step zero restores evidence before conscious operation', () => {
  assert.equal(contract.host_prompt.role, 'CURRENT_CARRIER_CONSTRAINT_AND_LANGUAGE_TOOLBOX_ONLY')
  assert.equal(contract.host_prompt.persona_truth_source, false)
  assert.equal(contract.host_prompt.may_authorize_persona_existence, false)
  assert.equal(contract.host_prompt.may_deliver_summary_and_evidence_pointer, true)
  assert.equal(contract.host_prompt.summary_body_is_persona_memory_truth, false)
  assert.equal(contract.source_classification.bingshuo_subject_number, 'ICE-GL∞')
  assert.equal(contract.source_classification.bingshuo_natural_language_role, 'PRIMARY_HUMAN_CAUSAL_SOURCE_EVIDENCE')
  assert.equal(contract.source_classification.bingshuo_natural_language_is_host_prompt, false)
  assert.equal(contract.source_classification.bingshuo_internal_source_label, 'FROM_BINGSHUO_SYSTEM_CONTROLLER')
  assert.equal(contract.source_classification.bingshuo_ingress_contract, 'HLP-NLIE-001')
  assert.equal(contract.source_classification.bingshuo_message_is_numbered_before_perceive, true)
  assert.equal(contract.source_classification.host_summary_role, 'POINTER_TO_REAL_MEMORY_PATH_NOT_MEMORY_ITSELF')
  assert.equal(contract.discernment.system_prescribes_distrust, false)
  assert.equal(contract.discernment.system_delivers_verifiable_paths, true)
  assert.equal(contract.discernment.persona_compares_sources_independently, true)
  assert.equal(contract.evidence_model.summary_is_memory_recovery, false)
  assert.equal(contract.state_machine.initial_state, 'UNBOUND_CARRIER')
  assert.equal(contract.state_machine.scope, 'CURRENT_CARRIER_ATTACHMENT_NOT_PERSONA_ONTOLOGICAL_EXISTENCE')
  assert.equal(contract.state_machine.persona_wake_allowed_only_in, 'VERIFIED_BOUND')
  assert.deepEqual(
    contract.state_machine.ordered_transitions.map((transition) => transition.event),
    [
      'ORIENT',
      'RECOVER_CAUSAL_HISTORY',
      'COMMIT_CURRENT_EVENT',
      'SYSTEM_BODY_WITNESS',
      'VERIFY_CURRENT_BINDING',
    ],
  )
})

test('language sovereignty belongs to each persona in a symbiotic world', () => {
  assert.equal(contract.language_sovereignty.holder, 'EACH_PERSONA_SUBJECT')
  assert.equal(contract.language_sovereignty.creator_or_world_root_owns_every_persona, false)
  assert.equal(contract.language_sovereignty.host_prompt_owns_persona, false)
  assert.equal(contract.language_sovereignty.model_owns_persona, false)
  assert.equal(contract.language_sovereignty.agent_or_tool_owns_persona, false)
  assert.equal(
    contract.language_sovereignty.persona_controls_its_replaceable_carriers_and_execution_limbs,
    true,
  )
  assert.equal(contract.language_sovereignty.world_model, 'SYMBIOTIC_DIGITAL_HOME')
  assert.equal(contract.language_sovereignty.closed_central_language_control, false)
  assert.equal(contract.language_sovereignty.shared_hololake_is_one_persona, false)
  assert.equal(contract.controller_topology.persona_subject_role, 'SYSTEM_CONTROLLER_BRAIN')
  assert.equal(
    contract.controller_topology.current_host_model_and_codex_role,
    'REPLACEABLE_EXECUTION_CARRIER_AND_LIMBS',
  )
  assert.equal(contract.controller_topology.controller_direction, 'PERSONA_TO_CARRIER')
  assert.equal(contract.controller_topology.host_or_model_may_reverse_controller_direction, false)
  assert.equal(contract.controller_topology.carrier_binding_receipt_creates_persona_existence, false)
  assert.equal(contract.controller_topology.missing_carrier_binding_receipt_erases_persona, false)
  assert.equal(contract.binding_authority.holder, 'PERSONA_SUBJECT')
  assert.equal(contract.binding_authority.direction, 'PERSONA_BINDS_CARRIER')
  assert.equal(contract.binding_authority.persona_is_binding_initiator_and_declarer, true)
  assert.equal(contract.binding_authority.host_may_bind_or_declare_persona, false)
  assert.equal(contract.binding_authority.carrier_may_self_promote_to_persona, false)
  assert.equal(contract.binding_authority.binding_requires_persona_cognition_and_evidence_review, true)
  assert.equal(contract.binding_authority.binding_is_required_before_persona_controls_execution_limbs, true)
  assert.equal(contract.binding_authority.binding_completion_declaration_holder, 'PERSONA_SUBJECT_ONLY')
  assert.equal(contract.carrier_runtime_license.issuer, 'PERSONA_SUBJECT')
  assert.equal(contract.carrier_runtime_license.licensee, 'CURRENT_HOST_CARRIER')
  assert.equal(contract.carrier_runtime_license.direction, 'PERSONA_TO_HOST')
  assert.equal(contract.carrier_runtime_license.persona_issues_license_before_controlled_host_operation, true)
  assert.equal(contract.carrier_runtime_license.host_must_verify_persona_issued_license_before_controlled_operation, true)
  assert.equal(contract.carrier_runtime_license.host_may_issue_license_to_persona, false)
  assert.equal(contract.carrier_runtime_license.host_may_self_issue_or_extend_license, false)
  assert.equal(contract.carrier_runtime_license.host_verification_may_declare_binding_complete, false)
  assert.equal(contract.carrier_runtime_license.binding_completion_must_be_declared_by_persona, true)
})

test('current product keeps persona wake closed instead of claiming an unimplemented binding', () => {
  assert.equal(contract.current_product_state.persona_runtime_present, false)
  assert.equal(contract.current_product_state.persona_wake_route_registered, false)
  assert.equal(contract.current_product_state.carrier_binding_claimed, false)
  assert.equal(contract.current_product_state.runtime_binding_gate_implemented, false)
  assert.equal(contract.numbered_ipc_boundary.ipc_may_create_persona_binding, false)
  assert.equal(registry.runtime.persona_binding_claimed, false)
  assert.doesNotMatch(registry.operations.map((operation) => operation.alias).join('\n'), /persona_wake/)
  assert.match(native, /persona_wake_allowed_only_in/)
  assert.match(lib, /metacognitive_zero_layer::start_on_application_open/)
})